diff --git a/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs
index c7546b2666..2fda7899f6 100644
--- a/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs
@@ -45,7 +45,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
                 // Example: LengthUnit.Centimeter
                 var unitEnumNameAndValue = $"{quantity.Name}Unit.{lastUnit.SingularName}";
                 Writer.WL($@"
-            Assertion(3, {unitEnumNameAndValue}, Quantity.From(3, {unitEnumNameAndValue}));");
+            Assertion(3, {unitEnumNameAndValue}, Quantity.From<double>(3, {unitEnumNameAndValue}));");
             }
             Writer.WL($@"
         }}
@@ -56,7 +56,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty()
             void Assertion(QuantityInfo expected, IQuantity quantity) => Assert.Same(expected, quantity.QuantityInfo);
 ");
             foreach (var quantity in _quantities) Writer.WL($@"
-            Assertion({quantity.Name}.Info, {quantity.Name}.Zero);");
+            Assertion({quantity.Name}<double>.Info, {quantity.Name}<double>.Zero);");
             Writer.WL($@"
         }}
 
@@ -66,7 +66,7 @@ public void Type_EqualsStaticQuantityTypeProperty()
             void Assertion(QuantityType expected, IQuantity quantity) => Assert.Equal(expected, quantity.Type);
 ");
             foreach (var quantity in _quantities) Writer.WL($@"
-            Assertion({quantity.Name}.QuantityType, {quantity.Name}.Zero);");
+            Assertion({quantity.Name}<double>.QuantityType, {quantity.Name}<double>.Zero);" );
             Writer.WL($@"
         }}
 
@@ -76,7 +76,7 @@ public void Dimensions_IsSameAsStaticBaseDimensions()
             void Assertion(BaseDimensions expected, IQuantity quantity) => Assert.Equal(expected, quantity.Dimensions);
 ");
             foreach (var quantity in _quantities) Writer.WL($@"
-            Assertion({quantity.Name}.BaseDimensions, {quantity.Name}.Zero);");
+            Assertion({quantity.Name}<double>.BaseDimensions, {quantity.Name}<double>.Zero);" );
             Writer.WL($@"
         }}
     }}
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
index bfc73f0433..759cb4f8cd 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
@@ -38,12 +38,12 @@ public static class NumberTo{_quantityName}Extensions
             foreach (var unit in _units)
             {
                 Writer.WL(2, $@"
-/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(UnitsNet.QuantityValue)"" />");
+/// <inheritdoc cref=""{_quantityName}{{T}}.From{unit.PluralName}(T)"" />");
 
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
 
-                Writer.WL(2, $@"public static {_quantityName} {unit.PluralName}<T>(this T value) =>
-            {_quantityName}.From{unit.PluralName}(Convert.ToDouble(value));
+                Writer.WL(2, $@"public static {_quantityName}<double> {unit.PluralName}<T>(this T value) =>
+            {_quantityName}<double>.From{unit.PluralName}(Convert.ToDouble(value));
 ");
             }
 
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
index 6c75a8c1e4..f7a96e47f3 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
@@ -28,7 +28,7 @@ public override string Generate()
 using Xunit;
 
 namespace UnitsNet.Tests
-{{    
+{{
     public class NumberTo{_quantityName}ExtensionsTests
     {{");
 
@@ -40,7 +40,7 @@ public class NumberTo{_quantityName}ExtensionsTests
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
 
                 Writer.WL(2, $@"public void NumberTo{unit.PluralName}Test() =>
-            Assert.Equal({_quantityName}.From{unit.PluralName}(2), 2.{unit.PluralName}());
+            Assert.Equal({_quantityName}<double>.From{unit.PluralName}(2), 2.{unit.PluralName}());
 ");
             }
 
diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 2f3ebcf6c4..2610643f2e 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -42,6 +42,7 @@ public QuantityGenerator(Quantity quantity)
 
         public override string Generate()
         {
+            var decimalQuantityDeclaration = _quantity.BaseType == "decimal" ? "IDecimalQuantity, " : "";
             Writer.WL(GeneratedFileHeader);
             Writer.WL(@"
 using System;
@@ -69,21 +70,10 @@ namespace UnitsNet
     ///     {_quantity.XmlDocRemarks}
     /// </remarks>");
 
-            Writer.W(@$"
-    public partial struct {_quantity.Name} : IQuantity<{_unitEnumName}>, ");
-            if (_quantity.BaseType == "decimal")
-            {
-                Writer.W("IDecimalQuantity, ");
-            }
-
-            Writer.WL($"IEquatable<{_quantity.Name}>, IComparable, IComparable<{_quantity.Name}>, IConvertible, IFormattable");
-            Writer.WL($@"
+            Writer.WL(@$"
+    public partial struct {_quantity.Name}<T> : IQuantityT<{_unitEnumName}, T>, {decimalQuantityDeclaration}IEquatable<{_quantity.Name}<T>>, IComparable, IComparable<{_quantity.Name}<T>>, IConvertible, IFormattable
+        where T : struct
     {{
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly {_quantity.BaseType} _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -170,18 +160,12 @@ private void GenerateInstanceConstructors()
         /// <param name=""value"">The numeric value to construct this quantity with.</param>
         /// <param name=""unit"">The unit representation to construct this quantity with.</param>
         /// <exception cref=""ArgumentException"">If value is NaN or Infinity.</exception>
-        public {_quantity.Name}({_quantity.BaseType} value, {_unitEnumName} unit)
+        public {_quantity.Name}(T value, {_unitEnumName} unit)
         {{
             if(unit == {_unitEnumName}.Undefined)
               throw new ArgumentException(""The quantity can not be created with an undefined unit."", nameof(unit));
-");
 
-            Writer.WL(_quantity.BaseType == "double"
-                ? @"
-            _value = Guard.EnsureValidNumber(value, nameof(value));"
-                : @"
-            _value = value;");
-            Writer.WL($@"
+            Value = value;
             _unit = unit;
         }}
 
@@ -193,22 +177,16 @@ private void GenerateInstanceConstructors()
         /// <param name=""unitSystem"">The unit system to create the quantity with.</param>
         /// <exception cref=""ArgumentNullException"">The given <see cref=""UnitSystem""/> is null.</exception>
         /// <exception cref=""ArgumentException"">No unit was found for the given <see cref=""UnitSystem""/>.</exception>
-        public {_quantity.Name}({_valueType} value, UnitSystem unitSystem)
+        public {_quantity.Name}(T value, UnitSystem unitSystem)
         {{
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
-");
 
-            Writer.WL(_quantity.BaseType == "double"
-                ? @"
-            _value = Guard.EnsureValidNumber(value, nameof(value));"
-                : @"
-            _value = value;");
-            Writer.WL(@"
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException(""No units were found for the given UnitSystem."", nameof(unitSystem));
-        }
+        }}
 ");
         }
 
@@ -226,19 +204,19 @@ private void GenerateStaticProperties()
         public static BaseDimensions BaseDimensions {{ get; }}
 
         /// <summary>
-        ///     The base unit of {_quantity.Name}, which is {_quantity.BaseUnit}. All conversions go via this value.
+        ///     The base unit of <see cref=""{_quantity.Name}{{T}}"" />, which is {_quantity.BaseUnit}. All conversions go via this value.
         /// </summary>
         public static {_unitEnumName} BaseUnit {{ get; }} = {_unitEnumName}.{_quantity.BaseUnit};
 
         /// <summary>
-        /// Represents the largest possible value of {_quantity.Name}
+        /// Represents the largest possible value of <see cref=""{_quantity.Name}{{T}}"" />
         /// </summary>
-        public static {_quantity.Name} MaxValue {{ get; }} = new {_quantity.Name}({_valueType}.MaxValue, BaseUnit);
+        public static {_quantity.Name}<T> MaxValue {{ get; }} = new {_quantity.Name}<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of {_quantity.Name}
+        /// Represents the smallest possible value of <see cref=""{_quantity.Name}{{T}}"" />
         /// </summary>
-        public static {_quantity.Name} MinValue {{ get; }} = new {_quantity.Name}({_valueType}.MinValue, BaseUnit);
+        public static {_quantity.Name}<T> MinValue {{ get; }} = new {_quantity.Name}<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref=""QuantityType"" /> of this quantity.
@@ -247,14 +225,14 @@ private void GenerateStaticProperties()
         public static QuantityType QuantityType {{ get; }} = QuantityType.{_quantity.Name};
 
         /// <summary>
-        ///     All units of measurement for the {_quantity.Name} quantity.
+        ///     All units of measurement for the <see cref=""{_quantity.Name}{{T}}"" /> quantity.
         /// </summary>
         public static {_unitEnumName}[] Units {{ get; }} = Enum.GetValues(typeof({_unitEnumName})).Cast<{_unitEnumName}>().Except(new {_unitEnumName}[]{{ {_unitEnumName}.Undefined }}).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit {_quantity.BaseUnit}.
         /// </summary>
-        public static {_quantity.Name} Zero {{ get; }} = new {_quantity.Name}(0, BaseUnit);
+        public static {_quantity.Name}<T> Zero {{ get; }} = new {_quantity.Name}<T>(default(T), BaseUnit);
 
         #endregion
 ");
@@ -268,21 +246,16 @@ private void GenerateProperties()
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public {_valueType} Value => _value;
-");
+        public T Value{{ get; }}
 
-            // Need to provide explicit interface implementation for decimal quantities like Information
-            if (_quantity.BaseType != "double")
-                Writer.WL(@"
-        double IQuantity.Value => (double) _value;
+        double IQuantity.Value => Convert.ToDouble(Value);
 ");
-            if (_quantity.BaseType == "decimal")
+        if (_quantity.BaseType == "decimal")
                 Writer.WL(@"
         /// <inheritdoc cref=""IDecimalQuantity.Value""/>
         decimal IDecimalQuantity.Value => _value;
 ");
-
-            Writer.WL($@"
+        Writer.WL($@"
         Enum IQuantity.Unit => Unit;
 
         /// <inheritdoc />
@@ -297,12 +270,12 @@ private void GenerateProperties()
         /// <summary>
         ///     The <see cref=""QuantityType"" /> of this quantity.
         /// </summary>
-        public QuantityType Type => {_quantity.Name}.QuantityType;
+        public QuantityType Type => {_quantity.Name}<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref=""BaseDimensions"" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => {_quantity.Name}.BaseDimensions;
+        public BaseDimensions Dimensions => {_quantity.Name}<T>.BaseDimensions;
 
         #endregion
 ");
@@ -317,11 +290,11 @@ private void GenerateConversionProperties()
             {
                 Writer.WL($@"
         /// <summary>
-        ///     Get {_quantity.Name} in {unit.PluralName}.
+        ///     Get <see cref=""{_quantity.Name}{{T}}"" /> in {unit.PluralName}.
         /// </summary>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public double {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
+        public T {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
 ");
             }
 
@@ -372,29 +345,28 @@ private void GenerateStaticFactoryMethods()
                 var valueParamName = unit.PluralName.ToLowerInvariant();
                 Writer.WL($@"
         /// <summary>
-        ///     Get {_quantity.Name} from {unit.PluralName}.
+        ///     Get <see cref=""{_quantity.Name}{{T}}"" /> from {unit.PluralName}.
         /// </summary>
         /// <exception cref=""ArgumentException"">If value is NaN or Infinity.</exception>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public static {_quantity.Name} From{unit.PluralName}(QuantityValue {valueParamName})
+        public static {_quantity.Name}<T> From{unit.PluralName}(T {valueParamName})
         {{
-            {_valueType} value = ({_valueType}) {valueParamName};
-            return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName});
+            return new {_quantity.Name}<T>({valueParamName}, {_unitEnumName}.{unit.SingularName});
         }}");
             }
 
             Writer.WL();
             Writer.WL($@"
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref=""{_unitEnumName}"" /> to <see cref=""{_quantity.Name}"" />.
+        ///     Dynamically convert from value and unit enum <see cref=""{_unitEnumName}"" /> to <see cref=""{_quantity.Name}{{T}}"" />.
         /// </summary>
         /// <param name=""value"">Value to convert from.</param>
         /// <param name=""fromUnit"">Unit to convert from.</param>
-        /// <returns>{_quantity.Name} unit value.</returns>
-        public static {_quantity.Name} From(QuantityValue value, {_unitEnumName} fromUnit)
+        /// <returns><see cref=""{_quantity.Name}{{T}}"" /> unit value.</returns>
+        public static {_quantity.Name}<T> From(T value, {_unitEnumName} fromUnit)
         {{
-            return new {_quantity.Name}(({_valueType})value, fromUnit);
+            return new {_quantity.Name}<T>(value, fromUnit);
         }}
 
         #endregion
@@ -428,7 +400,7 @@ private void GenerateStaticParseMethods()
         ///     We wrap exceptions in <see cref=""UnitsNetException"" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static {_quantity.Name} Parse(string str)
+        public static {_quantity.Name}<T> Parse(string str)
         {{
             return Parse(str, null);
         }}
@@ -456,9 +428,9 @@ private void GenerateStaticParseMethods()
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentUICulture"" /> if null.</param>
-        public static {_quantity.Name} Parse(string str, IFormatProvider? provider)
+        public static {_quantity.Name}<T> Parse(string str, IFormatProvider? provider)
         {{
-            return QuantityParser.Default.Parse<{_quantity.Name}, {_unitEnumName}>(
+            return QuantityParser.Default.Parse<T, {_quantity.Name}<T>, {_unitEnumName}>(
                 str,
                 provider,
                 From);
@@ -472,7 +444,7 @@ private void GenerateStaticParseMethods()
         /// <example>
         ///     Length.Parse(""5.5 m"", new CultureInfo(""en-US""));
         /// </example>
-        public static bool TryParse(string? str, out {_quantity.Name} result)
+        public static bool TryParse(string? str, out {_quantity.Name}<T> result)
         {{
             return TryParse(str, null, out result);
         }}
@@ -487,9 +459,9 @@ public static bool TryParse(string? str, out {_quantity.Name} result)
         ///     Length.Parse(""5.5 m"", new CultureInfo(""en-US""));
         /// </example>
         /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentUICulture"" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out {_quantity.Name} result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out {_quantity.Name}<T> result)
         {{
-            return QuantityParser.Default.TryParse<{_quantity.Name}, {_unitEnumName}>(
+            return QuantityParser.Default.TryParse<T, {_quantity.Name}<T>, {_unitEnumName}>(
                 str,
                 provider,
                 From,
@@ -566,45 +538,50 @@ private void GenerateArithmeticOperators()
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static {_quantity.Name} operator -({_quantity.Name} right)
+        public static {_quantity.Name}<T> operator -({_quantity.Name}<T> right)
         {{
-            return new {_quantity.Name}(-right.Value, right.Unit);
+            return new {_quantity.Name}<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from adding two <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator +({_quantity.Name} left, {_quantity.Name} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from adding two <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator +({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
-            return new {_quantity.Name}(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new {_quantity.Name}<T>(value, left.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from subtracting two <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator -({_quantity.Name} left, {_quantity.Name} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from subtracting two <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator -({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
-            return new {_quantity.Name}(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new {_quantity.Name}<T>(value, left.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from multiplying value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_valueType} left, {_quantity.Name} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from multiplying value and <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator *(T left, {_quantity.Name}<T> right)
         {{
-            return new {_quantity.Name}(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new {_quantity.Name}<T>(value, right.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from multiplying value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_quantity.Name} left, {_valueType} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from multiplying value and <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator *({_quantity.Name}<T> left, T right)
         {{
-            return new {_quantity.Name}(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new {_quantity.Name}<T>(value, left.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from dividing <see cref=""{_quantity.Name}""/> by value.</summary>
-        public static {_quantity.Name} operator /({_quantity.Name} left, {_valueType} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from dividing <see cref=""{_quantity.Name}{{T}}""/> by value.</summary>
+        public static {_quantity.Name}<T> operator /({_quantity.Name}<T> left, T right)
         {{
-            return new {_quantity.Name}(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new {_quantity.Name}<T>(value, left.Unit);
         }}
 
-        /// <summary>Get ratio value from dividing <see cref=""{_quantity.Name}""/> by <see cref=""{_quantity.Name}""/>.</summary>
-        public static double operator /({_quantity.Name} left, {_quantity.Name} right)
+        /// <summary>Get ratio value from dividing <see cref=""{_quantity.Name}{{T}}""/> by <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static T operator /({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
-            return left.{_baseUnit.PluralName} / right.{_baseUnit.PluralName};
+            return CompiledLambdas.Divide(left.{_baseUnit.PluralName}, right.{_baseUnit.PluralName});
         }}
 
         #endregion
@@ -620,50 +597,50 @@ private void GenerateLogarithmicArithmeticOperators()
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static {_quantity.Name} operator -({_quantity.Name} right)
+        public static {_quantity.Name}<T> operator -({_quantity.Name}<T> right)
         {{
-            return new {_quantity.Name}(-right.Value, right.Unit);
+            return new {_quantity.Name}<T>(-right.Value, right.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic addition of two <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator +({_quantity.Name} left, {_quantity.Name} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from logarithmic addition of two <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator +({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
             // Logarithmic addition
             // Formula: {x}*log10(10^(x/{x}) + 10^(y/{x}))
-            return new {_quantity.Name}({x}*Math.Log10(Math.Pow(10, left.Value/{x}) + Math.Pow(10, right.GetValueAs(left.Unit)/{x})), left.Unit);
+            return new {_quantity.Name}<T>({x}*Math.Log10(Math.Pow(10, left.Value/{x}) + Math.Pow(10, right.GetValueAs(left.Unit)/{x})), left.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic subtraction of two <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator -({_quantity.Name} left, {_quantity.Name} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from logarithmic subtraction of two <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator -({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
             // Logarithmic subtraction
             // Formula: {x}*log10(10^(x/{x}) - 10^(y/{x}))
-            return new {_quantity.Name}({x}*Math.Log10(Math.Pow(10, left.Value/{x}) - Math.Pow(10, right.GetValueAs(left.Unit)/{x})), left.Unit);
+            return new {_quantity.Name}<T>({x}*Math.Log10(Math.Pow(10, left.Value/{x}) - Math.Pow(10, right.GetValueAs(left.Unit)/{x})), left.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic multiplication of value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_valueType} left, {_quantity.Name} right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from logarithmic multiplication of value and <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator *({_valueType} left, {_quantity.Name}<T> right)
         {{
             // Logarithmic multiplication = addition
-            return new {_quantity.Name}(left + right.Value, right.Unit);
+            return new {_quantity.Name}<T>(left + right.Value, right.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic multiplication of value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_quantity.Name} left, double right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from logarithmic multiplication of value and <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static {_quantity.Name}<T> operator *({_quantity.Name}<T> left, double right)
         {{
             // Logarithmic multiplication = addition
-            return new {_quantity.Name}(left.Value + ({_valueType})right, left.Unit);
+            return new {_quantity.Name}<T>(left.Value + ({_valueType})right, left.Unit);
         }}
 
-        /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic division of <see cref=""{_quantity.Name}""/> by value.</summary>
-        public static {_quantity.Name} operator /({_quantity.Name} left, double right)
+        /// <summary>Get <see cref=""{_quantity.Name}{{T}}""/> from logarithmic division of <see cref=""{_quantity.Name}{{T}}""/> by value.</summary>
+        public static {_quantity.Name}<T> operator /({_quantity.Name}<T> left, double right)
         {{
             // Logarithmic division = subtraction
-            return new {_quantity.Name}(left.Value - ({_valueType})right, left.Unit);
+            return new {_quantity.Name}<T>(left.Value - ({_valueType})right, left.Unit);
         }}
 
-        /// <summary>Get ratio value from logarithmic division of <see cref=""{_quantity.Name}""/> by <see cref=""{_quantity.Name}""/>.</summary>
-        public static double operator /({_quantity.Name} left, {_quantity.Name} right)
+        /// <summary>Get ratio value from logarithmic division of <see cref=""{_quantity.Name}{{T}}""/> by <see cref=""{_quantity.Name}{{T}}""/>.</summary>
+        public static double operator /({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
             // Logarithmic division = subtraction
             return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit));
@@ -679,39 +656,39 @@ private void GenerateEqualityAndComparison()
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=({_quantity.Name} left, {_quantity.Name} right)
+        public static bool operator <=({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }}
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=({_quantity.Name} left, {_quantity.Name} right)
+        public static bool operator >=({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }}
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <({_quantity.Name} left, {_quantity.Name} right)
+        public static bool operator <({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }}
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >({_quantity.Name} left, {_quantity.Name} right)
+        public static bool operator >({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }}
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
-        public static bool operator ==({_quantity.Name} left, {_quantity.Name} right)
+        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}{{T}}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
+        public static bool operator ==({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
             return left.Equals(right);
         }}
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
-        public static bool operator !=({_quantity.Name} left, {_quantity.Name} right)
+        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}{{T}}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
+        public static bool operator !=({_quantity.Name}<T> left, {_quantity.Name}<T> right)
         {{
             return !(left == right);
         }}
@@ -720,37 +697,37 @@ private void GenerateEqualityAndComparison()
         public int CompareTo(object obj)
         {{
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is {_quantity.Name} obj{_quantity.Name})) throw new ArgumentException(""Expected type {_quantity.Name}."", nameof(obj));
+            if(!(obj is {_quantity.Name}<T> obj{_quantity.Name})) throw new ArgumentException(""Expected type {_quantity.Name}."", nameof(obj));
 
             return CompareTo(obj{_quantity.Name});
         }}
 
         /// <inheritdoc />
-        public int CompareTo({_quantity.Name} other)
+        public int CompareTo({_quantity.Name}<T> other)
         {{
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }}
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}{{T}}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {{
-            if(obj is null || !(obj is {_quantity.Name} obj{_quantity.Name}))
+            if(obj is null || !(obj is {_quantity.Name}<T> obj{_quantity.Name}))
                 return false;
 
             return Equals(obj{_quantity.Name});
         }}
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
-        public bool Equals({_quantity.Name} other)
+        /// <remarks>Consider using <see cref=""Equals({_quantity.Name}{{T}}, double, ComparisonType)""/> for safely comparing floating point values.</remarks>
+        public bool Equals({_quantity.Name}<T> other)
         {{
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }}
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another {_quantity.Name} within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref=""{_quantity.Name}{{T}}"" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -788,21 +765,19 @@ public bool Equals({_quantity.Name} other)
         /// <param name=""tolerance"">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name=""comparisonType"">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals({_quantity.Name} other, double tolerance, ComparisonType comparisonType)
+        public bool Equals({_quantity.Name}<T> other, T tolerance, ComparisonType comparisonType)
         {{
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException(""tolerance"", ""Tolerance must be greater than or equal to 0."");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), ""Tolerance must be greater than or equal to 0"");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }}
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current {_quantity.Name}.</returns>
+        /// <returns>A hash code for the current <see cref=""{_quantity.Name}{{T}}"" />.</returns>
         public override int GetHashCode()
         {{
             return new {{ Info.Name, Value, Unit }}.GetHashCode();
@@ -821,17 +796,17 @@ private void GenerateConversionMethods()
         ///     Convert to the unit representation <paramref name=""unit"" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As({_unitEnumName} unit)
+        public T As({_unitEnumName} unit)
         {{
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }}
 
         /// <inheritdoc cref=""IQuantity.As(UnitSystem)""/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {{
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -851,17 +826,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is {_unitEnumName} unitAs{_unitEnumName}))
                 throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
 
-            return As(unitAs{_unitEnumName});
+            var asValue = As(unitAs{_unitEnumName});
+            return Convert.ToDouble(asValue);
         }}
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<{_unitEnumName}>.As({_unitEnumName} unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this {_quantity.Name} to another {_quantity.Name} with the unit representation <paramref name=""unit"" />.
+        ///     Converts this <see cref=""{_quantity.Name}{{T}}"" /> to another <see cref=""{_quantity.Name}{{T}}"" /> with the unit representation <paramref name=""unit"" />.
         /// </summary>
-        /// <returns>A {_quantity.Name} with the specified unit.</returns>
-        public {_quantity.Name} ToUnit({_unitEnumName} unit)
+        /// <returns>A <see cref=""{_quantity.Name}{{T}}"" /> with the specified unit.</returns>
+        public {_quantity.Name}<T> ToUnit({_unitEnumName} unit)
         {{
             var convertedValue = GetValueAs(unit);
-            return new {_quantity.Name}(convertedValue, unit);
+            return new {_quantity.Name}<T>(convertedValue, unit);
         }}
 
         /// <inheritdoc />
@@ -874,7 +854,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }}
 
         /// <inheritdoc cref=""IQuantity.ToUnit(UnitSystem)""/>
-        public {_quantity.Name} ToUnit(UnitSystem unitSystem)
+        public {_quantity.Name}<T> ToUnit(UnitSystem unitSystem)
         {{
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -894,21 +874,27 @@ IQuantity IQuantity.ToUnit(Enum unit)
         /// <inheritdoc />
         IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit({_unitEnumName} unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<{_unitEnumName}, T> IQuantityT<{_unitEnumName}, T>.ToUnit({_unitEnumName} unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<{_unitEnumName}, T> IQuantityT<{_unitEnumName}, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private {_valueType} GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {{
             switch(Unit)
             {{");
             foreach (var unit in _quantity.Units)
             {
-                var func = unit.FromUnitToBaseFunc.Replace("x", "_value");
+                var func = unit.FromUnitToBaseFunc.Replace("x", "Value");
                 Writer.WL($@"
                 case {_unitEnumName}.{unit.SingularName}: return {func};");
             }
@@ -924,16 +910,16 @@ IQuantity IQuantity.ToUnit(Enum unit)
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal {_quantity.Name} ToBaseUnit()
+        internal {_quantity.Name}<T> ToBaseUnit()
         {{
             var baseUnitValue = GetValueInBaseUnit();
-            return new {_quantity.Name}(baseUnitValue, BaseUnit);
+            return new {_quantity.Name}<T>(baseUnitValue, BaseUnit);
         }}
 
-        private {_valueType} GetValueAs({_unitEnumName} unit)
+        private T GetValueAs({_unitEnumName} unit)
         {{
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1038,7 +1024,7 @@ public string ToString(string format, IFormatProvider? provider)
         }}
 
         #endregion
-" );
+");
         }
 
         private void GenerateIConvertibleMethods()
@@ -1053,57 +1039,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {{
-            throw new InvalidCastException($""Converting {{typeof({_quantity.Name})}} to bool is not supported."");
+            throw new InvalidCastException($""Converting {{typeof({_quantity.Name}<T>)}} to bool is not supported."");
         }}
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {{
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }}
 
         char IConvertible.ToChar(IFormatProvider provider)
         {{
-            throw new InvalidCastException($""Converting {{typeof({_quantity.Name})}} to char is not supported."");
+            throw new InvalidCastException($""Converting {{typeof({_quantity.Name}<T>)}} to char is not supported."");
         }}
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {{
-            throw new InvalidCastException($""Converting {{typeof({_quantity.Name})}} to DateTime is not supported."");
+            throw new InvalidCastException($""Converting {{typeof({_quantity.Name}<T>)}} to DateTime is not supported."");
         }}
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {{
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }}
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {{
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }}
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {{
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }}
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {{
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }}
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {{
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }}
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {{
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }}
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {{
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }}
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1113,33 +1099,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {{
-            if(conversionType == typeof({_quantity.Name}))
+            if(conversionType == typeof({_quantity.Name}<T>))
                 return this;
             else if(conversionType == typeof({_unitEnumName}))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return {_quantity.Name}.QuantityType;
+                return {_quantity.Name}<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return {_quantity.Name}.Info;
+                return {_quantity.Name}<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return {_quantity.Name}.BaseDimensions;
+                return {_quantity.Name}<T>.BaseDimensions;
             else
-                throw new InvalidCastException($""Converting {{typeof({_quantity.Name})}} to {{conversionType}} is not supported."");
+                throw new InvalidCastException($""Converting {{typeof({_quantity.Name}<T>)}} to {{conversionType}} is not supported."");
         }}
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {{
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }}
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {{
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }}
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {{
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }}
 
         #endregion");
diff --git a/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
index 5e646a0605..75be087080 100644
--- a/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
@@ -60,7 +60,7 @@ public static partial class Quantity
         /// <param name=""value"">The value to construct the quantity with.</param>
         /// <returns>The created quantity.</returns>
         [Obsolete(""QuantityType will be removed. Use FromQuantityInfo(QuantityInfo, QuantityValue) instead."")]
-        public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValue value)
+        public static IQuantity FromQuantityType<T>(QuantityType quantityType, QuantityValue value)
         {
             switch(quantityType)
             {");
@@ -69,7 +69,7 @@ public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValu
                 var quantityName = quantity.Name;
                 Writer.WL($@"
                 case QuantityType.{quantityName}:
-                    return {quantityName}.From(value, {quantityName}.BaseUnit);");
+                    return {quantityName}<T>.From(value, {quantityName}<T>.BaseUnit);");
             }
 
             Writer.WL(@"
@@ -109,7 +109,7 @@ public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValu
         /// <param name=""unit"">Unit enum value.</param>
         /// <param name=""quantity"">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns><c>True</c> if successful with <paramref name=""quantity""/> assigned the value, otherwise <c>false</c>.</returns>
-        public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quantity)
+        public static bool TryFrom<T>(QuantityValue value, Enum unit, out IQuantity? quantity)
         {
             switch (unit)
             {");
@@ -120,7 +120,7 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quanti
                 var unitValue = unitTypeName.ToCamelCase();
                 Writer.WL($@"
                 case {unitTypeName} {unitValue}:
-                    quantity = {quantityName}.From(value, {unitValue});
+                    quantity = {quantityName}<T>.From(value, {unitValue});
                     return true;");
             }
 
@@ -137,11 +137,11 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quanti
         ///     Try to dynamically parse a quantity string representation.
         /// </summary>
         /// <param name=""formatProvider"">The format provider to use for lookup. Defaults to <see cref=""CultureInfo.CurrentUICulture"" /> if null.</param>
-        /// <param name=""quantityType"">Type of quantity, such as <see cref=""Length""/>.</param>
+        /// <param name=""quantityType"">Type of quantity, such as <see cref=""Length{T}""/>.</param>
         /// <param name=""quantityString"">Quantity string representation, such as ""1.5 kg"". Must be compatible with given quantity type.</param>
         /// <param name=""quantity"">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns>The parsed quantity.</returns>
-        public static bool TryParse(IFormatProvider? formatProvider, Type quantityType, string quantityString, out IQuantity? quantity)
+        public static bool TryParse<T>(IFormatProvider? formatProvider, Type quantityType, string quantityString, out IQuantity? quantity)
         {
             quantity = default(IQuantity);
 
@@ -156,8 +156,8 @@ public static bool TryParse(IFormatProvider? formatProvider, Type quantityType,
             {
                 var quantityName = quantity.Name;
                 Writer.WL($@"
-                case Type _ when quantityType == typeof({quantityName}):
-                    return parser.TryParse<{quantityName}, {quantityName}Unit>(quantityString, formatProvider, {quantityName}.From, out quantity);");
+                case Type _ when quantityType == typeof({quantityName}<T>):
+                    return parser.TryParse<{quantityName}<T>, {quantityName}Unit>(quantityString, formatProvider, {quantityName}<T>.From, out quantity);");
             }
 
             Writer.WL(@"
diff --git a/CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs b/CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs
index 09047b06e9..a54acfa1fd 100644
--- a/CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using CodeGen.Helpers;
@@ -26,23 +26,23 @@ public override string Generate()
 
 namespace UnitsNet
 {{
-    public sealed partial class UnitConverter
+    public sealed partial class UnitConverter<T>
     {{
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref=""UnitConverter""/> instance.
+        /// Registers the default conversion functions in the given <see cref=""UnitConverter{{T}}""/> instance.
         /// </summary>
-        /// <param name=""unitConverter"">The <see cref=""UnitConverter""/> to register the default conversion functions in.</param>
-        public static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {{");
+        /// <param name=""unitConverter"">The <see cref=""UnitConverter{{T}}""/> to register the default conversion functions in.</param>
+        public static void RegisterDefaultConversions(UnitConverter<T> unitConverter)
+        {{" );
             foreach (Quantity quantity in _quantities)
             foreach (Unit unit in quantity.Units)
             {
                 Writer.WL(quantity.BaseUnit == unit.SingularName
                     ? $@"
-            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}.BaseUnit, q => q);"
+            unitConverter.SetConversionFunction<{quantity.Name}<T>>({quantity.Name}<T>.BaseUnit, {quantity.Name}<T>.BaseUnit, q => q);"
                     : $@"
-            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}Unit.{unit.SingularName}, q => q.ToUnit({quantity.Name}Unit.{unit.SingularName}));
-            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}Unit.{unit.SingularName}, {quantity.Name}.BaseUnit, q => q.ToBaseUnit());");
+            unitConverter.SetConversionFunction<{quantity.Name}<T>>({quantity.Name}<T>.BaseUnit, {quantity.Name}Unit.{unit.SingularName}, q => q.ToUnit({quantity.Name}Unit.{unit.SingularName}));
+            unitConverter.SetConversionFunction<{quantity.Name}<T>>({quantity.Name}Unit.{unit.SingularName}, {quantity.Name}<T>.BaseUnit, q => q.ToBaseUnit());");
             }
 
             Writer.WL($@"
diff --git a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
index 352f895108..1bce249e7f 100644
--- a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
@@ -103,7 +103,7 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {{
-            Assert.Throws<ArgumentException>(() => new {_quantity.Name}(({_quantity.BaseType})0.0, {_unitEnumName}.Undefined));
+            Assert.Throws<ArgumentException>(() => new {_quantity.Name}<double>(({_quantity.BaseType})0.0, {_unitEnumName}.Undefined));
         }}
 
         [Fact]
@@ -122,14 +122,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {{
-            Assert.Throws<ArgumentException>(() => new {_quantity.Name}(double.PositiveInfinity, {_baseUnitFullName}));
-            Assert.Throws<ArgumentException>(() => new {_quantity.Name}(double.NegativeInfinity, {_baseUnitFullName}));
+            Assert.Throws<ArgumentException>(() => new {_quantity.Name}<double>(double.PositiveInfinity, {_baseUnitFullName}));
+            Assert.Throws<ArgumentException>(() => new {_quantity.Name}<double>(double.NegativeInfinity, {_baseUnitFullName}));
         }}
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {{
-            Assert.Throws<ArgumentException>(() => new {_quantity.Name}(double.NaN, {_baseUnitFullName}));
+            Assert.Throws<ArgumentException>(() => new {_quantity.Name}<double>(double.NaN, {_baseUnitFullName}));
         }}
 "); Writer.WL($@"
 
@@ -176,7 +176,7 @@ public void Ctor_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void {_baseUnit.SingularName}To{_quantity.Name}Units()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            {_quantity.Name}<double> {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);");
 
             foreach (var unit in _quantity.Units) Writer.WL($@"
             AssertEx.EqualTolerance({unit.PluralName}InOne{_baseUnit.SingularName}, {baseUnitVariableName}.{unit.PluralName}, {unit.PluralName}Tolerance);");
@@ -191,7 +191,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
             {
                 var quantityVariable = $"quantity{i++:D2}";
                 Writer.WL($@"
-            var {quantityVariable} = {_quantity.Name}.From(1, {GetUnitFullName(unit)});
+            var {quantityVariable} = {_quantity.Name}<double>.From(1, {GetUnitFullName(unit)});
             AssertEx.EqualTolerance(1, {quantityVariable}.{unit.PluralName}, {unit.PluralName}Tolerance);
             Assert.Equal({GetUnitFullName(unit)}, {quantityVariable}.Unit);
 ");
@@ -204,21 +204,21 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void From{_baseUnit.PluralName}_WithInfinityValue_ThrowsArgumentException()
         {{
-            Assert.Throws<ArgumentException>(() => {_quantity.Name}.From{_baseUnit.PluralName}(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => {_quantity.Name}.From{_baseUnit.PluralName}(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => {_quantity.Name}<double>.From{_baseUnit.PluralName}(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => {_quantity.Name}<double>.From{_baseUnit.PluralName}(double.NegativeInfinity));
         }}
 
         [Fact]
         public void From{_baseUnit.PluralName}_WithNanValue_ThrowsArgumentException()
         {{
-            Assert.Throws<ArgumentException>(() => {_quantity.Name}.From{_baseUnit.PluralName}(double.NaN));
+            Assert.Throws<ArgumentException>(() => {_quantity.Name}<double>.From{_baseUnit.PluralName}(double.NaN));
         }}
 "); Writer.WL($@"
 
         [Fact]
         public void As()
         {{
-            var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            var {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);");
             foreach (var unit in _quantity.Units) Writer.WL($@"
             AssertEx.EqualTolerance({unit.PluralName}InOne{_baseUnit.SingularName}, {baseUnitVariableName}.As({GetUnitFullName(unit)}), {unit.PluralName}Tolerance);");
             Writer.WL($@"
@@ -244,7 +244,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {{
-            var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            var {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);");
             foreach (var unit in _quantity.Units)
             {
                 var asQuantityVariableName = $"{unit.SingularName.ToLowerInvariant()}Quantity";
@@ -269,9 +269,9 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            {_quantity.Name}<double> {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);");
             foreach (var unit in _quantity.Units) Writer.WL($@"
-            AssertEx.EqualTolerance(1, {_quantity.Name}.From{unit.PluralName}({baseUnitVariableName}.{unit.PluralName}).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);");
+            AssertEx.EqualTolerance(1, {_quantity.Name}<double>.From{unit.PluralName}({baseUnitVariableName}.{unit.PluralName}).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);");
             Writer.WL($@"
         }}
 ");
@@ -282,14 +282,14 @@ public void ConversionRoundTrip()
         [Fact]
         public void LogarithmicArithmeticOperators()
         {{
-            {_quantity.Name} v = {_quantity.Name}.From{_baseUnit.PluralName}(40);
+            {_quantity.Name}<double> v = {_quantity.Name}<double>.From{_baseUnit.PluralName}(40);
             AssertEx.EqualTolerance(-40, -v.{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
             AssertEx.EqualTolerance(50, (v*10).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
             AssertEx.EqualTolerance(50, (10*v).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
             AssertEx.EqualTolerance(35, (v/5).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(35, v/{_quantity.Name}.From{_baseUnit.PluralName}(5), {unit.PluralName}Tolerance);
+            AssertEx.EqualTolerance(35, v/{_quantity.Name}<double>.From{_baseUnit.PluralName}(5), {unit.PluralName}Tolerance);
         }}
 
         protected abstract void AssertLogarithmicAddition();
@@ -303,14 +303,14 @@ public void LogarithmicArithmeticOperators()
         [Fact]
         public void ArithmeticOperators()
         {{
-            {_quantity.Name} v = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            {_quantity.Name}<double> v = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
             AssertEx.EqualTolerance(-1, -v.{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, ({_quantity.Name}.From{_baseUnit.PluralName}(3)-v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
+            AssertEx.EqualTolerance(2, ({_quantity.Name}<double>.From{_baseUnit.PluralName}(3)-v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
             AssertEx.EqualTolerance(2, (v + v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
             AssertEx.EqualTolerance(10, (v*10).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
             AssertEx.EqualTolerance(10, (10*v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, ({_quantity.Name}.From{_baseUnit.PluralName}(10)/5).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, {_quantity.Name}.From{_baseUnit.PluralName}(10)/{_quantity.Name}.From{_baseUnit.PluralName}(5), {_baseUnit.PluralName}Tolerance);
+            AssertEx.EqualTolerance(2, ({_quantity.Name}<double>.From{_baseUnit.PluralName}(10)/5).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
+            AssertEx.EqualTolerance(2, {_quantity.Name}<double>.From{_baseUnit.PluralName}(10)/{_quantity.Name}<double>.From{_baseUnit.PluralName}(5), {_baseUnit.PluralName}Tolerance);
         }}
 ");
             }
@@ -323,8 +323,8 @@ public void ArithmeticOperators()
         [Fact]
         public void ComparisonOperators()
         {{
-            {_quantity.Name} one{_baseUnit.SingularName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);
-            {_quantity.Name} two{_baseUnit.PluralName} = {_quantity.Name}.From{_baseUnit.PluralName}(2);
+            {_quantity.Name}<double> one{_baseUnit.SingularName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
+            {_quantity.Name}<double> two{_baseUnit.PluralName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(2);
 
             Assert.True(one{_baseUnit.SingularName} < two{_baseUnit.PluralName});
             Assert.True(one{_baseUnit.SingularName} <= two{_baseUnit.PluralName});
@@ -340,31 +340,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            {_quantity.Name}<double> {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
             Assert.Equal(0, {baseUnitVariableName}.CompareTo({baseUnitVariableName}));
-            Assert.True({baseUnitVariableName}.CompareTo({_quantity.Name}.Zero) > 0);
-            Assert.True({_quantity.Name}.Zero.CompareTo({baseUnitVariableName}) < 0);
+            Assert.True({baseUnitVariableName}.CompareTo({_quantity.Name}<double>.Zero) > 0);
+            Assert.True({_quantity.Name}<double>.Zero.CompareTo({baseUnitVariableName}) < 0);
         }}
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            {_quantity.Name}<double> {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
             Assert.Throws<ArgumentException>(() => {baseUnitVariableName}.CompareTo(new object()));
         }}
 
         [Fact]
         public void CompareToThrowsOnNull()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            {_quantity.Name}<double> {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
             Assert.Throws<ArgumentNullException>(() => {baseUnitVariableName}.CompareTo(null));
         }}
 
         [Fact]
         public void EqualityOperators()
         {{
-            var a = {_quantity.Name}.From{_baseUnit.PluralName}(1);
-            var b = {_quantity.Name}.From{_baseUnit.PluralName}(2);
+            var a = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
+            var b = {_quantity.Name}<double>.From{_baseUnit.PluralName}(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -383,8 +383,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {{
-            var a = {_quantity.Name}.From{_baseUnit.PluralName}(1);
-            var b = {_quantity.Name}.From{_baseUnit.PluralName}(2);
+            var a = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
+            var b = {_quantity.Name}<double>.From{_baseUnit.PluralName}(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -404,9 +404,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {{
-            var v = {_quantity.Name}.From{_baseUnit.PluralName}(1);
-            Assert.True(v.Equals({_quantity.Name}.From{_baseUnit.PluralName}(1), {_baseUnit.PluralName}Tolerance, ComparisonType.Relative));
-            Assert.False(v.Equals({_quantity.Name}.Zero, {_baseUnit.PluralName}Tolerance, ComparisonType.Relative));
+            var v = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
+            Assert.True(v.Equals({_quantity.Name}<double>.From{_baseUnit.PluralName}(1), {_baseUnit.PluralName}Tolerance, ComparisonType.Relative));
+            Assert.False(v.Equals({_quantity.Name}<double>.Zero, {_baseUnit.PluralName}Tolerance, ComparisonType.Relative));
         }}
 
         [Fact]
@@ -419,21 +419,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            {_quantity.Name}<double> {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
             Assert.False({baseUnitVariableName}.Equals(new object()));
         }}
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            {_quantity.Name}<double> {baseUnitVariableName} = {_quantity.Name}<double>.From{_baseUnit.PluralName}(1);
             Assert.False({baseUnitVariableName}.Equals(null));
         }}
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {{
-            Assert.DoesNotContain({_unitEnumName}.Undefined, {_quantity.Name}.Units);
+            Assert.DoesNotContain({_unitEnumName}.Undefined, {_quantity.Name}<double>.Units);
         }}
 
         [Fact]
@@ -452,7 +452,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {{
-            Assert.False({_quantity.Name}.BaseDimensions is null);
+            Assert.False({_quantity.Name}<double>.BaseDimensions is null);
         }}
 
         [Fact]
diff --git a/UnitsNet.Benchmark/Program.cs b/UnitsNet.Benchmark/Program.cs
index d51d42b653..ef54d50b36 100644
--- a/UnitsNet.Benchmark/Program.cs
+++ b/UnitsNet.Benchmark/Program.cs
@@ -7,17 +7,17 @@ namespace UnitsNet.Benchmark
     [MemoryDiagnoser]
     public class UnitsNetBenchmarks
     {
-        private Length length = Length.FromMeters(3.0);
-        private IQuantity lengthIQuantity = Length.FromMeters(3.0);
+        private Length<double> length = Length<double>.FromMeters(3.0);
+        private IQuantity lengthIQuantity = Length<double>.FromMeters(3.0);
 
         [Benchmark]
-        public Length Constructor() => new Length(3.0, LengthUnit.Meter);
+        public Length<double> Constructor() => new Length<double>( 3.0, LengthUnit.Meter);
 
         [Benchmark]
-        public Length Constructor_SI() => new Length(3.0, UnitSystem.SI);
+        public Length<double> Constructor_SI() => new Length<double>( 3.0, UnitSystem.SI);
 
         [Benchmark]
-        public Length FromMethod() => Length.FromMeters(3.0);
+        public Length<double> FromMethod() => Length<double>.FromMeters(3.0);
 
         [Benchmark]
         public double ToProperty() => length.Centimeters;
@@ -29,25 +29,25 @@ public class UnitsNetBenchmarks
         public double As_SI() => length.As(UnitSystem.SI);
 
         [Benchmark]
-        public Length ToUnit() => length.ToUnit(LengthUnit.Centimeter);
+        public Length<double> ToUnit() => length.ToUnit(LengthUnit.Centimeter);
 
         [Benchmark]
-        public Length ToUnit_SI() => length.ToUnit(UnitSystem.SI);
+        public Length<double> ToUnit_SI() => length.ToUnit(UnitSystem.SI);
 
         [Benchmark]
         public string ToStringTest() => length.ToString();
 
         [Benchmark]
-        public Length Parse() => Length.Parse("3.0 m");
+        public Length<double> Parse() => Length<double>.Parse("3.0 m");
 
         [Benchmark]
-        public bool TryParseValid() => Length.TryParse("3.0 m", out var l);
+        public bool TryParseValid() => Length<double>.TryParse("3.0 m", out var l);
 
         [Benchmark]
-        public bool TryParseInvalid() => Length.TryParse("3.0 zoom", out var l);
+        public bool TryParseInvalid() => Length<double>.TryParse("3.0 zoom", out var l);
 
         [Benchmark]
-        public IQuantity QuantityFrom() => Quantity.From(3.0, LengthUnit.Meter);
+        public IQuantity QuantityFrom() => Quantity.From<double>( 3.0, LengthUnit.Meter);
 
         [Benchmark]
         public double IQuantity_As() => lengthIQuantity.As(LengthUnit.Centimeter);
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs
index e7825c4d36..0b9688f17a 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs
@@ -21,64 +21,64 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToAccelerationExtensionsTests
     {
         [Fact]
         public void NumberToCentimetersPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromCentimetersPerSecondSquared(2), 2.CentimetersPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromCentimetersPerSecondSquared(2), 2.CentimetersPerSecondSquared());
 
         [Fact]
         public void NumberToDecimetersPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromDecimetersPerSecondSquared(2), 2.DecimetersPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromDecimetersPerSecondSquared(2), 2.DecimetersPerSecondSquared());
 
         [Fact]
         public void NumberToFeetPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromFeetPerSecondSquared(2), 2.FeetPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromFeetPerSecondSquared(2), 2.FeetPerSecondSquared());
 
         [Fact]
         public void NumberToInchesPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromInchesPerSecondSquared(2), 2.InchesPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromInchesPerSecondSquared(2), 2.InchesPerSecondSquared());
 
         [Fact]
         public void NumberToKilometersPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromKilometersPerSecondSquared(2), 2.KilometersPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromKilometersPerSecondSquared(2), 2.KilometersPerSecondSquared());
 
         [Fact]
         public void NumberToKnotsPerHourTest() =>
-            Assert.Equal(Acceleration.FromKnotsPerHour(2), 2.KnotsPerHour());
+            Assert.Equal(Acceleration<double>.FromKnotsPerHour(2), 2.KnotsPerHour());
 
         [Fact]
         public void NumberToKnotsPerMinuteTest() =>
-            Assert.Equal(Acceleration.FromKnotsPerMinute(2), 2.KnotsPerMinute());
+            Assert.Equal(Acceleration<double>.FromKnotsPerMinute(2), 2.KnotsPerMinute());
 
         [Fact]
         public void NumberToKnotsPerSecondTest() =>
-            Assert.Equal(Acceleration.FromKnotsPerSecond(2), 2.KnotsPerSecond());
+            Assert.Equal(Acceleration<double>.FromKnotsPerSecond(2), 2.KnotsPerSecond());
 
         [Fact]
         public void NumberToMetersPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromMetersPerSecondSquared(2), 2.MetersPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromMetersPerSecondSquared(2), 2.MetersPerSecondSquared());
 
         [Fact]
         public void NumberToMicrometersPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromMicrometersPerSecondSquared(2), 2.MicrometersPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromMicrometersPerSecondSquared(2), 2.MicrometersPerSecondSquared());
 
         [Fact]
         public void NumberToMillimetersPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromMillimetersPerSecondSquared(2), 2.MillimetersPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromMillimetersPerSecondSquared(2), 2.MillimetersPerSecondSquared());
 
         [Fact]
         public void NumberToMillistandardGravityTest() =>
-            Assert.Equal(Acceleration.FromMillistandardGravity(2), 2.MillistandardGravity());
+            Assert.Equal(Acceleration<double>.FromMillistandardGravity(2), 2.MillistandardGravity());
 
         [Fact]
         public void NumberToNanometersPerSecondSquaredTest() =>
-            Assert.Equal(Acceleration.FromNanometersPerSecondSquared(2), 2.NanometersPerSecondSquared());
+            Assert.Equal(Acceleration<double>.FromNanometersPerSecondSquared(2), 2.NanometersPerSecondSquared());
 
         [Fact]
         public void NumberToStandardGravityTest() =>
-            Assert.Equal(Acceleration.FromStandardGravity(2), 2.StandardGravity());
+            Assert.Equal(Acceleration<double>.FromStandardGravity(2), 2.StandardGravity());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs
index 7197c0edac..02c943929f 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs
@@ -21,68 +21,68 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToAmountOfSubstanceExtensionsTests
     {
         [Fact]
         public void NumberToCentimolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromCentimoles(2), 2.Centimoles());
+            Assert.Equal(AmountOfSubstance<double>.FromCentimoles(2), 2.Centimoles());
 
         [Fact]
         public void NumberToCentipoundMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromCentipoundMoles(2), 2.CentipoundMoles());
+            Assert.Equal(AmountOfSubstance<double>.FromCentipoundMoles(2), 2.CentipoundMoles());
 
         [Fact]
         public void NumberToDecimolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromDecimoles(2), 2.Decimoles());
+            Assert.Equal(AmountOfSubstance<double>.FromDecimoles(2), 2.Decimoles());
 
         [Fact]
         public void NumberToDecipoundMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromDecipoundMoles(2), 2.DecipoundMoles());
+            Assert.Equal(AmountOfSubstance<double>.FromDecipoundMoles(2), 2.DecipoundMoles());
 
         [Fact]
         public void NumberToKilomolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromKilomoles(2), 2.Kilomoles());
+            Assert.Equal(AmountOfSubstance<double>.FromKilomoles(2), 2.Kilomoles());
 
         [Fact]
         public void NumberToKilopoundMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromKilopoundMoles(2), 2.KilopoundMoles());
+            Assert.Equal(AmountOfSubstance<double>.FromKilopoundMoles(2), 2.KilopoundMoles());
 
         [Fact]
         public void NumberToMegamolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromMegamoles(2), 2.Megamoles());
+            Assert.Equal(AmountOfSubstance<double>.FromMegamoles(2), 2.Megamoles());
 
         [Fact]
         public void NumberToMicromolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromMicromoles(2), 2.Micromoles());
+            Assert.Equal(AmountOfSubstance<double>.FromMicromoles(2), 2.Micromoles());
 
         [Fact]
         public void NumberToMicropoundMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromMicropoundMoles(2), 2.MicropoundMoles());
+            Assert.Equal(AmountOfSubstance<double>.FromMicropoundMoles(2), 2.MicropoundMoles());
 
         [Fact]
         public void NumberToMillimolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromMillimoles(2), 2.Millimoles());
+            Assert.Equal(AmountOfSubstance<double>.FromMillimoles(2), 2.Millimoles());
 
         [Fact]
         public void NumberToMillipoundMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromMillipoundMoles(2), 2.MillipoundMoles());
+            Assert.Equal(AmountOfSubstance<double>.FromMillipoundMoles(2), 2.MillipoundMoles());
 
         [Fact]
         public void NumberToMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromMoles(2), 2.Moles());
+            Assert.Equal(AmountOfSubstance<double>.FromMoles(2), 2.Moles());
 
         [Fact]
         public void NumberToNanomolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromNanomoles(2), 2.Nanomoles());
+            Assert.Equal(AmountOfSubstance<double>.FromNanomoles(2), 2.Nanomoles());
 
         [Fact]
         public void NumberToNanopoundMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromNanopoundMoles(2), 2.NanopoundMoles());
+            Assert.Equal(AmountOfSubstance<double>.FromNanopoundMoles(2), 2.NanopoundMoles());
 
         [Fact]
         public void NumberToPoundMolesTest() =>
-            Assert.Equal(AmountOfSubstance.FromPoundMoles(2), 2.PoundMoles());
+            Assert.Equal(AmountOfSubstance<double>.FromPoundMoles(2), 2.PoundMoles());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs
index 33b41517be..a2f6325bb1 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToAmplitudeRatioExtensionsTests
     {
         [Fact]
         public void NumberToDecibelMicrovoltsTest() =>
-            Assert.Equal(AmplitudeRatio.FromDecibelMicrovolts(2), 2.DecibelMicrovolts());
+            Assert.Equal(AmplitudeRatio<double>.FromDecibelMicrovolts(2), 2.DecibelMicrovolts());
 
         [Fact]
         public void NumberToDecibelMillivoltsTest() =>
-            Assert.Equal(AmplitudeRatio.FromDecibelMillivolts(2), 2.DecibelMillivolts());
+            Assert.Equal(AmplitudeRatio<double>.FromDecibelMillivolts(2), 2.DecibelMillivolts());
 
         [Fact]
         public void NumberToDecibelsUnloadedTest() =>
-            Assert.Equal(AmplitudeRatio.FromDecibelsUnloaded(2), 2.DecibelsUnloaded());
+            Assert.Equal(AmplitudeRatio<double>.FromDecibelsUnloaded(2), 2.DecibelsUnloaded());
 
         [Fact]
         public void NumberToDecibelVoltsTest() =>
-            Assert.Equal(AmplitudeRatio.FromDecibelVolts(2), 2.DecibelVolts());
+            Assert.Equal(AmplitudeRatio<double>.FromDecibelVolts(2), 2.DecibelVolts());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs
index 9d34cc85c0..78a0e1bbb6 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs
@@ -21,64 +21,64 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToAngleExtensionsTests
     {
         [Fact]
         public void NumberToArcminutesTest() =>
-            Assert.Equal(Angle.FromArcminutes(2), 2.Arcminutes());
+            Assert.Equal(Angle<double>.FromArcminutes(2), 2.Arcminutes());
 
         [Fact]
         public void NumberToArcsecondsTest() =>
-            Assert.Equal(Angle.FromArcseconds(2), 2.Arcseconds());
+            Assert.Equal(Angle<double>.FromArcseconds(2), 2.Arcseconds());
 
         [Fact]
         public void NumberToCentiradiansTest() =>
-            Assert.Equal(Angle.FromCentiradians(2), 2.Centiradians());
+            Assert.Equal(Angle<double>.FromCentiradians(2), 2.Centiradians());
 
         [Fact]
         public void NumberToDeciradiansTest() =>
-            Assert.Equal(Angle.FromDeciradians(2), 2.Deciradians());
+            Assert.Equal(Angle<double>.FromDeciradians(2), 2.Deciradians());
 
         [Fact]
         public void NumberToDegreesTest() =>
-            Assert.Equal(Angle.FromDegrees(2), 2.Degrees());
+            Assert.Equal(Angle<double>.FromDegrees(2), 2.Degrees());
 
         [Fact]
         public void NumberToGradiansTest() =>
-            Assert.Equal(Angle.FromGradians(2), 2.Gradians());
+            Assert.Equal(Angle<double>.FromGradians(2), 2.Gradians());
 
         [Fact]
         public void NumberToMicrodegreesTest() =>
-            Assert.Equal(Angle.FromMicrodegrees(2), 2.Microdegrees());
+            Assert.Equal(Angle<double>.FromMicrodegrees(2), 2.Microdegrees());
 
         [Fact]
         public void NumberToMicroradiansTest() =>
-            Assert.Equal(Angle.FromMicroradians(2), 2.Microradians());
+            Assert.Equal(Angle<double>.FromMicroradians(2), 2.Microradians());
 
         [Fact]
         public void NumberToMillidegreesTest() =>
-            Assert.Equal(Angle.FromMillidegrees(2), 2.Millidegrees());
+            Assert.Equal(Angle<double>.FromMillidegrees(2), 2.Millidegrees());
 
         [Fact]
         public void NumberToMilliradiansTest() =>
-            Assert.Equal(Angle.FromMilliradians(2), 2.Milliradians());
+            Assert.Equal(Angle<double>.FromMilliradians(2), 2.Milliradians());
 
         [Fact]
         public void NumberToNanodegreesTest() =>
-            Assert.Equal(Angle.FromNanodegrees(2), 2.Nanodegrees());
+            Assert.Equal(Angle<double>.FromNanodegrees(2), 2.Nanodegrees());
 
         [Fact]
         public void NumberToNanoradiansTest() =>
-            Assert.Equal(Angle.FromNanoradians(2), 2.Nanoradians());
+            Assert.Equal(Angle<double>.FromNanoradians(2), 2.Nanoradians());
 
         [Fact]
         public void NumberToRadiansTest() =>
-            Assert.Equal(Angle.FromRadians(2), 2.Radians());
+            Assert.Equal(Angle<double>.FromRadians(2), 2.Radians());
 
         [Fact]
         public void NumberToRevolutionsTest() =>
-            Assert.Equal(Angle.FromRevolutions(2), 2.Revolutions());
+            Assert.Equal(Angle<double>.FromRevolutions(2), 2.Revolutions());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs
index 218daac837..cea943d671 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToApparentEnergyExtensionsTests
     {
         [Fact]
         public void NumberToKilovoltampereHoursTest() =>
-            Assert.Equal(ApparentEnergy.FromKilovoltampereHours(2), 2.KilovoltampereHours());
+            Assert.Equal(ApparentEnergy<double>.FromKilovoltampereHours(2), 2.KilovoltampereHours());
 
         [Fact]
         public void NumberToMegavoltampereHoursTest() =>
-            Assert.Equal(ApparentEnergy.FromMegavoltampereHours(2), 2.MegavoltampereHours());
+            Assert.Equal(ApparentEnergy<double>.FromMegavoltampereHours(2), 2.MegavoltampereHours());
 
         [Fact]
         public void NumberToVoltampereHoursTest() =>
-            Assert.Equal(ApparentEnergy.FromVoltampereHours(2), 2.VoltampereHours());
+            Assert.Equal(ApparentEnergy<double>.FromVoltampereHours(2), 2.VoltampereHours());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs
index c7855d37da..736989efc4 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToApparentPowerExtensionsTests
     {
         [Fact]
         public void NumberToGigavoltamperesTest() =>
-            Assert.Equal(ApparentPower.FromGigavoltamperes(2), 2.Gigavoltamperes());
+            Assert.Equal(ApparentPower<double>.FromGigavoltamperes(2), 2.Gigavoltamperes());
 
         [Fact]
         public void NumberToKilovoltamperesTest() =>
-            Assert.Equal(ApparentPower.FromKilovoltamperes(2), 2.Kilovoltamperes());
+            Assert.Equal(ApparentPower<double>.FromKilovoltamperes(2), 2.Kilovoltamperes());
 
         [Fact]
         public void NumberToMegavoltamperesTest() =>
-            Assert.Equal(ApparentPower.FromMegavoltamperes(2), 2.Megavoltamperes());
+            Assert.Equal(ApparentPower<double>.FromMegavoltamperes(2), 2.Megavoltamperes());
 
         [Fact]
         public void NumberToVoltamperesTest() =>
-            Assert.Equal(ApparentPower.FromVoltamperes(2), 2.Voltamperes());
+            Assert.Equal(ApparentPower<double>.FromVoltamperes(2), 2.Voltamperes());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
index e5f721ddc0..d78fd1895e 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToAreaDensityExtensionsTests
     {
         [Fact]
         public void NumberToKilogramsPerSquareMeterTest() =>
-            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(2), 2.KilogramsPerSquareMeter());
+            Assert.Equal(AreaDensity<double>.FromKilogramsPerSquareMeter(2), 2.KilogramsPerSquareMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs
index 4f35ec9d41..7e1c193dbf 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs
@@ -21,64 +21,64 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToAreaExtensionsTests
     {
         [Fact]
         public void NumberToAcresTest() =>
-            Assert.Equal(Area.FromAcres(2), 2.Acres());
+            Assert.Equal(Area<double>.FromAcres(2), 2.Acres());
 
         [Fact]
         public void NumberToHectaresTest() =>
-            Assert.Equal(Area.FromHectares(2), 2.Hectares());
+            Assert.Equal(Area<double>.FromHectares(2), 2.Hectares());
 
         [Fact]
         public void NumberToSquareCentimetersTest() =>
-            Assert.Equal(Area.FromSquareCentimeters(2), 2.SquareCentimeters());
+            Assert.Equal(Area<double>.FromSquareCentimeters(2), 2.SquareCentimeters());
 
         [Fact]
         public void NumberToSquareDecimetersTest() =>
-            Assert.Equal(Area.FromSquareDecimeters(2), 2.SquareDecimeters());
+            Assert.Equal(Area<double>.FromSquareDecimeters(2), 2.SquareDecimeters());
 
         [Fact]
         public void NumberToSquareFeetTest() =>
-            Assert.Equal(Area.FromSquareFeet(2), 2.SquareFeet());
+            Assert.Equal(Area<double>.FromSquareFeet(2), 2.SquareFeet());
 
         [Fact]
         public void NumberToSquareInchesTest() =>
-            Assert.Equal(Area.FromSquareInches(2), 2.SquareInches());
+            Assert.Equal(Area<double>.FromSquareInches(2), 2.SquareInches());
 
         [Fact]
         public void NumberToSquareKilometersTest() =>
-            Assert.Equal(Area.FromSquareKilometers(2), 2.SquareKilometers());
+            Assert.Equal(Area<double>.FromSquareKilometers(2), 2.SquareKilometers());
 
         [Fact]
         public void NumberToSquareMetersTest() =>
-            Assert.Equal(Area.FromSquareMeters(2), 2.SquareMeters());
+            Assert.Equal(Area<double>.FromSquareMeters(2), 2.SquareMeters());
 
         [Fact]
         public void NumberToSquareMicrometersTest() =>
-            Assert.Equal(Area.FromSquareMicrometers(2), 2.SquareMicrometers());
+            Assert.Equal(Area<double>.FromSquareMicrometers(2), 2.SquareMicrometers());
 
         [Fact]
         public void NumberToSquareMilesTest() =>
-            Assert.Equal(Area.FromSquareMiles(2), 2.SquareMiles());
+            Assert.Equal(Area<double>.FromSquareMiles(2), 2.SquareMiles());
 
         [Fact]
         public void NumberToSquareMillimetersTest() =>
-            Assert.Equal(Area.FromSquareMillimeters(2), 2.SquareMillimeters());
+            Assert.Equal(Area<double>.FromSquareMillimeters(2), 2.SquareMillimeters());
 
         [Fact]
         public void NumberToSquareNauticalMilesTest() =>
-            Assert.Equal(Area.FromSquareNauticalMiles(2), 2.SquareNauticalMiles());
+            Assert.Equal(Area<double>.FromSquareNauticalMiles(2), 2.SquareNauticalMiles());
 
         [Fact]
         public void NumberToSquareYardsTest() =>
-            Assert.Equal(Area.FromSquareYards(2), 2.SquareYards());
+            Assert.Equal(Area<double>.FromSquareYards(2), 2.SquareYards());
 
         [Fact]
         public void NumberToUsSurveySquareFeetTest() =>
-            Assert.Equal(Area.FromUsSurveySquareFeet(2), 2.UsSurveySquareFeet());
+            Assert.Equal(Area<double>.FromUsSurveySquareFeet(2), 2.UsSurveySquareFeet());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs
index 217dc33c30..52e32526d3 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs
@@ -21,32 +21,32 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToAreaMomentOfInertiaExtensionsTests
     {
         [Fact]
         public void NumberToCentimetersToTheFourthTest() =>
-            Assert.Equal(AreaMomentOfInertia.FromCentimetersToTheFourth(2), 2.CentimetersToTheFourth());
+            Assert.Equal(AreaMomentOfInertia<double>.FromCentimetersToTheFourth(2), 2.CentimetersToTheFourth());
 
         [Fact]
         public void NumberToDecimetersToTheFourthTest() =>
-            Assert.Equal(AreaMomentOfInertia.FromDecimetersToTheFourth(2), 2.DecimetersToTheFourth());
+            Assert.Equal(AreaMomentOfInertia<double>.FromDecimetersToTheFourth(2), 2.DecimetersToTheFourth());
 
         [Fact]
         public void NumberToFeetToTheFourthTest() =>
-            Assert.Equal(AreaMomentOfInertia.FromFeetToTheFourth(2), 2.FeetToTheFourth());
+            Assert.Equal(AreaMomentOfInertia<double>.FromFeetToTheFourth(2), 2.FeetToTheFourth());
 
         [Fact]
         public void NumberToInchesToTheFourthTest() =>
-            Assert.Equal(AreaMomentOfInertia.FromInchesToTheFourth(2), 2.InchesToTheFourth());
+            Assert.Equal(AreaMomentOfInertia<double>.FromInchesToTheFourth(2), 2.InchesToTheFourth());
 
         [Fact]
         public void NumberToMetersToTheFourthTest() =>
-            Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(2), 2.MetersToTheFourth());
+            Assert.Equal(AreaMomentOfInertia<double>.FromMetersToTheFourth(2), 2.MetersToTheFourth());
 
         [Fact]
         public void NumberToMillimetersToTheFourthTest() =>
-            Assert.Equal(AreaMomentOfInertia.FromMillimetersToTheFourth(2), 2.MillimetersToTheFourth());
+            Assert.Equal(AreaMomentOfInertia<double>.FromMillimetersToTheFourth(2), 2.MillimetersToTheFourth());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs
index 46afbcae68..dae2842870 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs
@@ -21,112 +21,112 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToBitRateExtensionsTests
     {
         [Fact]
         public void NumberToBitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromBitsPerSecond(2), 2.BitsPerSecond());
+            Assert.Equal(BitRate<double>.FromBitsPerSecond(2), 2.BitsPerSecond());
 
         [Fact]
         public void NumberToBytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromBytesPerSecond(2), 2.BytesPerSecond());
+            Assert.Equal(BitRate<double>.FromBytesPerSecond(2), 2.BytesPerSecond());
 
         [Fact]
         public void NumberToExabitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromExabitsPerSecond(2), 2.ExabitsPerSecond());
+            Assert.Equal(BitRate<double>.FromExabitsPerSecond(2), 2.ExabitsPerSecond());
 
         [Fact]
         public void NumberToExabytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromExabytesPerSecond(2), 2.ExabytesPerSecond());
+            Assert.Equal(BitRate<double>.FromExabytesPerSecond(2), 2.ExabytesPerSecond());
 
         [Fact]
         public void NumberToExbibitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromExbibitsPerSecond(2), 2.ExbibitsPerSecond());
+            Assert.Equal(BitRate<double>.FromExbibitsPerSecond(2), 2.ExbibitsPerSecond());
 
         [Fact]
         public void NumberToExbibytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromExbibytesPerSecond(2), 2.ExbibytesPerSecond());
+            Assert.Equal(BitRate<double>.FromExbibytesPerSecond(2), 2.ExbibytesPerSecond());
 
         [Fact]
         public void NumberToGibibitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromGibibitsPerSecond(2), 2.GibibitsPerSecond());
+            Assert.Equal(BitRate<double>.FromGibibitsPerSecond(2), 2.GibibitsPerSecond());
 
         [Fact]
         public void NumberToGibibytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromGibibytesPerSecond(2), 2.GibibytesPerSecond());
+            Assert.Equal(BitRate<double>.FromGibibytesPerSecond(2), 2.GibibytesPerSecond());
 
         [Fact]
         public void NumberToGigabitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromGigabitsPerSecond(2), 2.GigabitsPerSecond());
+            Assert.Equal(BitRate<double>.FromGigabitsPerSecond(2), 2.GigabitsPerSecond());
 
         [Fact]
         public void NumberToGigabytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromGigabytesPerSecond(2), 2.GigabytesPerSecond());
+            Assert.Equal(BitRate<double>.FromGigabytesPerSecond(2), 2.GigabytesPerSecond());
 
         [Fact]
         public void NumberToKibibitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromKibibitsPerSecond(2), 2.KibibitsPerSecond());
+            Assert.Equal(BitRate<double>.FromKibibitsPerSecond(2), 2.KibibitsPerSecond());
 
         [Fact]
         public void NumberToKibibytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromKibibytesPerSecond(2), 2.KibibytesPerSecond());
+            Assert.Equal(BitRate<double>.FromKibibytesPerSecond(2), 2.KibibytesPerSecond());
 
         [Fact]
         public void NumberToKilobitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromKilobitsPerSecond(2), 2.KilobitsPerSecond());
+            Assert.Equal(BitRate<double>.FromKilobitsPerSecond(2), 2.KilobitsPerSecond());
 
         [Fact]
         public void NumberToKilobytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromKilobytesPerSecond(2), 2.KilobytesPerSecond());
+            Assert.Equal(BitRate<double>.FromKilobytesPerSecond(2), 2.KilobytesPerSecond());
 
         [Fact]
         public void NumberToMebibitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromMebibitsPerSecond(2), 2.MebibitsPerSecond());
+            Assert.Equal(BitRate<double>.FromMebibitsPerSecond(2), 2.MebibitsPerSecond());
 
         [Fact]
         public void NumberToMebibytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromMebibytesPerSecond(2), 2.MebibytesPerSecond());
+            Assert.Equal(BitRate<double>.FromMebibytesPerSecond(2), 2.MebibytesPerSecond());
 
         [Fact]
         public void NumberToMegabitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromMegabitsPerSecond(2), 2.MegabitsPerSecond());
+            Assert.Equal(BitRate<double>.FromMegabitsPerSecond(2), 2.MegabitsPerSecond());
 
         [Fact]
         public void NumberToMegabytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromMegabytesPerSecond(2), 2.MegabytesPerSecond());
+            Assert.Equal(BitRate<double>.FromMegabytesPerSecond(2), 2.MegabytesPerSecond());
 
         [Fact]
         public void NumberToPebibitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromPebibitsPerSecond(2), 2.PebibitsPerSecond());
+            Assert.Equal(BitRate<double>.FromPebibitsPerSecond(2), 2.PebibitsPerSecond());
 
         [Fact]
         public void NumberToPebibytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromPebibytesPerSecond(2), 2.PebibytesPerSecond());
+            Assert.Equal(BitRate<double>.FromPebibytesPerSecond(2), 2.PebibytesPerSecond());
 
         [Fact]
         public void NumberToPetabitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromPetabitsPerSecond(2), 2.PetabitsPerSecond());
+            Assert.Equal(BitRate<double>.FromPetabitsPerSecond(2), 2.PetabitsPerSecond());
 
         [Fact]
         public void NumberToPetabytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromPetabytesPerSecond(2), 2.PetabytesPerSecond());
+            Assert.Equal(BitRate<double>.FromPetabytesPerSecond(2), 2.PetabytesPerSecond());
 
         [Fact]
         public void NumberToTebibitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromTebibitsPerSecond(2), 2.TebibitsPerSecond());
+            Assert.Equal(BitRate<double>.FromTebibitsPerSecond(2), 2.TebibitsPerSecond());
 
         [Fact]
         public void NumberToTebibytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromTebibytesPerSecond(2), 2.TebibytesPerSecond());
+            Assert.Equal(BitRate<double>.FromTebibytesPerSecond(2), 2.TebibytesPerSecond());
 
         [Fact]
         public void NumberToTerabitsPerSecondTest() =>
-            Assert.Equal(BitRate.FromTerabitsPerSecond(2), 2.TerabitsPerSecond());
+            Assert.Equal(BitRate<double>.FromTerabitsPerSecond(2), 2.TerabitsPerSecond());
 
         [Fact]
         public void NumberToTerabytesPerSecondTest() =>
-            Assert.Equal(BitRate.FromTerabytesPerSecond(2), 2.TerabytesPerSecond());
+            Assert.Equal(BitRate<double>.FromTerabytesPerSecond(2), 2.TerabytesPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs
index 3d229d9f32..24db5d5d76 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToBrakeSpecificFuelConsumptionExtensionsTests
     {
         [Fact]
         public void NumberToGramsPerKiloWattHourTest() =>
-            Assert.Equal(BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(2), 2.GramsPerKiloWattHour());
+            Assert.Equal(BrakeSpecificFuelConsumption<double>.FromGramsPerKiloWattHour(2), 2.GramsPerKiloWattHour());
 
         [Fact]
         public void NumberToKilogramsPerJouleTest() =>
-            Assert.Equal(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2), 2.KilogramsPerJoule());
+            Assert.Equal(BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(2), 2.KilogramsPerJoule());
 
         [Fact]
         public void NumberToPoundsPerMechanicalHorsepowerHourTest() =>
-            Assert.Equal(BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(2), 2.PoundsPerMechanicalHorsepowerHour());
+            Assert.Equal(BrakeSpecificFuelConsumption<double>.FromPoundsPerMechanicalHorsepowerHour(2), 2.PoundsPerMechanicalHorsepowerHour());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs
index 5fb028ebfd..138ed16f70 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs
@@ -21,36 +21,36 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToCapacitanceExtensionsTests
     {
         [Fact]
         public void NumberToFaradsTest() =>
-            Assert.Equal(Capacitance.FromFarads(2), 2.Farads());
+            Assert.Equal(Capacitance<double>.FromFarads(2), 2.Farads());
 
         [Fact]
         public void NumberToKilofaradsTest() =>
-            Assert.Equal(Capacitance.FromKilofarads(2), 2.Kilofarads());
+            Assert.Equal(Capacitance<double>.FromKilofarads(2), 2.Kilofarads());
 
         [Fact]
         public void NumberToMegafaradsTest() =>
-            Assert.Equal(Capacitance.FromMegafarads(2), 2.Megafarads());
+            Assert.Equal(Capacitance<double>.FromMegafarads(2), 2.Megafarads());
 
         [Fact]
         public void NumberToMicrofaradsTest() =>
-            Assert.Equal(Capacitance.FromMicrofarads(2), 2.Microfarads());
+            Assert.Equal(Capacitance<double>.FromMicrofarads(2), 2.Microfarads());
 
         [Fact]
         public void NumberToMillifaradsTest() =>
-            Assert.Equal(Capacitance.FromMillifarads(2), 2.Millifarads());
+            Assert.Equal(Capacitance<double>.FromMillifarads(2), 2.Millifarads());
 
         [Fact]
         public void NumberToNanofaradsTest() =>
-            Assert.Equal(Capacitance.FromNanofarads(2), 2.Nanofarads());
+            Assert.Equal(Capacitance<double>.FromNanofarads(2), 2.Nanofarads());
 
         [Fact]
         public void NumberToPicofaradsTest() =>
-            Assert.Equal(Capacitance.FromPicofarads(2), 2.Picofarads());
+            Assert.Equal(Capacitance<double>.FromPicofarads(2), 2.Picofarads());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs
index fa1a8d2a47..5068c53ce9 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToCoefficientOfThermalExpansionExtensionsTests
     {
         [Fact]
         public void NumberToInverseDegreeCelsiusTest() =>
-            Assert.Equal(CoefficientOfThermalExpansion.FromInverseDegreeCelsius(2), 2.InverseDegreeCelsius());
+            Assert.Equal(CoefficientOfThermalExpansion<double>.FromInverseDegreeCelsius(2), 2.InverseDegreeCelsius());
 
         [Fact]
         public void NumberToInverseDegreeFahrenheitTest() =>
-            Assert.Equal(CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(2), 2.InverseDegreeFahrenheit());
+            Assert.Equal(CoefficientOfThermalExpansion<double>.FromInverseDegreeFahrenheit(2), 2.InverseDegreeFahrenheit());
 
         [Fact]
         public void NumberToInverseKelvinTest() =>
-            Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(2), 2.InverseKelvin());
+            Assert.Equal(CoefficientOfThermalExpansion<double>.FromInverseKelvin(2), 2.InverseKelvin());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs
index 59f917e45e..50697c067c 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs
@@ -21,168 +21,168 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToDensityExtensionsTests
     {
         [Fact]
         public void NumberToCentigramsPerDeciLiterTest() =>
-            Assert.Equal(Density.FromCentigramsPerDeciLiter(2), 2.CentigramsPerDeciLiter());
+            Assert.Equal(Density<double>.FromCentigramsPerDeciLiter(2), 2.CentigramsPerDeciLiter());
 
         [Fact]
         public void NumberToCentigramsPerLiterTest() =>
-            Assert.Equal(Density.FromCentigramsPerLiter(2), 2.CentigramsPerLiter());
+            Assert.Equal(Density<double>.FromCentigramsPerLiter(2), 2.CentigramsPerLiter());
 
         [Fact]
         public void NumberToCentigramsPerMilliliterTest() =>
-            Assert.Equal(Density.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter());
+            Assert.Equal(Density<double>.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter());
 
         [Fact]
         public void NumberToDecigramsPerDeciLiterTest() =>
-            Assert.Equal(Density.FromDecigramsPerDeciLiter(2), 2.DecigramsPerDeciLiter());
+            Assert.Equal(Density<double>.FromDecigramsPerDeciLiter(2), 2.DecigramsPerDeciLiter());
 
         [Fact]
         public void NumberToDecigramsPerLiterTest() =>
-            Assert.Equal(Density.FromDecigramsPerLiter(2), 2.DecigramsPerLiter());
+            Assert.Equal(Density<double>.FromDecigramsPerLiter(2), 2.DecigramsPerLiter());
 
         [Fact]
         public void NumberToDecigramsPerMilliliterTest() =>
-            Assert.Equal(Density.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter());
+            Assert.Equal(Density<double>.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter());
 
         [Fact]
         public void NumberToGramsPerCubicCentimeterTest() =>
-            Assert.Equal(Density.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter());
+            Assert.Equal(Density<double>.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter());
 
         [Fact]
         public void NumberToGramsPerCubicMeterTest() =>
-            Assert.Equal(Density.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter());
+            Assert.Equal(Density<double>.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter());
 
         [Fact]
         public void NumberToGramsPerCubicMillimeterTest() =>
-            Assert.Equal(Density.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter());
+            Assert.Equal(Density<double>.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter());
 
         [Fact]
         public void NumberToGramsPerDeciLiterTest() =>
-            Assert.Equal(Density.FromGramsPerDeciLiter(2), 2.GramsPerDeciLiter());
+            Assert.Equal(Density<double>.FromGramsPerDeciLiter(2), 2.GramsPerDeciLiter());
 
         [Fact]
         public void NumberToGramsPerLiterTest() =>
-            Assert.Equal(Density.FromGramsPerLiter(2), 2.GramsPerLiter());
+            Assert.Equal(Density<double>.FromGramsPerLiter(2), 2.GramsPerLiter());
 
         [Fact]
         public void NumberToGramsPerMilliliterTest() =>
-            Assert.Equal(Density.FromGramsPerMilliliter(2), 2.GramsPerMilliliter());
+            Assert.Equal(Density<double>.FromGramsPerMilliliter(2), 2.GramsPerMilliliter());
 
         [Fact]
         public void NumberToKilogramsPerCubicCentimeterTest() =>
-            Assert.Equal(Density.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter());
+            Assert.Equal(Density<double>.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter());
 
         [Fact]
         public void NumberToKilogramsPerCubicMeterTest() =>
-            Assert.Equal(Density.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter());
+            Assert.Equal(Density<double>.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter());
 
         [Fact]
         public void NumberToKilogramsPerCubicMillimeterTest() =>
-            Assert.Equal(Density.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter());
+            Assert.Equal(Density<double>.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter());
 
         [Fact]
         public void NumberToKilogramsPerLiterTest() =>
-            Assert.Equal(Density.FromKilogramsPerLiter(2), 2.KilogramsPerLiter());
+            Assert.Equal(Density<double>.FromKilogramsPerLiter(2), 2.KilogramsPerLiter());
 
         [Fact]
         public void NumberToKilopoundsPerCubicFootTest() =>
-            Assert.Equal(Density.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot());
+            Assert.Equal(Density<double>.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot());
 
         [Fact]
         public void NumberToKilopoundsPerCubicInchTest() =>
-            Assert.Equal(Density.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch());
+            Assert.Equal(Density<double>.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch());
 
         [Fact]
         public void NumberToMicrogramsPerCubicMeterTest() =>
-            Assert.Equal(Density.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter());
+            Assert.Equal(Density<double>.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter());
 
         [Fact]
         public void NumberToMicrogramsPerDeciLiterTest() =>
-            Assert.Equal(Density.FromMicrogramsPerDeciLiter(2), 2.MicrogramsPerDeciLiter());
+            Assert.Equal(Density<double>.FromMicrogramsPerDeciLiter(2), 2.MicrogramsPerDeciLiter());
 
         [Fact]
         public void NumberToMicrogramsPerLiterTest() =>
-            Assert.Equal(Density.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter());
+            Assert.Equal(Density<double>.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter());
 
         [Fact]
         public void NumberToMicrogramsPerMilliliterTest() =>
-            Assert.Equal(Density.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter());
+            Assert.Equal(Density<double>.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter());
 
         [Fact]
         public void NumberToMilligramsPerCubicMeterTest() =>
-            Assert.Equal(Density.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter());
+            Assert.Equal(Density<double>.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter());
 
         [Fact]
         public void NumberToMilligramsPerDeciLiterTest() =>
-            Assert.Equal(Density.FromMilligramsPerDeciLiter(2), 2.MilligramsPerDeciLiter());
+            Assert.Equal(Density<double>.FromMilligramsPerDeciLiter(2), 2.MilligramsPerDeciLiter());
 
         [Fact]
         public void NumberToMilligramsPerLiterTest() =>
-            Assert.Equal(Density.FromMilligramsPerLiter(2), 2.MilligramsPerLiter());
+            Assert.Equal(Density<double>.FromMilligramsPerLiter(2), 2.MilligramsPerLiter());
 
         [Fact]
         public void NumberToMilligramsPerMilliliterTest() =>
-            Assert.Equal(Density.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter());
+            Assert.Equal(Density<double>.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter());
 
         [Fact]
         public void NumberToNanogramsPerDeciLiterTest() =>
-            Assert.Equal(Density.FromNanogramsPerDeciLiter(2), 2.NanogramsPerDeciLiter());
+            Assert.Equal(Density<double>.FromNanogramsPerDeciLiter(2), 2.NanogramsPerDeciLiter());
 
         [Fact]
         public void NumberToNanogramsPerLiterTest() =>
-            Assert.Equal(Density.FromNanogramsPerLiter(2), 2.NanogramsPerLiter());
+            Assert.Equal(Density<double>.FromNanogramsPerLiter(2), 2.NanogramsPerLiter());
 
         [Fact]
         public void NumberToNanogramsPerMilliliterTest() =>
-            Assert.Equal(Density.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter());
+            Assert.Equal(Density<double>.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter());
 
         [Fact]
         public void NumberToPicogramsPerDeciLiterTest() =>
-            Assert.Equal(Density.FromPicogramsPerDeciLiter(2), 2.PicogramsPerDeciLiter());
+            Assert.Equal(Density<double>.FromPicogramsPerDeciLiter(2), 2.PicogramsPerDeciLiter());
 
         [Fact]
         public void NumberToPicogramsPerLiterTest() =>
-            Assert.Equal(Density.FromPicogramsPerLiter(2), 2.PicogramsPerLiter());
+            Assert.Equal(Density<double>.FromPicogramsPerLiter(2), 2.PicogramsPerLiter());
 
         [Fact]
         public void NumberToPicogramsPerMilliliterTest() =>
-            Assert.Equal(Density.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter());
+            Assert.Equal(Density<double>.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter());
 
         [Fact]
         public void NumberToPoundsPerCubicFootTest() =>
-            Assert.Equal(Density.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot());
+            Assert.Equal(Density<double>.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot());
 
         [Fact]
         public void NumberToPoundsPerCubicInchTest() =>
-            Assert.Equal(Density.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch());
+            Assert.Equal(Density<double>.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch());
 
         [Fact]
         public void NumberToPoundsPerImperialGallonTest() =>
-            Assert.Equal(Density.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon());
+            Assert.Equal(Density<double>.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon());
 
         [Fact]
         public void NumberToPoundsPerUSGallonTest() =>
-            Assert.Equal(Density.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon());
+            Assert.Equal(Density<double>.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon());
 
         [Fact]
         public void NumberToSlugsPerCubicFootTest() =>
-            Assert.Equal(Density.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot());
+            Assert.Equal(Density<double>.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot());
 
         [Fact]
         public void NumberToTonnesPerCubicCentimeterTest() =>
-            Assert.Equal(Density.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter());
+            Assert.Equal(Density<double>.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter());
 
         [Fact]
         public void NumberToTonnesPerCubicMeterTest() =>
-            Assert.Equal(Density.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter());
+            Assert.Equal(Density<double>.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter());
 
         [Fact]
         public void NumberToTonnesPerCubicMillimeterTest() =>
-            Assert.Equal(Density.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter());
+            Assert.Equal(Density<double>.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs
index 93fc192f86..06a70d4826 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs
@@ -21,48 +21,48 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToDurationExtensionsTests
     {
         [Fact]
         public void NumberToDaysTest() =>
-            Assert.Equal(Duration.FromDays(2), 2.Days());
+            Assert.Equal(Duration<double>.FromDays(2), 2.Days());
 
         [Fact]
         public void NumberToHoursTest() =>
-            Assert.Equal(Duration.FromHours(2), 2.Hours());
+            Assert.Equal(Duration<double>.FromHours(2), 2.Hours());
 
         [Fact]
         public void NumberToMicrosecondsTest() =>
-            Assert.Equal(Duration.FromMicroseconds(2), 2.Microseconds());
+            Assert.Equal(Duration<double>.FromMicroseconds(2), 2.Microseconds());
 
         [Fact]
         public void NumberToMillisecondsTest() =>
-            Assert.Equal(Duration.FromMilliseconds(2), 2.Milliseconds());
+            Assert.Equal(Duration<double>.FromMilliseconds(2), 2.Milliseconds());
 
         [Fact]
         public void NumberToMinutesTest() =>
-            Assert.Equal(Duration.FromMinutes(2), 2.Minutes());
+            Assert.Equal(Duration<double>.FromMinutes(2), 2.Minutes());
 
         [Fact]
         public void NumberToMonths30Test() =>
-            Assert.Equal(Duration.FromMonths30(2), 2.Months30());
+            Assert.Equal(Duration<double>.FromMonths30(2), 2.Months30());
 
         [Fact]
         public void NumberToNanosecondsTest() =>
-            Assert.Equal(Duration.FromNanoseconds(2), 2.Nanoseconds());
+            Assert.Equal(Duration<double>.FromNanoseconds(2), 2.Nanoseconds());
 
         [Fact]
         public void NumberToSecondsTest() =>
-            Assert.Equal(Duration.FromSeconds(2), 2.Seconds());
+            Assert.Equal(Duration<double>.FromSeconds(2), 2.Seconds());
 
         [Fact]
         public void NumberToWeeksTest() =>
-            Assert.Equal(Duration.FromWeeks(2), 2.Weeks());
+            Assert.Equal(Duration<double>.FromWeeks(2), 2.Weeks());
 
         [Fact]
         public void NumberToYears365Test() =>
-            Assert.Equal(Duration.FromYears365(2), 2.Years365());
+            Assert.Equal(Duration<double>.FromYears365(2), 2.Years365());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs
index f82aec3c5b..da83f442e1 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs
@@ -21,48 +21,48 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToDynamicViscosityExtensionsTests
     {
         [Fact]
         public void NumberToCentipoiseTest() =>
-            Assert.Equal(DynamicViscosity.FromCentipoise(2), 2.Centipoise());
+            Assert.Equal(DynamicViscosity<double>.FromCentipoise(2), 2.Centipoise());
 
         [Fact]
         public void NumberToMicropascalSecondsTest() =>
-            Assert.Equal(DynamicViscosity.FromMicropascalSeconds(2), 2.MicropascalSeconds());
+            Assert.Equal(DynamicViscosity<double>.FromMicropascalSeconds(2), 2.MicropascalSeconds());
 
         [Fact]
         public void NumberToMillipascalSecondsTest() =>
-            Assert.Equal(DynamicViscosity.FromMillipascalSeconds(2), 2.MillipascalSeconds());
+            Assert.Equal(DynamicViscosity<double>.FromMillipascalSeconds(2), 2.MillipascalSeconds());
 
         [Fact]
         public void NumberToNewtonSecondsPerMeterSquaredTest() =>
-            Assert.Equal(DynamicViscosity.FromNewtonSecondsPerMeterSquared(2), 2.NewtonSecondsPerMeterSquared());
+            Assert.Equal(DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(2), 2.NewtonSecondsPerMeterSquared());
 
         [Fact]
         public void NumberToPascalSecondsTest() =>
-            Assert.Equal(DynamicViscosity.FromPascalSeconds(2), 2.PascalSeconds());
+            Assert.Equal(DynamicViscosity<double>.FromPascalSeconds(2), 2.PascalSeconds());
 
         [Fact]
         public void NumberToPoiseTest() =>
-            Assert.Equal(DynamicViscosity.FromPoise(2), 2.Poise());
+            Assert.Equal(DynamicViscosity<double>.FromPoise(2), 2.Poise());
 
         [Fact]
         public void NumberToPoundsForceSecondPerSquareFootTest() =>
-            Assert.Equal(DynamicViscosity.FromPoundsForceSecondPerSquareFoot(2), 2.PoundsForceSecondPerSquareFoot());
+            Assert.Equal(DynamicViscosity<double>.FromPoundsForceSecondPerSquareFoot(2), 2.PoundsForceSecondPerSquareFoot());
 
         [Fact]
         public void NumberToPoundsForceSecondPerSquareInchTest() =>
-            Assert.Equal(DynamicViscosity.FromPoundsForceSecondPerSquareInch(2), 2.PoundsForceSecondPerSquareInch());
+            Assert.Equal(DynamicViscosity<double>.FromPoundsForceSecondPerSquareInch(2), 2.PoundsForceSecondPerSquareInch());
 
         [Fact]
         public void NumberToPoundsPerFootSecondTest() =>
-            Assert.Equal(DynamicViscosity.FromPoundsPerFootSecond(2), 2.PoundsPerFootSecond());
+            Assert.Equal(DynamicViscosity<double>.FromPoundsPerFootSecond(2), 2.PoundsPerFootSecond());
 
         [Fact]
         public void NumberToReynsTest() =>
-            Assert.Equal(DynamicViscosity.FromReyns(2), 2.Reyns());
+            Assert.Equal(DynamicViscosity<double>.FromReyns(2), 2.Reyns());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs
index 92e38cf4a3..bda61f3c96 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricAdmittanceExtensionsTests
     {
         [Fact]
         public void NumberToMicrosiemensTest() =>
-            Assert.Equal(ElectricAdmittance.FromMicrosiemens(2), 2.Microsiemens());
+            Assert.Equal(ElectricAdmittance<double>.FromMicrosiemens(2), 2.Microsiemens());
 
         [Fact]
         public void NumberToMillisiemensTest() =>
-            Assert.Equal(ElectricAdmittance.FromMillisiemens(2), 2.Millisiemens());
+            Assert.Equal(ElectricAdmittance<double>.FromMillisiemens(2), 2.Millisiemens());
 
         [Fact]
         public void NumberToNanosiemensTest() =>
-            Assert.Equal(ElectricAdmittance.FromNanosiemens(2), 2.Nanosiemens());
+            Assert.Equal(ElectricAdmittance<double>.FromNanosiemens(2), 2.Nanosiemens());
 
         [Fact]
         public void NumberToSiemensTest() =>
-            Assert.Equal(ElectricAdmittance.FromSiemens(2), 2.Siemens());
+            Assert.Equal(ElectricAdmittance<double>.FromSiemens(2), 2.Siemens());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs
index e947ba90e4..7a0300e80c 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricChargeDensityExtensionsTests
     {
         [Fact]
         public void NumberToCoulombsPerCubicMeterTest() =>
-            Assert.Equal(ElectricChargeDensity.FromCoulombsPerCubicMeter(2), 2.CoulombsPerCubicMeter());
+            Assert.Equal(ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(2), 2.CoulombsPerCubicMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs
index 2e2de22eb3..32d888f509 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs
@@ -21,28 +21,28 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricChargeExtensionsTests
     {
         [Fact]
         public void NumberToAmpereHoursTest() =>
-            Assert.Equal(ElectricCharge.FromAmpereHours(2), 2.AmpereHours());
+            Assert.Equal(ElectricCharge<double>.FromAmpereHours(2), 2.AmpereHours());
 
         [Fact]
         public void NumberToCoulombsTest() =>
-            Assert.Equal(ElectricCharge.FromCoulombs(2), 2.Coulombs());
+            Assert.Equal(ElectricCharge<double>.FromCoulombs(2), 2.Coulombs());
 
         [Fact]
         public void NumberToKiloampereHoursTest() =>
-            Assert.Equal(ElectricCharge.FromKiloampereHours(2), 2.KiloampereHours());
+            Assert.Equal(ElectricCharge<double>.FromKiloampereHours(2), 2.KiloampereHours());
 
         [Fact]
         public void NumberToMegaampereHoursTest() =>
-            Assert.Equal(ElectricCharge.FromMegaampereHours(2), 2.MegaampereHours());
+            Assert.Equal(ElectricCharge<double>.FromMegaampereHours(2), 2.MegaampereHours());
 
         [Fact]
         public void NumberToMilliampereHoursTest() =>
-            Assert.Equal(ElectricCharge.FromMilliampereHours(2), 2.MilliampereHours());
+            Assert.Equal(ElectricCharge<double>.FromMilliampereHours(2), 2.MilliampereHours());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs
index e6640aa1d5..771b52fa39 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricConductanceExtensionsTests
     {
         [Fact]
         public void NumberToMicrosiemensTest() =>
-            Assert.Equal(ElectricConductance.FromMicrosiemens(2), 2.Microsiemens());
+            Assert.Equal(ElectricConductance<double>.FromMicrosiemens(2), 2.Microsiemens());
 
         [Fact]
         public void NumberToMillisiemensTest() =>
-            Assert.Equal(ElectricConductance.FromMillisiemens(2), 2.Millisiemens());
+            Assert.Equal(ElectricConductance<double>.FromMillisiemens(2), 2.Millisiemens());
 
         [Fact]
         public void NumberToSiemensTest() =>
-            Assert.Equal(ElectricConductance.FromSiemens(2), 2.Siemens());
+            Assert.Equal(ElectricConductance<double>.FromSiemens(2), 2.Siemens());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs
index 7abe9c5bbe..19d67fe30a 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricConductivityExtensionsTests
     {
         [Fact]
         public void NumberToSiemensPerFootTest() =>
-            Assert.Equal(ElectricConductivity.FromSiemensPerFoot(2), 2.SiemensPerFoot());
+            Assert.Equal(ElectricConductivity<double>.FromSiemensPerFoot(2), 2.SiemensPerFoot());
 
         [Fact]
         public void NumberToSiemensPerInchTest() =>
-            Assert.Equal(ElectricConductivity.FromSiemensPerInch(2), 2.SiemensPerInch());
+            Assert.Equal(ElectricConductivity<double>.FromSiemensPerInch(2), 2.SiemensPerInch());
 
         [Fact]
         public void NumberToSiemensPerMeterTest() =>
-            Assert.Equal(ElectricConductivity.FromSiemensPerMeter(2), 2.SiemensPerMeter());
+            Assert.Equal(ElectricConductivity<double>.FromSiemensPerMeter(2), 2.SiemensPerMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs
index d07398f18c..b66a856b46 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricCurrentDensityExtensionsTests
     {
         [Fact]
         public void NumberToAmperesPerSquareFootTest() =>
-            Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareFoot(2), 2.AmperesPerSquareFoot());
+            Assert.Equal(ElectricCurrentDensity<double>.FromAmperesPerSquareFoot(2), 2.AmperesPerSquareFoot());
 
         [Fact]
         public void NumberToAmperesPerSquareInchTest() =>
-            Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareInch(2), 2.AmperesPerSquareInch());
+            Assert.Equal(ElectricCurrentDensity<double>.FromAmperesPerSquareInch(2), 2.AmperesPerSquareInch());
 
         [Fact]
         public void NumberToAmperesPerSquareMeterTest() =>
-            Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareMeter(2), 2.AmperesPerSquareMeter());
+            Assert.Equal(ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(2), 2.AmperesPerSquareMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs
index a8e9233ca1..e4bc42a9a2 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs
@@ -21,40 +21,40 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricCurrentExtensionsTests
     {
         [Fact]
         public void NumberToAmperesTest() =>
-            Assert.Equal(ElectricCurrent.FromAmperes(2), 2.Amperes());
+            Assert.Equal(ElectricCurrent<double>.FromAmperes(2), 2.Amperes());
 
         [Fact]
         public void NumberToCentiamperesTest() =>
-            Assert.Equal(ElectricCurrent.FromCentiamperes(2), 2.Centiamperes());
+            Assert.Equal(ElectricCurrent<double>.FromCentiamperes(2), 2.Centiamperes());
 
         [Fact]
         public void NumberToKiloamperesTest() =>
-            Assert.Equal(ElectricCurrent.FromKiloamperes(2), 2.Kiloamperes());
+            Assert.Equal(ElectricCurrent<double>.FromKiloamperes(2), 2.Kiloamperes());
 
         [Fact]
         public void NumberToMegaamperesTest() =>
-            Assert.Equal(ElectricCurrent.FromMegaamperes(2), 2.Megaamperes());
+            Assert.Equal(ElectricCurrent<double>.FromMegaamperes(2), 2.Megaamperes());
 
         [Fact]
         public void NumberToMicroamperesTest() =>
-            Assert.Equal(ElectricCurrent.FromMicroamperes(2), 2.Microamperes());
+            Assert.Equal(ElectricCurrent<double>.FromMicroamperes(2), 2.Microamperes());
 
         [Fact]
         public void NumberToMilliamperesTest() =>
-            Assert.Equal(ElectricCurrent.FromMilliamperes(2), 2.Milliamperes());
+            Assert.Equal(ElectricCurrent<double>.FromMilliamperes(2), 2.Milliamperes());
 
         [Fact]
         public void NumberToNanoamperesTest() =>
-            Assert.Equal(ElectricCurrent.FromNanoamperes(2), 2.Nanoamperes());
+            Assert.Equal(ElectricCurrent<double>.FromNanoamperes(2), 2.Nanoamperes());
 
         [Fact]
         public void NumberToPicoamperesTest() =>
-            Assert.Equal(ElectricCurrent.FromPicoamperes(2), 2.Picoamperes());
+            Assert.Equal(ElectricCurrent<double>.FromPicoamperes(2), 2.Picoamperes());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs
index e2df64f669..294954cb3e 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricCurrentGradientExtensionsTests
     {
         [Fact]
         public void NumberToAmperesPerMicrosecondTest() =>
-            Assert.Equal(ElectricCurrentGradient.FromAmperesPerMicrosecond(2), 2.AmperesPerMicrosecond());
+            Assert.Equal(ElectricCurrentGradient<double>.FromAmperesPerMicrosecond(2), 2.AmperesPerMicrosecond());
 
         [Fact]
         public void NumberToAmperesPerMillisecondTest() =>
-            Assert.Equal(ElectricCurrentGradient.FromAmperesPerMillisecond(2), 2.AmperesPerMillisecond());
+            Assert.Equal(ElectricCurrentGradient<double>.FromAmperesPerMillisecond(2), 2.AmperesPerMillisecond());
 
         [Fact]
         public void NumberToAmperesPerNanosecondTest() =>
-            Assert.Equal(ElectricCurrentGradient.FromAmperesPerNanosecond(2), 2.AmperesPerNanosecond());
+            Assert.Equal(ElectricCurrentGradient<double>.FromAmperesPerNanosecond(2), 2.AmperesPerNanosecond());
 
         [Fact]
         public void NumberToAmperesPerSecondTest() =>
-            Assert.Equal(ElectricCurrentGradient.FromAmperesPerSecond(2), 2.AmperesPerSecond());
+            Assert.Equal(ElectricCurrentGradient<double>.FromAmperesPerSecond(2), 2.AmperesPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs
index 633c0ad865..46d4c55fcb 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricFieldExtensionsTests
     {
         [Fact]
         public void NumberToVoltsPerMeterTest() =>
-            Assert.Equal(ElectricField.FromVoltsPerMeter(2), 2.VoltsPerMeter());
+            Assert.Equal(ElectricField<double>.FromVoltsPerMeter(2), 2.VoltsPerMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs
index 59869a90f2..cca05f069b 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricInductanceExtensionsTests
     {
         [Fact]
         public void NumberToHenriesTest() =>
-            Assert.Equal(ElectricInductance.FromHenries(2), 2.Henries());
+            Assert.Equal(ElectricInductance<double>.FromHenries(2), 2.Henries());
 
         [Fact]
         public void NumberToMicrohenriesTest() =>
-            Assert.Equal(ElectricInductance.FromMicrohenries(2), 2.Microhenries());
+            Assert.Equal(ElectricInductance<double>.FromMicrohenries(2), 2.Microhenries());
 
         [Fact]
         public void NumberToMillihenriesTest() =>
-            Assert.Equal(ElectricInductance.FromMillihenries(2), 2.Millihenries());
+            Assert.Equal(ElectricInductance<double>.FromMillihenries(2), 2.Millihenries());
 
         [Fact]
         public void NumberToNanohenriesTest() =>
-            Assert.Equal(ElectricInductance.FromNanohenries(2), 2.Nanohenries());
+            Assert.Equal(ElectricInductance<double>.FromNanohenries(2), 2.Nanohenries());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs
index 54337c2287..845c68ff51 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs
@@ -21,28 +21,28 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricPotentialAcExtensionsTests
     {
         [Fact]
         public void NumberToKilovoltsAcTest() =>
-            Assert.Equal(ElectricPotentialAc.FromKilovoltsAc(2), 2.KilovoltsAc());
+            Assert.Equal(ElectricPotentialAc<double>.FromKilovoltsAc(2), 2.KilovoltsAc());
 
         [Fact]
         public void NumberToMegavoltsAcTest() =>
-            Assert.Equal(ElectricPotentialAc.FromMegavoltsAc(2), 2.MegavoltsAc());
+            Assert.Equal(ElectricPotentialAc<double>.FromMegavoltsAc(2), 2.MegavoltsAc());
 
         [Fact]
         public void NumberToMicrovoltsAcTest() =>
-            Assert.Equal(ElectricPotentialAc.FromMicrovoltsAc(2), 2.MicrovoltsAc());
+            Assert.Equal(ElectricPotentialAc<double>.FromMicrovoltsAc(2), 2.MicrovoltsAc());
 
         [Fact]
         public void NumberToMillivoltsAcTest() =>
-            Assert.Equal(ElectricPotentialAc.FromMillivoltsAc(2), 2.MillivoltsAc());
+            Assert.Equal(ElectricPotentialAc<double>.FromMillivoltsAc(2), 2.MillivoltsAc());
 
         [Fact]
         public void NumberToVoltsAcTest() =>
-            Assert.Equal(ElectricPotentialAc.FromVoltsAc(2), 2.VoltsAc());
+            Assert.Equal(ElectricPotentialAc<double>.FromVoltsAc(2), 2.VoltsAc());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs
index ce9ca9e848..ca30d858fb 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs
@@ -21,88 +21,88 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricPotentialChangeRateExtensionsTests
     {
         [Fact]
         public void NumberToKilovoltsPerHoursTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerHours(2), 2.KilovoltsPerHours());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromKilovoltsPerHours(2), 2.KilovoltsPerHours());
 
         [Fact]
         public void NumberToKilovoltsPerMicrosecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMicroseconds(2), 2.KilovoltsPerMicroseconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromKilovoltsPerMicroseconds(2), 2.KilovoltsPerMicroseconds());
 
         [Fact]
         public void NumberToKilovoltsPerMinutesTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMinutes(2), 2.KilovoltsPerMinutes());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromKilovoltsPerMinutes(2), 2.KilovoltsPerMinutes());
 
         [Fact]
         public void NumberToKilovoltsPerSecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerSeconds(2), 2.KilovoltsPerSeconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromKilovoltsPerSeconds(2), 2.KilovoltsPerSeconds());
 
         [Fact]
         public void NumberToMegavoltsPerHoursTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerHours(2), 2.MegavoltsPerHours());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMegavoltsPerHours(2), 2.MegavoltsPerHours());
 
         [Fact]
         public void NumberToMegavoltsPerMicrosecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMicroseconds(2), 2.MegavoltsPerMicroseconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMegavoltsPerMicroseconds(2), 2.MegavoltsPerMicroseconds());
 
         [Fact]
         public void NumberToMegavoltsPerMinutesTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMinutes(2), 2.MegavoltsPerMinutes());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMegavoltsPerMinutes(2), 2.MegavoltsPerMinutes());
 
         [Fact]
         public void NumberToMegavoltsPerSecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerSeconds(2), 2.MegavoltsPerSeconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMegavoltsPerSeconds(2), 2.MegavoltsPerSeconds());
 
         [Fact]
         public void NumberToMicrovoltsPerHoursTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerHours(2), 2.MicrovoltsPerHours());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMicrovoltsPerHours(2), 2.MicrovoltsPerHours());
 
         [Fact]
         public void NumberToMicrovoltsPerMicrosecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMicroseconds(2), 2.MicrovoltsPerMicroseconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMicrovoltsPerMicroseconds(2), 2.MicrovoltsPerMicroseconds());
 
         [Fact]
         public void NumberToMicrovoltsPerMinutesTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMinutes(2), 2.MicrovoltsPerMinutes());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMicrovoltsPerMinutes(2), 2.MicrovoltsPerMinutes());
 
         [Fact]
         public void NumberToMicrovoltsPerSecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerSeconds(2), 2.MicrovoltsPerSeconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMicrovoltsPerSeconds(2), 2.MicrovoltsPerSeconds());
 
         [Fact]
         public void NumberToMillivoltsPerHoursTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerHours(2), 2.MillivoltsPerHours());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMillivoltsPerHours(2), 2.MillivoltsPerHours());
 
         [Fact]
         public void NumberToMillivoltsPerMicrosecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMicroseconds(2), 2.MillivoltsPerMicroseconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMillivoltsPerMicroseconds(2), 2.MillivoltsPerMicroseconds());
 
         [Fact]
         public void NumberToMillivoltsPerMinutesTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMinutes(2), 2.MillivoltsPerMinutes());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMillivoltsPerMinutes(2), 2.MillivoltsPerMinutes());
 
         [Fact]
         public void NumberToMillivoltsPerSecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerSeconds(2), 2.MillivoltsPerSeconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromMillivoltsPerSeconds(2), 2.MillivoltsPerSeconds());
 
         [Fact]
         public void NumberToVoltsPerHoursTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerHours(2), 2.VoltsPerHours());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromVoltsPerHours(2), 2.VoltsPerHours());
 
         [Fact]
         public void NumberToVoltsPerMicrosecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMicroseconds(2), 2.VoltsPerMicroseconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromVoltsPerMicroseconds(2), 2.VoltsPerMicroseconds());
 
         [Fact]
         public void NumberToVoltsPerMinutesTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMinutes(2), 2.VoltsPerMinutes());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromVoltsPerMinutes(2), 2.VoltsPerMinutes());
 
         [Fact]
         public void NumberToVoltsPerSecondsTest() =>
-            Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerSeconds(2), 2.VoltsPerSeconds());
+            Assert.Equal(ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(2), 2.VoltsPerSeconds());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs
index 2c058240c3..863857ba42 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs
@@ -21,28 +21,28 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricPotentialDcExtensionsTests
     {
         [Fact]
         public void NumberToKilovoltsDcTest() =>
-            Assert.Equal(ElectricPotentialDc.FromKilovoltsDc(2), 2.KilovoltsDc());
+            Assert.Equal(ElectricPotentialDc<double>.FromKilovoltsDc(2), 2.KilovoltsDc());
 
         [Fact]
         public void NumberToMegavoltsDcTest() =>
-            Assert.Equal(ElectricPotentialDc.FromMegavoltsDc(2), 2.MegavoltsDc());
+            Assert.Equal(ElectricPotentialDc<double>.FromMegavoltsDc(2), 2.MegavoltsDc());
 
         [Fact]
         public void NumberToMicrovoltsDcTest() =>
-            Assert.Equal(ElectricPotentialDc.FromMicrovoltsDc(2), 2.MicrovoltsDc());
+            Assert.Equal(ElectricPotentialDc<double>.FromMicrovoltsDc(2), 2.MicrovoltsDc());
 
         [Fact]
         public void NumberToMillivoltsDcTest() =>
-            Assert.Equal(ElectricPotentialDc.FromMillivoltsDc(2), 2.MillivoltsDc());
+            Assert.Equal(ElectricPotentialDc<double>.FromMillivoltsDc(2), 2.MillivoltsDc());
 
         [Fact]
         public void NumberToVoltsDcTest() =>
-            Assert.Equal(ElectricPotentialDc.FromVoltsDc(2), 2.VoltsDc());
+            Assert.Equal(ElectricPotentialDc<double>.FromVoltsDc(2), 2.VoltsDc());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs
index 799c7ae5bc..1d3166c3ef 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs
@@ -21,28 +21,28 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricPotentialExtensionsTests
     {
         [Fact]
         public void NumberToKilovoltsTest() =>
-            Assert.Equal(ElectricPotential.FromKilovolts(2), 2.Kilovolts());
+            Assert.Equal(ElectricPotential<double>.FromKilovolts(2), 2.Kilovolts());
 
         [Fact]
         public void NumberToMegavoltsTest() =>
-            Assert.Equal(ElectricPotential.FromMegavolts(2), 2.Megavolts());
+            Assert.Equal(ElectricPotential<double>.FromMegavolts(2), 2.Megavolts());
 
         [Fact]
         public void NumberToMicrovoltsTest() =>
-            Assert.Equal(ElectricPotential.FromMicrovolts(2), 2.Microvolts());
+            Assert.Equal(ElectricPotential<double>.FromMicrovolts(2), 2.Microvolts());
 
         [Fact]
         public void NumberToMillivoltsTest() =>
-            Assert.Equal(ElectricPotential.FromMillivolts(2), 2.Millivolts());
+            Assert.Equal(ElectricPotential<double>.FromMillivolts(2), 2.Millivolts());
 
         [Fact]
         public void NumberToVoltsTest() =>
-            Assert.Equal(ElectricPotential.FromVolts(2), 2.Volts());
+            Assert.Equal(ElectricPotential<double>.FromVolts(2), 2.Volts());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs
index ee33155d98..4bb943f9cf 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs
@@ -21,32 +21,32 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricResistanceExtensionsTests
     {
         [Fact]
         public void NumberToGigaohmsTest() =>
-            Assert.Equal(ElectricResistance.FromGigaohms(2), 2.Gigaohms());
+            Assert.Equal(ElectricResistance<double>.FromGigaohms(2), 2.Gigaohms());
 
         [Fact]
         public void NumberToKiloohmsTest() =>
-            Assert.Equal(ElectricResistance.FromKiloohms(2), 2.Kiloohms());
+            Assert.Equal(ElectricResistance<double>.FromKiloohms(2), 2.Kiloohms());
 
         [Fact]
         public void NumberToMegaohmsTest() =>
-            Assert.Equal(ElectricResistance.FromMegaohms(2), 2.Megaohms());
+            Assert.Equal(ElectricResistance<double>.FromMegaohms(2), 2.Megaohms());
 
         [Fact]
         public void NumberToMicroohmsTest() =>
-            Assert.Equal(ElectricResistance.FromMicroohms(2), 2.Microohms());
+            Assert.Equal(ElectricResistance<double>.FromMicroohms(2), 2.Microohms());
 
         [Fact]
         public void NumberToMilliohmsTest() =>
-            Assert.Equal(ElectricResistance.FromMilliohms(2), 2.Milliohms());
+            Assert.Equal(ElectricResistance<double>.FromMilliohms(2), 2.Milliohms());
 
         [Fact]
         public void NumberToOhmsTest() =>
-            Assert.Equal(ElectricResistance.FromOhms(2), 2.Ohms());
+            Assert.Equal(ElectricResistance<double>.FromOhms(2), 2.Ohms());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs
index 6a50c427e4..2fb6a8f77c 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs
@@ -21,64 +21,64 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricResistivityExtensionsTests
     {
         [Fact]
         public void NumberToKiloohmsCentimeterTest() =>
-            Assert.Equal(ElectricResistivity.FromKiloohmsCentimeter(2), 2.KiloohmsCentimeter());
+            Assert.Equal(ElectricResistivity<double>.FromKiloohmsCentimeter(2), 2.KiloohmsCentimeter());
 
         [Fact]
         public void NumberToKiloohmMetersTest() =>
-            Assert.Equal(ElectricResistivity.FromKiloohmMeters(2), 2.KiloohmMeters());
+            Assert.Equal(ElectricResistivity<double>.FromKiloohmMeters(2), 2.KiloohmMeters());
 
         [Fact]
         public void NumberToMegaohmsCentimeterTest() =>
-            Assert.Equal(ElectricResistivity.FromMegaohmsCentimeter(2), 2.MegaohmsCentimeter());
+            Assert.Equal(ElectricResistivity<double>.FromMegaohmsCentimeter(2), 2.MegaohmsCentimeter());
 
         [Fact]
         public void NumberToMegaohmMetersTest() =>
-            Assert.Equal(ElectricResistivity.FromMegaohmMeters(2), 2.MegaohmMeters());
+            Assert.Equal(ElectricResistivity<double>.FromMegaohmMeters(2), 2.MegaohmMeters());
 
         [Fact]
         public void NumberToMicroohmsCentimeterTest() =>
-            Assert.Equal(ElectricResistivity.FromMicroohmsCentimeter(2), 2.MicroohmsCentimeter());
+            Assert.Equal(ElectricResistivity<double>.FromMicroohmsCentimeter(2), 2.MicroohmsCentimeter());
 
         [Fact]
         public void NumberToMicroohmMetersTest() =>
-            Assert.Equal(ElectricResistivity.FromMicroohmMeters(2), 2.MicroohmMeters());
+            Assert.Equal(ElectricResistivity<double>.FromMicroohmMeters(2), 2.MicroohmMeters());
 
         [Fact]
         public void NumberToMilliohmsCentimeterTest() =>
-            Assert.Equal(ElectricResistivity.FromMilliohmsCentimeter(2), 2.MilliohmsCentimeter());
+            Assert.Equal(ElectricResistivity<double>.FromMilliohmsCentimeter(2), 2.MilliohmsCentimeter());
 
         [Fact]
         public void NumberToMilliohmMetersTest() =>
-            Assert.Equal(ElectricResistivity.FromMilliohmMeters(2), 2.MilliohmMeters());
+            Assert.Equal(ElectricResistivity<double>.FromMilliohmMeters(2), 2.MilliohmMeters());
 
         [Fact]
         public void NumberToNanoohmsCentimeterTest() =>
-            Assert.Equal(ElectricResistivity.FromNanoohmsCentimeter(2), 2.NanoohmsCentimeter());
+            Assert.Equal(ElectricResistivity<double>.FromNanoohmsCentimeter(2), 2.NanoohmsCentimeter());
 
         [Fact]
         public void NumberToNanoohmMetersTest() =>
-            Assert.Equal(ElectricResistivity.FromNanoohmMeters(2), 2.NanoohmMeters());
+            Assert.Equal(ElectricResistivity<double>.FromNanoohmMeters(2), 2.NanoohmMeters());
 
         [Fact]
         public void NumberToOhmsCentimeterTest() =>
-            Assert.Equal(ElectricResistivity.FromOhmsCentimeter(2), 2.OhmsCentimeter());
+            Assert.Equal(ElectricResistivity<double>.FromOhmsCentimeter(2), 2.OhmsCentimeter());
 
         [Fact]
         public void NumberToOhmMetersTest() =>
-            Assert.Equal(ElectricResistivity.FromOhmMeters(2), 2.OhmMeters());
+            Assert.Equal(ElectricResistivity<double>.FromOhmMeters(2), 2.OhmMeters());
 
         [Fact]
         public void NumberToPicoohmsCentimeterTest() =>
-            Assert.Equal(ElectricResistivity.FromPicoohmsCentimeter(2), 2.PicoohmsCentimeter());
+            Assert.Equal(ElectricResistivity<double>.FromPicoohmsCentimeter(2), 2.PicoohmsCentimeter());
 
         [Fact]
         public void NumberToPicoohmMetersTest() =>
-            Assert.Equal(ElectricResistivity.FromPicoohmMeters(2), 2.PicoohmMeters());
+            Assert.Equal(ElectricResistivity<double>.FromPicoohmMeters(2), 2.PicoohmMeters());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs
index bc6ed172f7..21cbcbf6b2 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToElectricSurfaceChargeDensityExtensionsTests
     {
         [Fact]
         public void NumberToCoulombsPerSquareCentimeterTest() =>
-            Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(2), 2.CoulombsPerSquareCentimeter());
+            Assert.Equal(ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareCentimeter(2), 2.CoulombsPerSquareCentimeter());
 
         [Fact]
         public void NumberToCoulombsPerSquareInchTest() =>
-            Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(2), 2.CoulombsPerSquareInch());
+            Assert.Equal(ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareInch(2), 2.CoulombsPerSquareInch());
 
         [Fact]
         public void NumberToCoulombsPerSquareMeterTest() =>
-            Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(2), 2.CoulombsPerSquareMeter());
+            Assert.Equal(ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(2), 2.CoulombsPerSquareMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs
index bfad6ae155..35d295396d 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs
@@ -21,152 +21,152 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToEnergyExtensionsTests
     {
         [Fact]
         public void NumberToBritishThermalUnitsTest() =>
-            Assert.Equal(Energy.FromBritishThermalUnits(2), 2.BritishThermalUnits());
+            Assert.Equal(Energy<double>.FromBritishThermalUnits(2), 2.BritishThermalUnits());
 
         [Fact]
         public void NumberToCaloriesTest() =>
-            Assert.Equal(Energy.FromCalories(2), 2.Calories());
+            Assert.Equal(Energy<double>.FromCalories(2), 2.Calories());
 
         [Fact]
         public void NumberToDecathermsEcTest() =>
-            Assert.Equal(Energy.FromDecathermsEc(2), 2.DecathermsEc());
+            Assert.Equal(Energy<double>.FromDecathermsEc(2), 2.DecathermsEc());
 
         [Fact]
         public void NumberToDecathermsImperialTest() =>
-            Assert.Equal(Energy.FromDecathermsImperial(2), 2.DecathermsImperial());
+            Assert.Equal(Energy<double>.FromDecathermsImperial(2), 2.DecathermsImperial());
 
         [Fact]
         public void NumberToDecathermsUsTest() =>
-            Assert.Equal(Energy.FromDecathermsUs(2), 2.DecathermsUs());
+            Assert.Equal(Energy<double>.FromDecathermsUs(2), 2.DecathermsUs());
 
         [Fact]
         public void NumberToElectronVoltsTest() =>
-            Assert.Equal(Energy.FromElectronVolts(2), 2.ElectronVolts());
+            Assert.Equal(Energy<double>.FromElectronVolts(2), 2.ElectronVolts());
 
         [Fact]
         public void NumberToErgsTest() =>
-            Assert.Equal(Energy.FromErgs(2), 2.Ergs());
+            Assert.Equal(Energy<double>.FromErgs(2), 2.Ergs());
 
         [Fact]
         public void NumberToFootPoundsTest() =>
-            Assert.Equal(Energy.FromFootPounds(2), 2.FootPounds());
+            Assert.Equal(Energy<double>.FromFootPounds(2), 2.FootPounds());
 
         [Fact]
         public void NumberToGigabritishThermalUnitsTest() =>
-            Assert.Equal(Energy.FromGigabritishThermalUnits(2), 2.GigabritishThermalUnits());
+            Assert.Equal(Energy<double>.FromGigabritishThermalUnits(2), 2.GigabritishThermalUnits());
 
         [Fact]
         public void NumberToGigaelectronVoltsTest() =>
-            Assert.Equal(Energy.FromGigaelectronVolts(2), 2.GigaelectronVolts());
+            Assert.Equal(Energy<double>.FromGigaelectronVolts(2), 2.GigaelectronVolts());
 
         [Fact]
         public void NumberToGigajoulesTest() =>
-            Assert.Equal(Energy.FromGigajoules(2), 2.Gigajoules());
+            Assert.Equal(Energy<double>.FromGigajoules(2), 2.Gigajoules());
 
         [Fact]
         public void NumberToGigawattDaysTest() =>
-            Assert.Equal(Energy.FromGigawattDays(2), 2.GigawattDays());
+            Assert.Equal(Energy<double>.FromGigawattDays(2), 2.GigawattDays());
 
         [Fact]
         public void NumberToGigawattHoursTest() =>
-            Assert.Equal(Energy.FromGigawattHours(2), 2.GigawattHours());
+            Assert.Equal(Energy<double>.FromGigawattHours(2), 2.GigawattHours());
 
         [Fact]
         public void NumberToHorsepowerHoursTest() =>
-            Assert.Equal(Energy.FromHorsepowerHours(2), 2.HorsepowerHours());
+            Assert.Equal(Energy<double>.FromHorsepowerHours(2), 2.HorsepowerHours());
 
         [Fact]
         public void NumberToJoulesTest() =>
-            Assert.Equal(Energy.FromJoules(2), 2.Joules());
+            Assert.Equal(Energy<double>.FromJoules(2), 2.Joules());
 
         [Fact]
         public void NumberToKilobritishThermalUnitsTest() =>
-            Assert.Equal(Energy.FromKilobritishThermalUnits(2), 2.KilobritishThermalUnits());
+            Assert.Equal(Energy<double>.FromKilobritishThermalUnits(2), 2.KilobritishThermalUnits());
 
         [Fact]
         public void NumberToKilocaloriesTest() =>
-            Assert.Equal(Energy.FromKilocalories(2), 2.Kilocalories());
+            Assert.Equal(Energy<double>.FromKilocalories(2), 2.Kilocalories());
 
         [Fact]
         public void NumberToKiloelectronVoltsTest() =>
-            Assert.Equal(Energy.FromKiloelectronVolts(2), 2.KiloelectronVolts());
+            Assert.Equal(Energy<double>.FromKiloelectronVolts(2), 2.KiloelectronVolts());
 
         [Fact]
         public void NumberToKilojoulesTest() =>
-            Assert.Equal(Energy.FromKilojoules(2), 2.Kilojoules());
+            Assert.Equal(Energy<double>.FromKilojoules(2), 2.Kilojoules());
 
         [Fact]
         public void NumberToKilowattDaysTest() =>
-            Assert.Equal(Energy.FromKilowattDays(2), 2.KilowattDays());
+            Assert.Equal(Energy<double>.FromKilowattDays(2), 2.KilowattDays());
 
         [Fact]
         public void NumberToKilowattHoursTest() =>
-            Assert.Equal(Energy.FromKilowattHours(2), 2.KilowattHours());
+            Assert.Equal(Energy<double>.FromKilowattHours(2), 2.KilowattHours());
 
         [Fact]
         public void NumberToMegabritishThermalUnitsTest() =>
-            Assert.Equal(Energy.FromMegabritishThermalUnits(2), 2.MegabritishThermalUnits());
+            Assert.Equal(Energy<double>.FromMegabritishThermalUnits(2), 2.MegabritishThermalUnits());
 
         [Fact]
         public void NumberToMegacaloriesTest() =>
-            Assert.Equal(Energy.FromMegacalories(2), 2.Megacalories());
+            Assert.Equal(Energy<double>.FromMegacalories(2), 2.Megacalories());
 
         [Fact]
         public void NumberToMegaelectronVoltsTest() =>
-            Assert.Equal(Energy.FromMegaelectronVolts(2), 2.MegaelectronVolts());
+            Assert.Equal(Energy<double>.FromMegaelectronVolts(2), 2.MegaelectronVolts());
 
         [Fact]
         public void NumberToMegajoulesTest() =>
-            Assert.Equal(Energy.FromMegajoules(2), 2.Megajoules());
+            Assert.Equal(Energy<double>.FromMegajoules(2), 2.Megajoules());
 
         [Fact]
         public void NumberToMegawattDaysTest() =>
-            Assert.Equal(Energy.FromMegawattDays(2), 2.MegawattDays());
+            Assert.Equal(Energy<double>.FromMegawattDays(2), 2.MegawattDays());
 
         [Fact]
         public void NumberToMegawattHoursTest() =>
-            Assert.Equal(Energy.FromMegawattHours(2), 2.MegawattHours());
+            Assert.Equal(Energy<double>.FromMegawattHours(2), 2.MegawattHours());
 
         [Fact]
         public void NumberToMillijoulesTest() =>
-            Assert.Equal(Energy.FromMillijoules(2), 2.Millijoules());
+            Assert.Equal(Energy<double>.FromMillijoules(2), 2.Millijoules());
 
         [Fact]
         public void NumberToTeraelectronVoltsTest() =>
-            Assert.Equal(Energy.FromTeraelectronVolts(2), 2.TeraelectronVolts());
+            Assert.Equal(Energy<double>.FromTeraelectronVolts(2), 2.TeraelectronVolts());
 
         [Fact]
         public void NumberToTerawattDaysTest() =>
-            Assert.Equal(Energy.FromTerawattDays(2), 2.TerawattDays());
+            Assert.Equal(Energy<double>.FromTerawattDays(2), 2.TerawattDays());
 
         [Fact]
         public void NumberToTerawattHoursTest() =>
-            Assert.Equal(Energy.FromTerawattHours(2), 2.TerawattHours());
+            Assert.Equal(Energy<double>.FromTerawattHours(2), 2.TerawattHours());
 
         [Fact]
         public void NumberToThermsEcTest() =>
-            Assert.Equal(Energy.FromThermsEc(2), 2.ThermsEc());
+            Assert.Equal(Energy<double>.FromThermsEc(2), 2.ThermsEc());
 
         [Fact]
         public void NumberToThermsImperialTest() =>
-            Assert.Equal(Energy.FromThermsImperial(2), 2.ThermsImperial());
+            Assert.Equal(Energy<double>.FromThermsImperial(2), 2.ThermsImperial());
 
         [Fact]
         public void NumberToThermsUsTest() =>
-            Assert.Equal(Energy.FromThermsUs(2), 2.ThermsUs());
+            Assert.Equal(Energy<double>.FromThermsUs(2), 2.ThermsUs());
 
         [Fact]
         public void NumberToWattDaysTest() =>
-            Assert.Equal(Energy.FromWattDays(2), 2.WattDays());
+            Assert.Equal(Energy<double>.FromWattDays(2), 2.WattDays());
 
         [Fact]
         public void NumberToWattHoursTest() =>
-            Assert.Equal(Energy.FromWattHours(2), 2.WattHours());
+            Assert.Equal(Energy<double>.FromWattHours(2), 2.WattHours());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs
index c6cf992847..4cb431ebe8 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs
@@ -21,36 +21,36 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToEntropyExtensionsTests
     {
         [Fact]
         public void NumberToCaloriesPerKelvinTest() =>
-            Assert.Equal(Entropy.FromCaloriesPerKelvin(2), 2.CaloriesPerKelvin());
+            Assert.Equal(Entropy<double>.FromCaloriesPerKelvin(2), 2.CaloriesPerKelvin());
 
         [Fact]
         public void NumberToJoulesPerDegreeCelsiusTest() =>
-            Assert.Equal(Entropy.FromJoulesPerDegreeCelsius(2), 2.JoulesPerDegreeCelsius());
+            Assert.Equal(Entropy<double>.FromJoulesPerDegreeCelsius(2), 2.JoulesPerDegreeCelsius());
 
         [Fact]
         public void NumberToJoulesPerKelvinTest() =>
-            Assert.Equal(Entropy.FromJoulesPerKelvin(2), 2.JoulesPerKelvin());
+            Assert.Equal(Entropy<double>.FromJoulesPerKelvin(2), 2.JoulesPerKelvin());
 
         [Fact]
         public void NumberToKilocaloriesPerKelvinTest() =>
-            Assert.Equal(Entropy.FromKilocaloriesPerKelvin(2), 2.KilocaloriesPerKelvin());
+            Assert.Equal(Entropy<double>.FromKilocaloriesPerKelvin(2), 2.KilocaloriesPerKelvin());
 
         [Fact]
         public void NumberToKilojoulesPerDegreeCelsiusTest() =>
-            Assert.Equal(Entropy.FromKilojoulesPerDegreeCelsius(2), 2.KilojoulesPerDegreeCelsius());
+            Assert.Equal(Entropy<double>.FromKilojoulesPerDegreeCelsius(2), 2.KilojoulesPerDegreeCelsius());
 
         [Fact]
         public void NumberToKilojoulesPerKelvinTest() =>
-            Assert.Equal(Entropy.FromKilojoulesPerKelvin(2), 2.KilojoulesPerKelvin());
+            Assert.Equal(Entropy<double>.FromKilojoulesPerKelvin(2), 2.KilojoulesPerKelvin());
 
         [Fact]
         public void NumberToMegajoulesPerKelvinTest() =>
-            Assert.Equal(Entropy.FromMegajoulesPerKelvin(2), 2.MegajoulesPerKelvin());
+            Assert.Equal(Entropy<double>.FromMegajoulesPerKelvin(2), 2.MegajoulesPerKelvin());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs
index c94a756ed7..a657b767c6 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs
@@ -21,52 +21,52 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToForceChangeRateExtensionsTests
     {
         [Fact]
         public void NumberToCentinewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromCentinewtonsPerSecond(2), 2.CentinewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromCentinewtonsPerSecond(2), 2.CentinewtonsPerSecond());
 
         [Fact]
         public void NumberToDecanewtonsPerMinuteTest() =>
-            Assert.Equal(ForceChangeRate.FromDecanewtonsPerMinute(2), 2.DecanewtonsPerMinute());
+            Assert.Equal(ForceChangeRate<double>.FromDecanewtonsPerMinute(2), 2.DecanewtonsPerMinute());
 
         [Fact]
         public void NumberToDecanewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromDecanewtonsPerSecond(2), 2.DecanewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromDecanewtonsPerSecond(2), 2.DecanewtonsPerSecond());
 
         [Fact]
         public void NumberToDecinewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromDecinewtonsPerSecond(2), 2.DecinewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromDecinewtonsPerSecond(2), 2.DecinewtonsPerSecond());
 
         [Fact]
         public void NumberToKilonewtonsPerMinuteTest() =>
-            Assert.Equal(ForceChangeRate.FromKilonewtonsPerMinute(2), 2.KilonewtonsPerMinute());
+            Assert.Equal(ForceChangeRate<double>.FromKilonewtonsPerMinute(2), 2.KilonewtonsPerMinute());
 
         [Fact]
         public void NumberToKilonewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromKilonewtonsPerSecond(2), 2.KilonewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromKilonewtonsPerSecond(2), 2.KilonewtonsPerSecond());
 
         [Fact]
         public void NumberToMicronewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromMicronewtonsPerSecond(2), 2.MicronewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromMicronewtonsPerSecond(2), 2.MicronewtonsPerSecond());
 
         [Fact]
         public void NumberToMillinewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromMillinewtonsPerSecond(2), 2.MillinewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromMillinewtonsPerSecond(2), 2.MillinewtonsPerSecond());
 
         [Fact]
         public void NumberToNanonewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromNanonewtonsPerSecond(2), 2.NanonewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromNanonewtonsPerSecond(2), 2.NanonewtonsPerSecond());
 
         [Fact]
         public void NumberToNewtonsPerMinuteTest() =>
-            Assert.Equal(ForceChangeRate.FromNewtonsPerMinute(2), 2.NewtonsPerMinute());
+            Assert.Equal(ForceChangeRate<double>.FromNewtonsPerMinute(2), 2.NewtonsPerMinute());
 
         [Fact]
         public void NumberToNewtonsPerSecondTest() =>
-            Assert.Equal(ForceChangeRate.FromNewtonsPerSecond(2), 2.NewtonsPerSecond());
+            Assert.Equal(ForceChangeRate<double>.FromNewtonsPerSecond(2), 2.NewtonsPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
index 1345478ea8..c102db43bf 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
@@ -21,68 +21,68 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToForceExtensionsTests
     {
         [Fact]
         public void NumberToDecanewtonsTest() =>
-            Assert.Equal(Force.FromDecanewtons(2), 2.Decanewtons());
+            Assert.Equal(Force<double>.FromDecanewtons(2), 2.Decanewtons());
 
         [Fact]
         public void NumberToDyneTest() =>
-            Assert.Equal(Force.FromDyne(2), 2.Dyne());
+            Assert.Equal(Force<double>.FromDyne(2), 2.Dyne());
 
         [Fact]
         public void NumberToKilogramsForceTest() =>
-            Assert.Equal(Force.FromKilogramsForce(2), 2.KilogramsForce());
+            Assert.Equal(Force<double>.FromKilogramsForce(2), 2.KilogramsForce());
 
         [Fact]
         public void NumberToKilonewtonsTest() =>
-            Assert.Equal(Force.FromKilonewtons(2), 2.Kilonewtons());
+            Assert.Equal(Force<double>.FromKilonewtons(2), 2.Kilonewtons());
 
         [Fact]
         public void NumberToKiloPondsTest() =>
-            Assert.Equal(Force.FromKiloPonds(2), 2.KiloPonds());
+            Assert.Equal(Force<double>.FromKiloPonds(2), 2.KiloPonds());
 
         [Fact]
         public void NumberToKilopoundsForceTest() =>
-            Assert.Equal(Force.FromKilopoundsForce(2), 2.KilopoundsForce());
+            Assert.Equal(Force<double>.FromKilopoundsForce(2), 2.KilopoundsForce());
 
         [Fact]
         public void NumberToMeganewtonsTest() =>
-            Assert.Equal(Force.FromMeganewtons(2), 2.Meganewtons());
+            Assert.Equal(Force<double>.FromMeganewtons(2), 2.Meganewtons());
 
         [Fact]
         public void NumberToMicronewtonsTest() =>
-            Assert.Equal(Force.FromMicronewtons(2), 2.Micronewtons());
+            Assert.Equal(Force<double>.FromMicronewtons(2), 2.Micronewtons());
 
         [Fact]
         public void NumberToMillinewtonsTest() =>
-            Assert.Equal(Force.FromMillinewtons(2), 2.Millinewtons());
+            Assert.Equal(Force<double>.FromMillinewtons(2), 2.Millinewtons());
 
         [Fact]
         public void NumberToNewtonsTest() =>
-            Assert.Equal(Force.FromNewtons(2), 2.Newtons());
+            Assert.Equal(Force<double>.FromNewtons(2), 2.Newtons());
 
         [Fact]
         public void NumberToOunceForceTest() =>
-            Assert.Equal(Force.FromOunceForce(2), 2.OunceForce());
+            Assert.Equal(Force<double>.FromOunceForce(2), 2.OunceForce());
 
         [Fact]
         public void NumberToPoundalsTest() =>
-            Assert.Equal(Force.FromPoundals(2), 2.Poundals());
+            Assert.Equal(Force<double>.FromPoundals(2), 2.Poundals());
 
         [Fact]
         public void NumberToPoundsForceTest() =>
-            Assert.Equal(Force.FromPoundsForce(2), 2.PoundsForce());
+            Assert.Equal(Force<double>.FromPoundsForce(2), 2.PoundsForce());
 
         [Fact]
         public void NumberToShortTonsForceTest() =>
-            Assert.Equal(Force.FromShortTonsForce(2), 2.ShortTonsForce());
+            Assert.Equal(Force<double>.FromShortTonsForce(2), 2.ShortTonsForce());
 
         [Fact]
         public void NumberToTonnesForceTest() =>
-            Assert.Equal(Force.FromTonnesForce(2), 2.TonnesForce());
+            Assert.Equal(Force<double>.FromTonnesForce(2), 2.TonnesForce());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs
index f8d99915a6..9ccad9ca5f 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs
@@ -21,160 +21,160 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToForcePerLengthExtensionsTests
     {
         [Fact]
         public void NumberToCentinewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromCentinewtonsPerCentimeter(2), 2.CentinewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromCentinewtonsPerCentimeter(2), 2.CentinewtonsPerCentimeter());
 
         [Fact]
         public void NumberToCentinewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromCentinewtonsPerMeter(2), 2.CentinewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromCentinewtonsPerMeter(2), 2.CentinewtonsPerMeter());
 
         [Fact]
         public void NumberToCentinewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromCentinewtonsPerMillimeter(2), 2.CentinewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromCentinewtonsPerMillimeter(2), 2.CentinewtonsPerMillimeter());
 
         [Fact]
         public void NumberToDecanewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromDecanewtonsPerCentimeter(2), 2.DecanewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromDecanewtonsPerCentimeter(2), 2.DecanewtonsPerCentimeter());
 
         [Fact]
         public void NumberToDecanewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromDecanewtonsPerMeter(2), 2.DecanewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromDecanewtonsPerMeter(2), 2.DecanewtonsPerMeter());
 
         [Fact]
         public void NumberToDecanewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromDecanewtonsPerMillimeter(2), 2.DecanewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromDecanewtonsPerMillimeter(2), 2.DecanewtonsPerMillimeter());
 
         [Fact]
         public void NumberToDecinewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromDecinewtonsPerCentimeter(2), 2.DecinewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromDecinewtonsPerCentimeter(2), 2.DecinewtonsPerCentimeter());
 
         [Fact]
         public void NumberToDecinewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromDecinewtonsPerMeter(2), 2.DecinewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromDecinewtonsPerMeter(2), 2.DecinewtonsPerMeter());
 
         [Fact]
         public void NumberToDecinewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromDecinewtonsPerMillimeter(2), 2.DecinewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromDecinewtonsPerMillimeter(2), 2.DecinewtonsPerMillimeter());
 
         [Fact]
         public void NumberToKilogramsForcePerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromKilogramsForcePerCentimeter(2), 2.KilogramsForcePerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromKilogramsForcePerCentimeter(2), 2.KilogramsForcePerCentimeter());
 
         [Fact]
         public void NumberToKilogramsForcePerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromKilogramsForcePerMeter(2), 2.KilogramsForcePerMeter());
+            Assert.Equal(ForcePerLength<double>.FromKilogramsForcePerMeter(2), 2.KilogramsForcePerMeter());
 
         [Fact]
         public void NumberToKilogramsForcePerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromKilogramsForcePerMillimeter(2), 2.KilogramsForcePerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromKilogramsForcePerMillimeter(2), 2.KilogramsForcePerMillimeter());
 
         [Fact]
         public void NumberToKilonewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromKilonewtonsPerCentimeter(2), 2.KilonewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromKilonewtonsPerCentimeter(2), 2.KilonewtonsPerCentimeter());
 
         [Fact]
         public void NumberToKilonewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromKilonewtonsPerMeter(2), 2.KilonewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromKilonewtonsPerMeter(2), 2.KilonewtonsPerMeter());
 
         [Fact]
         public void NumberToKilonewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromKilonewtonsPerMillimeter(2), 2.KilonewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromKilonewtonsPerMillimeter(2), 2.KilonewtonsPerMillimeter());
 
         [Fact]
         public void NumberToKilopoundsForcePerFootTest() =>
-            Assert.Equal(ForcePerLength.FromKilopoundsForcePerFoot(2), 2.KilopoundsForcePerFoot());
+            Assert.Equal(ForcePerLength<double>.FromKilopoundsForcePerFoot(2), 2.KilopoundsForcePerFoot());
 
         [Fact]
         public void NumberToKilopoundsForcePerInchTest() =>
-            Assert.Equal(ForcePerLength.FromKilopoundsForcePerInch(2), 2.KilopoundsForcePerInch());
+            Assert.Equal(ForcePerLength<double>.FromKilopoundsForcePerInch(2), 2.KilopoundsForcePerInch());
 
         [Fact]
         public void NumberToMeganewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromMeganewtonsPerCentimeter(2), 2.MeganewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromMeganewtonsPerCentimeter(2), 2.MeganewtonsPerCentimeter());
 
         [Fact]
         public void NumberToMeganewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromMeganewtonsPerMeter(2), 2.MeganewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromMeganewtonsPerMeter(2), 2.MeganewtonsPerMeter());
 
         [Fact]
         public void NumberToMeganewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromMeganewtonsPerMillimeter(2), 2.MeganewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromMeganewtonsPerMillimeter(2), 2.MeganewtonsPerMillimeter());
 
         [Fact]
         public void NumberToMicronewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromMicronewtonsPerCentimeter(2), 2.MicronewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromMicronewtonsPerCentimeter(2), 2.MicronewtonsPerCentimeter());
 
         [Fact]
         public void NumberToMicronewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromMicronewtonsPerMeter(2), 2.MicronewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromMicronewtonsPerMeter(2), 2.MicronewtonsPerMeter());
 
         [Fact]
         public void NumberToMicronewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromMicronewtonsPerMillimeter(2), 2.MicronewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromMicronewtonsPerMillimeter(2), 2.MicronewtonsPerMillimeter());
 
         [Fact]
         public void NumberToMillinewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromMillinewtonsPerCentimeter(2), 2.MillinewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromMillinewtonsPerCentimeter(2), 2.MillinewtonsPerCentimeter());
 
         [Fact]
         public void NumberToMillinewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromMillinewtonsPerMeter(2), 2.MillinewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromMillinewtonsPerMeter(2), 2.MillinewtonsPerMeter());
 
         [Fact]
         public void NumberToMillinewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromMillinewtonsPerMillimeter(2), 2.MillinewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromMillinewtonsPerMillimeter(2), 2.MillinewtonsPerMillimeter());
 
         [Fact]
         public void NumberToNanonewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromNanonewtonsPerCentimeter(2), 2.NanonewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromNanonewtonsPerCentimeter(2), 2.NanonewtonsPerCentimeter());
 
         [Fact]
         public void NumberToNanonewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromNanonewtonsPerMeter(2), 2.NanonewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromNanonewtonsPerMeter(2), 2.NanonewtonsPerMeter());
 
         [Fact]
         public void NumberToNanonewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromNanonewtonsPerMillimeter(2), 2.NanonewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromNanonewtonsPerMillimeter(2), 2.NanonewtonsPerMillimeter());
 
         [Fact]
         public void NumberToNewtonsPerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromNewtonsPerCentimeter(2), 2.NewtonsPerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromNewtonsPerCentimeter(2), 2.NewtonsPerCentimeter());
 
         [Fact]
         public void NumberToNewtonsPerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromNewtonsPerMeter(2), 2.NewtonsPerMeter());
+            Assert.Equal(ForcePerLength<double>.FromNewtonsPerMeter(2), 2.NewtonsPerMeter());
 
         [Fact]
         public void NumberToNewtonsPerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromNewtonsPerMillimeter(2), 2.NewtonsPerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromNewtonsPerMillimeter(2), 2.NewtonsPerMillimeter());
 
         [Fact]
         public void NumberToPoundsForcePerFootTest() =>
-            Assert.Equal(ForcePerLength.FromPoundsForcePerFoot(2), 2.PoundsForcePerFoot());
+            Assert.Equal(ForcePerLength<double>.FromPoundsForcePerFoot(2), 2.PoundsForcePerFoot());
 
         [Fact]
         public void NumberToPoundsForcePerInchTest() =>
-            Assert.Equal(ForcePerLength.FromPoundsForcePerInch(2), 2.PoundsForcePerInch());
+            Assert.Equal(ForcePerLength<double>.FromPoundsForcePerInch(2), 2.PoundsForcePerInch());
 
         [Fact]
         public void NumberToPoundsForcePerYardTest() =>
-            Assert.Equal(ForcePerLength.FromPoundsForcePerYard(2), 2.PoundsForcePerYard());
+            Assert.Equal(ForcePerLength<double>.FromPoundsForcePerYard(2), 2.PoundsForcePerYard());
 
         [Fact]
         public void NumberToTonnesForcePerCentimeterTest() =>
-            Assert.Equal(ForcePerLength.FromTonnesForcePerCentimeter(2), 2.TonnesForcePerCentimeter());
+            Assert.Equal(ForcePerLength<double>.FromTonnesForcePerCentimeter(2), 2.TonnesForcePerCentimeter());
 
         [Fact]
         public void NumberToTonnesForcePerMeterTest() =>
-            Assert.Equal(ForcePerLength.FromTonnesForcePerMeter(2), 2.TonnesForcePerMeter());
+            Assert.Equal(ForcePerLength<double>.FromTonnesForcePerMeter(2), 2.TonnesForcePerMeter());
 
         [Fact]
         public void NumberToTonnesForcePerMillimeterTest() =>
-            Assert.Equal(ForcePerLength.FromTonnesForcePerMillimeter(2), 2.TonnesForcePerMillimeter());
+            Assert.Equal(ForcePerLength<double>.FromTonnesForcePerMillimeter(2), 2.TonnesForcePerMillimeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs
index 77824e7c6a..8e20b4f9d2 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs
@@ -21,48 +21,48 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToFrequencyExtensionsTests
     {
         [Fact]
         public void NumberToBeatsPerMinuteTest() =>
-            Assert.Equal(Frequency.FromBeatsPerMinute(2), 2.BeatsPerMinute());
+            Assert.Equal(Frequency<double>.FromBeatsPerMinute(2), 2.BeatsPerMinute());
 
         [Fact]
         public void NumberToCyclesPerHourTest() =>
-            Assert.Equal(Frequency.FromCyclesPerHour(2), 2.CyclesPerHour());
+            Assert.Equal(Frequency<double>.FromCyclesPerHour(2), 2.CyclesPerHour());
 
         [Fact]
         public void NumberToCyclesPerMinuteTest() =>
-            Assert.Equal(Frequency.FromCyclesPerMinute(2), 2.CyclesPerMinute());
+            Assert.Equal(Frequency<double>.FromCyclesPerMinute(2), 2.CyclesPerMinute());
 
         [Fact]
         public void NumberToGigahertzTest() =>
-            Assert.Equal(Frequency.FromGigahertz(2), 2.Gigahertz());
+            Assert.Equal(Frequency<double>.FromGigahertz(2), 2.Gigahertz());
 
         [Fact]
         public void NumberToHertzTest() =>
-            Assert.Equal(Frequency.FromHertz(2), 2.Hertz());
+            Assert.Equal(Frequency<double>.FromHertz(2), 2.Hertz());
 
         [Fact]
         public void NumberToKilohertzTest() =>
-            Assert.Equal(Frequency.FromKilohertz(2), 2.Kilohertz());
+            Assert.Equal(Frequency<double>.FromKilohertz(2), 2.Kilohertz());
 
         [Fact]
         public void NumberToMegahertzTest() =>
-            Assert.Equal(Frequency.FromMegahertz(2), 2.Megahertz());
+            Assert.Equal(Frequency<double>.FromMegahertz(2), 2.Megahertz());
 
         [Fact]
         public void NumberToPerSecondTest() =>
-            Assert.Equal(Frequency.FromPerSecond(2), 2.PerSecond());
+            Assert.Equal(Frequency<double>.FromPerSecond(2), 2.PerSecond());
 
         [Fact]
         public void NumberToRadiansPerSecondTest() =>
-            Assert.Equal(Frequency.FromRadiansPerSecond(2), 2.RadiansPerSecond());
+            Assert.Equal(Frequency<double>.FromRadiansPerSecond(2), 2.RadiansPerSecond());
 
         [Fact]
         public void NumberToTerahertzTest() =>
-            Assert.Equal(Frequency.FromTerahertz(2), 2.Terahertz());
+            Assert.Equal(Frequency<double>.FromTerahertz(2), 2.Terahertz());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs
index a4a8ef5c87..1de68f5b66 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToFuelEfficiencyExtensionsTests
     {
         [Fact]
         public void NumberToKilometersPerLitersTest() =>
-            Assert.Equal(FuelEfficiency.FromKilometersPerLiters(2), 2.KilometersPerLiters());
+            Assert.Equal(FuelEfficiency<double>.FromKilometersPerLiters(2), 2.KilometersPerLiters());
 
         [Fact]
         public void NumberToLitersPer100KilometersTest() =>
-            Assert.Equal(FuelEfficiency.FromLitersPer100Kilometers(2), 2.LitersPer100Kilometers());
+            Assert.Equal(FuelEfficiency<double>.FromLitersPer100Kilometers(2), 2.LitersPer100Kilometers());
 
         [Fact]
         public void NumberToMilesPerUkGallonTest() =>
-            Assert.Equal(FuelEfficiency.FromMilesPerUkGallon(2), 2.MilesPerUkGallon());
+            Assert.Equal(FuelEfficiency<double>.FromMilesPerUkGallon(2), 2.MilesPerUkGallon());
 
         [Fact]
         public void NumberToMilesPerUsGallonTest() =>
-            Assert.Equal(FuelEfficiency.FromMilesPerUsGallon(2), 2.MilesPerUsGallon());
+            Assert.Equal(FuelEfficiency<double>.FromMilesPerUsGallon(2), 2.MilesPerUsGallon());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
index 1c6e35a100..2df8a1c78a 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
@@ -21,80 +21,80 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToHeatFluxExtensionsTests
     {
         [Fact]
         public void NumberToBtusPerHourSquareFootTest() =>
-            Assert.Equal(HeatFlux.FromBtusPerHourSquareFoot(2), 2.BtusPerHourSquareFoot());
+            Assert.Equal(HeatFlux<double>.FromBtusPerHourSquareFoot(2), 2.BtusPerHourSquareFoot());
 
         [Fact]
         public void NumberToBtusPerMinuteSquareFootTest() =>
-            Assert.Equal(HeatFlux.FromBtusPerMinuteSquareFoot(2), 2.BtusPerMinuteSquareFoot());
+            Assert.Equal(HeatFlux<double>.FromBtusPerMinuteSquareFoot(2), 2.BtusPerMinuteSquareFoot());
 
         [Fact]
         public void NumberToBtusPerSecondSquareFootTest() =>
-            Assert.Equal(HeatFlux.FromBtusPerSecondSquareFoot(2), 2.BtusPerSecondSquareFoot());
+            Assert.Equal(HeatFlux<double>.FromBtusPerSecondSquareFoot(2), 2.BtusPerSecondSquareFoot());
 
         [Fact]
         public void NumberToBtusPerSecondSquareInchTest() =>
-            Assert.Equal(HeatFlux.FromBtusPerSecondSquareInch(2), 2.BtusPerSecondSquareInch());
+            Assert.Equal(HeatFlux<double>.FromBtusPerSecondSquareInch(2), 2.BtusPerSecondSquareInch());
 
         [Fact]
         public void NumberToCaloriesPerSecondSquareCentimeterTest() =>
-            Assert.Equal(HeatFlux.FromCaloriesPerSecondSquareCentimeter(2), 2.CaloriesPerSecondSquareCentimeter());
+            Assert.Equal(HeatFlux<double>.FromCaloriesPerSecondSquareCentimeter(2), 2.CaloriesPerSecondSquareCentimeter());
 
         [Fact]
         public void NumberToCentiwattsPerSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromCentiwattsPerSquareMeter(2), 2.CentiwattsPerSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromCentiwattsPerSquareMeter(2), 2.CentiwattsPerSquareMeter());
 
         [Fact]
         public void NumberToDeciwattsPerSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromDeciwattsPerSquareMeter(2), 2.DeciwattsPerSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromDeciwattsPerSquareMeter(2), 2.DeciwattsPerSquareMeter());
 
         [Fact]
         public void NumberToKilocaloriesPerHourSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromKilocaloriesPerHourSquareMeter(2), 2.KilocaloriesPerHourSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromKilocaloriesPerHourSquareMeter(2), 2.KilocaloriesPerHourSquareMeter());
 
         [Fact]
         public void NumberToKilocaloriesPerSecondSquareCentimeterTest() =>
-            Assert.Equal(HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(2), 2.KilocaloriesPerSecondSquareCentimeter());
+            Assert.Equal(HeatFlux<double>.FromKilocaloriesPerSecondSquareCentimeter(2), 2.KilocaloriesPerSecondSquareCentimeter());
 
         [Fact]
         public void NumberToKilowattsPerSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter());
 
         [Fact]
         public void NumberToMicrowattsPerSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter());
 
         [Fact]
         public void NumberToMilliwattsPerSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter());
 
         [Fact]
         public void NumberToNanowattsPerSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter());
 
         [Fact]
         public void NumberToPoundsForcePerFootSecondTest() =>
-            Assert.Equal(HeatFlux.FromPoundsForcePerFootSecond(2), 2.PoundsForcePerFootSecond());
+            Assert.Equal(HeatFlux<double>.FromPoundsForcePerFootSecond(2), 2.PoundsForcePerFootSecond());
 
         [Fact]
         public void NumberToPoundsPerSecondCubedTest() =>
-            Assert.Equal(HeatFlux.FromPoundsPerSecondCubed(2), 2.PoundsPerSecondCubed());
+            Assert.Equal(HeatFlux<double>.FromPoundsPerSecondCubed(2), 2.PoundsPerSecondCubed());
 
         [Fact]
         public void NumberToWattsPerSquareFootTest() =>
-            Assert.Equal(HeatFlux.FromWattsPerSquareFoot(2), 2.WattsPerSquareFoot());
+            Assert.Equal(HeatFlux<double>.FromWattsPerSquareFoot(2), 2.WattsPerSquareFoot());
 
         [Fact]
         public void NumberToWattsPerSquareInchTest() =>
-            Assert.Equal(HeatFlux.FromWattsPerSquareInch(2), 2.WattsPerSquareInch());
+            Assert.Equal(HeatFlux<double>.FromWattsPerSquareInch(2), 2.WattsPerSquareInch());
 
         [Fact]
         public void NumberToWattsPerSquareMeterTest() =>
-            Assert.Equal(HeatFlux.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter());
+            Assert.Equal(HeatFlux<double>.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
index 511070611b..86cc63440e 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToHeatTransferCoefficientExtensionsTests
     {
         [Fact]
         public void NumberToBtusPerSquareFootDegreeFahrenheitTest() =>
-            Assert.Equal(HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(2), 2.BtusPerSquareFootDegreeFahrenheit());
+            Assert.Equal(HeatTransferCoefficient<double>.FromBtusPerSquareFootDegreeFahrenheit(2), 2.BtusPerSquareFootDegreeFahrenheit());
 
         [Fact]
         public void NumberToWattsPerSquareMeterCelsiusTest() =>
-            Assert.Equal(HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(2), 2.WattsPerSquareMeterCelsius());
+            Assert.Equal(HeatTransferCoefficient<double>.FromWattsPerSquareMeterCelsius(2), 2.WattsPerSquareMeterCelsius());
 
         [Fact]
         public void NumberToWattsPerSquareMeterKelvinTest() =>
-            Assert.Equal(HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(2), 2.WattsPerSquareMeterKelvin());
+            Assert.Equal(HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(2), 2.WattsPerSquareMeterKelvin());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs
index f39ff3cdbd..525204a5c3 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToIlluminanceExtensionsTests
     {
         [Fact]
         public void NumberToKiloluxTest() =>
-            Assert.Equal(Illuminance.FromKilolux(2), 2.Kilolux());
+            Assert.Equal(Illuminance<double>.FromKilolux(2), 2.Kilolux());
 
         [Fact]
         public void NumberToLuxTest() =>
-            Assert.Equal(Illuminance.FromLux(2), 2.Lux());
+            Assert.Equal(Illuminance<double>.FromLux(2), 2.Lux());
 
         [Fact]
         public void NumberToMegaluxTest() =>
-            Assert.Equal(Illuminance.FromMegalux(2), 2.Megalux());
+            Assert.Equal(Illuminance<double>.FromMegalux(2), 2.Megalux());
 
         [Fact]
         public void NumberToMilliluxTest() =>
-            Assert.Equal(Illuminance.FromMillilux(2), 2.Millilux());
+            Assert.Equal(Illuminance<double>.FromMillilux(2), 2.Millilux());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs
index 3f566f4025..0e7247cc02 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs
@@ -21,112 +21,112 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToInformationExtensionsTests
     {
         [Fact]
         public void NumberToBitsTest() =>
-            Assert.Equal(Information.FromBits(2), 2.Bits());
+            Assert.Equal(Information<double>.FromBits(2), 2.Bits());
 
         [Fact]
         public void NumberToBytesTest() =>
-            Assert.Equal(Information.FromBytes(2), 2.Bytes());
+            Assert.Equal(Information<double>.FromBytes(2), 2.Bytes());
 
         [Fact]
         public void NumberToExabitsTest() =>
-            Assert.Equal(Information.FromExabits(2), 2.Exabits());
+            Assert.Equal(Information<double>.FromExabits(2), 2.Exabits());
 
         [Fact]
         public void NumberToExabytesTest() =>
-            Assert.Equal(Information.FromExabytes(2), 2.Exabytes());
+            Assert.Equal(Information<double>.FromExabytes(2), 2.Exabytes());
 
         [Fact]
         public void NumberToExbibitsTest() =>
-            Assert.Equal(Information.FromExbibits(2), 2.Exbibits());
+            Assert.Equal(Information<double>.FromExbibits(2), 2.Exbibits());
 
         [Fact]
         public void NumberToExbibytesTest() =>
-            Assert.Equal(Information.FromExbibytes(2), 2.Exbibytes());
+            Assert.Equal(Information<double>.FromExbibytes(2), 2.Exbibytes());
 
         [Fact]
         public void NumberToGibibitsTest() =>
-            Assert.Equal(Information.FromGibibits(2), 2.Gibibits());
+            Assert.Equal(Information<double>.FromGibibits(2), 2.Gibibits());
 
         [Fact]
         public void NumberToGibibytesTest() =>
-            Assert.Equal(Information.FromGibibytes(2), 2.Gibibytes());
+            Assert.Equal(Information<double>.FromGibibytes(2), 2.Gibibytes());
 
         [Fact]
         public void NumberToGigabitsTest() =>
-            Assert.Equal(Information.FromGigabits(2), 2.Gigabits());
+            Assert.Equal(Information<double>.FromGigabits(2), 2.Gigabits());
 
         [Fact]
         public void NumberToGigabytesTest() =>
-            Assert.Equal(Information.FromGigabytes(2), 2.Gigabytes());
+            Assert.Equal(Information<double>.FromGigabytes(2), 2.Gigabytes());
 
         [Fact]
         public void NumberToKibibitsTest() =>
-            Assert.Equal(Information.FromKibibits(2), 2.Kibibits());
+            Assert.Equal(Information<double>.FromKibibits(2), 2.Kibibits());
 
         [Fact]
         public void NumberToKibibytesTest() =>
-            Assert.Equal(Information.FromKibibytes(2), 2.Kibibytes());
+            Assert.Equal(Information<double>.FromKibibytes(2), 2.Kibibytes());
 
         [Fact]
         public void NumberToKilobitsTest() =>
-            Assert.Equal(Information.FromKilobits(2), 2.Kilobits());
+            Assert.Equal(Information<double>.FromKilobits(2), 2.Kilobits());
 
         [Fact]
         public void NumberToKilobytesTest() =>
-            Assert.Equal(Information.FromKilobytes(2), 2.Kilobytes());
+            Assert.Equal(Information<double>.FromKilobytes(2), 2.Kilobytes());
 
         [Fact]
         public void NumberToMebibitsTest() =>
-            Assert.Equal(Information.FromMebibits(2), 2.Mebibits());
+            Assert.Equal(Information<double>.FromMebibits(2), 2.Mebibits());
 
         [Fact]
         public void NumberToMebibytesTest() =>
-            Assert.Equal(Information.FromMebibytes(2), 2.Mebibytes());
+            Assert.Equal(Information<double>.FromMebibytes(2), 2.Mebibytes());
 
         [Fact]
         public void NumberToMegabitsTest() =>
-            Assert.Equal(Information.FromMegabits(2), 2.Megabits());
+            Assert.Equal(Information<double>.FromMegabits(2), 2.Megabits());
 
         [Fact]
         public void NumberToMegabytesTest() =>
-            Assert.Equal(Information.FromMegabytes(2), 2.Megabytes());
+            Assert.Equal(Information<double>.FromMegabytes(2), 2.Megabytes());
 
         [Fact]
         public void NumberToPebibitsTest() =>
-            Assert.Equal(Information.FromPebibits(2), 2.Pebibits());
+            Assert.Equal(Information<double>.FromPebibits(2), 2.Pebibits());
 
         [Fact]
         public void NumberToPebibytesTest() =>
-            Assert.Equal(Information.FromPebibytes(2), 2.Pebibytes());
+            Assert.Equal(Information<double>.FromPebibytes(2), 2.Pebibytes());
 
         [Fact]
         public void NumberToPetabitsTest() =>
-            Assert.Equal(Information.FromPetabits(2), 2.Petabits());
+            Assert.Equal(Information<double>.FromPetabits(2), 2.Petabits());
 
         [Fact]
         public void NumberToPetabytesTest() =>
-            Assert.Equal(Information.FromPetabytes(2), 2.Petabytes());
+            Assert.Equal(Information<double>.FromPetabytes(2), 2.Petabytes());
 
         [Fact]
         public void NumberToTebibitsTest() =>
-            Assert.Equal(Information.FromTebibits(2), 2.Tebibits());
+            Assert.Equal(Information<double>.FromTebibits(2), 2.Tebibits());
 
         [Fact]
         public void NumberToTebibytesTest() =>
-            Assert.Equal(Information.FromTebibytes(2), 2.Tebibytes());
+            Assert.Equal(Information<double>.FromTebibytes(2), 2.Tebibytes());
 
         [Fact]
         public void NumberToTerabitsTest() =>
-            Assert.Equal(Information.FromTerabits(2), 2.Terabits());
+            Assert.Equal(Information<double>.FromTerabits(2), 2.Terabits());
 
         [Fact]
         public void NumberToTerabytesTest() =>
-            Assert.Equal(Information.FromTerabytes(2), 2.Terabytes());
+            Assert.Equal(Information<double>.FromTerabytes(2), 2.Terabytes());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs
index 93a9cb1cbc..5a174f3365 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs
@@ -21,64 +21,64 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToIrradianceExtensionsTests
     {
         [Fact]
         public void NumberToKilowattsPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiance.FromKilowattsPerSquareCentimeter(2), 2.KilowattsPerSquareCentimeter());
+            Assert.Equal(Irradiance<double>.FromKilowattsPerSquareCentimeter(2), 2.KilowattsPerSquareCentimeter());
 
         [Fact]
         public void NumberToKilowattsPerSquareMeterTest() =>
-            Assert.Equal(Irradiance.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter());
+            Assert.Equal(Irradiance<double>.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter());
 
         [Fact]
         public void NumberToMegawattsPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiance.FromMegawattsPerSquareCentimeter(2), 2.MegawattsPerSquareCentimeter());
+            Assert.Equal(Irradiance<double>.FromMegawattsPerSquareCentimeter(2), 2.MegawattsPerSquareCentimeter());
 
         [Fact]
         public void NumberToMegawattsPerSquareMeterTest() =>
-            Assert.Equal(Irradiance.FromMegawattsPerSquareMeter(2), 2.MegawattsPerSquareMeter());
+            Assert.Equal(Irradiance<double>.FromMegawattsPerSquareMeter(2), 2.MegawattsPerSquareMeter());
 
         [Fact]
         public void NumberToMicrowattsPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiance.FromMicrowattsPerSquareCentimeter(2), 2.MicrowattsPerSquareCentimeter());
+            Assert.Equal(Irradiance<double>.FromMicrowattsPerSquareCentimeter(2), 2.MicrowattsPerSquareCentimeter());
 
         [Fact]
         public void NumberToMicrowattsPerSquareMeterTest() =>
-            Assert.Equal(Irradiance.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter());
+            Assert.Equal(Irradiance<double>.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter());
 
         [Fact]
         public void NumberToMilliwattsPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiance.FromMilliwattsPerSquareCentimeter(2), 2.MilliwattsPerSquareCentimeter());
+            Assert.Equal(Irradiance<double>.FromMilliwattsPerSquareCentimeter(2), 2.MilliwattsPerSquareCentimeter());
 
         [Fact]
         public void NumberToMilliwattsPerSquareMeterTest() =>
-            Assert.Equal(Irradiance.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter());
+            Assert.Equal(Irradiance<double>.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter());
 
         [Fact]
         public void NumberToNanowattsPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiance.FromNanowattsPerSquareCentimeter(2), 2.NanowattsPerSquareCentimeter());
+            Assert.Equal(Irradiance<double>.FromNanowattsPerSquareCentimeter(2), 2.NanowattsPerSquareCentimeter());
 
         [Fact]
         public void NumberToNanowattsPerSquareMeterTest() =>
-            Assert.Equal(Irradiance.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter());
+            Assert.Equal(Irradiance<double>.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter());
 
         [Fact]
         public void NumberToPicowattsPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiance.FromPicowattsPerSquareCentimeter(2), 2.PicowattsPerSquareCentimeter());
+            Assert.Equal(Irradiance<double>.FromPicowattsPerSquareCentimeter(2), 2.PicowattsPerSquareCentimeter());
 
         [Fact]
         public void NumberToPicowattsPerSquareMeterTest() =>
-            Assert.Equal(Irradiance.FromPicowattsPerSquareMeter(2), 2.PicowattsPerSquareMeter());
+            Assert.Equal(Irradiance<double>.FromPicowattsPerSquareMeter(2), 2.PicowattsPerSquareMeter());
 
         [Fact]
         public void NumberToWattsPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiance.FromWattsPerSquareCentimeter(2), 2.WattsPerSquareCentimeter());
+            Assert.Equal(Irradiance<double>.FromWattsPerSquareCentimeter(2), 2.WattsPerSquareCentimeter());
 
         [Fact]
         public void NumberToWattsPerSquareMeterTest() =>
-            Assert.Equal(Irradiance.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter());
+            Assert.Equal(Irradiance<double>.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs
index f14afa4cb6..c9d35ace1b 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs
@@ -21,36 +21,36 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToIrradiationExtensionsTests
     {
         [Fact]
         public void NumberToJoulesPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiation.FromJoulesPerSquareCentimeter(2), 2.JoulesPerSquareCentimeter());
+            Assert.Equal(Irradiation<double>.FromJoulesPerSquareCentimeter(2), 2.JoulesPerSquareCentimeter());
 
         [Fact]
         public void NumberToJoulesPerSquareMeterTest() =>
-            Assert.Equal(Irradiation.FromJoulesPerSquareMeter(2), 2.JoulesPerSquareMeter());
+            Assert.Equal(Irradiation<double>.FromJoulesPerSquareMeter(2), 2.JoulesPerSquareMeter());
 
         [Fact]
         public void NumberToJoulesPerSquareMillimeterTest() =>
-            Assert.Equal(Irradiation.FromJoulesPerSquareMillimeter(2), 2.JoulesPerSquareMillimeter());
+            Assert.Equal(Irradiation<double>.FromJoulesPerSquareMillimeter(2), 2.JoulesPerSquareMillimeter());
 
         [Fact]
         public void NumberToKilojoulesPerSquareMeterTest() =>
-            Assert.Equal(Irradiation.FromKilojoulesPerSquareMeter(2), 2.KilojoulesPerSquareMeter());
+            Assert.Equal(Irradiation<double>.FromKilojoulesPerSquareMeter(2), 2.KilojoulesPerSquareMeter());
 
         [Fact]
         public void NumberToKilowattHoursPerSquareMeterTest() =>
-            Assert.Equal(Irradiation.FromKilowattHoursPerSquareMeter(2), 2.KilowattHoursPerSquareMeter());
+            Assert.Equal(Irradiation<double>.FromKilowattHoursPerSquareMeter(2), 2.KilowattHoursPerSquareMeter());
 
         [Fact]
         public void NumberToMillijoulesPerSquareCentimeterTest() =>
-            Assert.Equal(Irradiation.FromMillijoulesPerSquareCentimeter(2), 2.MillijoulesPerSquareCentimeter());
+            Assert.Equal(Irradiation<double>.FromMillijoulesPerSquareCentimeter(2), 2.MillijoulesPerSquareCentimeter());
 
         [Fact]
         public void NumberToWattHoursPerSquareMeterTest() =>
-            Assert.Equal(Irradiation.FromWattHoursPerSquareMeter(2), 2.WattHoursPerSquareMeter());
+            Assert.Equal(Irradiation<double>.FromWattHoursPerSquareMeter(2), 2.WattHoursPerSquareMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs
index 54ac9d71c4..0700adaa86 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs
@@ -21,40 +21,40 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToKinematicViscosityExtensionsTests
     {
         [Fact]
         public void NumberToCentistokesTest() =>
-            Assert.Equal(KinematicViscosity.FromCentistokes(2), 2.Centistokes());
+            Assert.Equal(KinematicViscosity<double>.FromCentistokes(2), 2.Centistokes());
 
         [Fact]
         public void NumberToDecistokesTest() =>
-            Assert.Equal(KinematicViscosity.FromDecistokes(2), 2.Decistokes());
+            Assert.Equal(KinematicViscosity<double>.FromDecistokes(2), 2.Decistokes());
 
         [Fact]
         public void NumberToKilostokesTest() =>
-            Assert.Equal(KinematicViscosity.FromKilostokes(2), 2.Kilostokes());
+            Assert.Equal(KinematicViscosity<double>.FromKilostokes(2), 2.Kilostokes());
 
         [Fact]
         public void NumberToMicrostokesTest() =>
-            Assert.Equal(KinematicViscosity.FromMicrostokes(2), 2.Microstokes());
+            Assert.Equal(KinematicViscosity<double>.FromMicrostokes(2), 2.Microstokes());
 
         [Fact]
         public void NumberToMillistokesTest() =>
-            Assert.Equal(KinematicViscosity.FromMillistokes(2), 2.Millistokes());
+            Assert.Equal(KinematicViscosity<double>.FromMillistokes(2), 2.Millistokes());
 
         [Fact]
         public void NumberToNanostokesTest() =>
-            Assert.Equal(KinematicViscosity.FromNanostokes(2), 2.Nanostokes());
+            Assert.Equal(KinematicViscosity<double>.FromNanostokes(2), 2.Nanostokes());
 
         [Fact]
         public void NumberToSquareMetersPerSecondTest() =>
-            Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(2), 2.SquareMetersPerSecond());
+            Assert.Equal(KinematicViscosity<double>.FromSquareMetersPerSecond(2), 2.SquareMetersPerSecond());
 
         [Fact]
         public void NumberToStokesTest() =>
-            Assert.Equal(KinematicViscosity.FromStokes(2), 2.Stokes());
+            Assert.Equal(KinematicViscosity<double>.FromStokes(2), 2.Stokes());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs
index a18304b716..01584c0e49 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLapseRateExtensionsTests
     {
         [Fact]
         public void NumberToDegreesCelciusPerKilometerTest() =>
-            Assert.Equal(LapseRate.FromDegreesCelciusPerKilometer(2), 2.DegreesCelciusPerKilometer());
+            Assert.Equal(LapseRate<double>.FromDegreesCelciusPerKilometer(2), 2.DegreesCelciusPerKilometer());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs
index 0c2e369277..62faa858c1 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs
@@ -21,140 +21,140 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLengthExtensionsTests
     {
         [Fact]
         public void NumberToAstronomicalUnitsTest() =>
-            Assert.Equal(Length.FromAstronomicalUnits(2), 2.AstronomicalUnits());
+            Assert.Equal(Length<double>.FromAstronomicalUnits(2), 2.AstronomicalUnits());
 
         [Fact]
         public void NumberToCentimetersTest() =>
-            Assert.Equal(Length.FromCentimeters(2), 2.Centimeters());
+            Assert.Equal(Length<double>.FromCentimeters(2), 2.Centimeters());
 
         [Fact]
         public void NumberToChainsTest() =>
-            Assert.Equal(Length.FromChains(2), 2.Chains());
+            Assert.Equal(Length<double>.FromChains(2), 2.Chains());
 
         [Fact]
         public void NumberToDecimetersTest() =>
-            Assert.Equal(Length.FromDecimeters(2), 2.Decimeters());
+            Assert.Equal(Length<double>.FromDecimeters(2), 2.Decimeters());
 
         [Fact]
         public void NumberToDtpPicasTest() =>
-            Assert.Equal(Length.FromDtpPicas(2), 2.DtpPicas());
+            Assert.Equal(Length<double>.FromDtpPicas(2), 2.DtpPicas());
 
         [Fact]
         public void NumberToDtpPointsTest() =>
-            Assert.Equal(Length.FromDtpPoints(2), 2.DtpPoints());
+            Assert.Equal(Length<double>.FromDtpPoints(2), 2.DtpPoints());
 
         [Fact]
         public void NumberToFathomsTest() =>
-            Assert.Equal(Length.FromFathoms(2), 2.Fathoms());
+            Assert.Equal(Length<double>.FromFathoms(2), 2.Fathoms());
 
         [Fact]
         public void NumberToFeetTest() =>
-            Assert.Equal(Length.FromFeet(2), 2.Feet());
+            Assert.Equal(Length<double>.FromFeet(2), 2.Feet());
 
         [Fact]
         public void NumberToHandsTest() =>
-            Assert.Equal(Length.FromHands(2), 2.Hands());
+            Assert.Equal(Length<double>.FromHands(2), 2.Hands());
 
         [Fact]
         public void NumberToHectometersTest() =>
-            Assert.Equal(Length.FromHectometers(2), 2.Hectometers());
+            Assert.Equal(Length<double>.FromHectometers(2), 2.Hectometers());
 
         [Fact]
         public void NumberToInchesTest() =>
-            Assert.Equal(Length.FromInches(2), 2.Inches());
+            Assert.Equal(Length<double>.FromInches(2), 2.Inches());
 
         [Fact]
         public void NumberToKilolightYearsTest() =>
-            Assert.Equal(Length.FromKilolightYears(2), 2.KilolightYears());
+            Assert.Equal(Length<double>.FromKilolightYears(2), 2.KilolightYears());
 
         [Fact]
         public void NumberToKilometersTest() =>
-            Assert.Equal(Length.FromKilometers(2), 2.Kilometers());
+            Assert.Equal(Length<double>.FromKilometers(2), 2.Kilometers());
 
         [Fact]
         public void NumberToKiloparsecsTest() =>
-            Assert.Equal(Length.FromKiloparsecs(2), 2.Kiloparsecs());
+            Assert.Equal(Length<double>.FromKiloparsecs(2), 2.Kiloparsecs());
 
         [Fact]
         public void NumberToLightYearsTest() =>
-            Assert.Equal(Length.FromLightYears(2), 2.LightYears());
+            Assert.Equal(Length<double>.FromLightYears(2), 2.LightYears());
 
         [Fact]
         public void NumberToMegalightYearsTest() =>
-            Assert.Equal(Length.FromMegalightYears(2), 2.MegalightYears());
+            Assert.Equal(Length<double>.FromMegalightYears(2), 2.MegalightYears());
 
         [Fact]
         public void NumberToMegaparsecsTest() =>
-            Assert.Equal(Length.FromMegaparsecs(2), 2.Megaparsecs());
+            Assert.Equal(Length<double>.FromMegaparsecs(2), 2.Megaparsecs());
 
         [Fact]
         public void NumberToMetersTest() =>
-            Assert.Equal(Length.FromMeters(2), 2.Meters());
+            Assert.Equal(Length<double>.FromMeters(2), 2.Meters());
 
         [Fact]
         public void NumberToMicroinchesTest() =>
-            Assert.Equal(Length.FromMicroinches(2), 2.Microinches());
+            Assert.Equal(Length<double>.FromMicroinches(2), 2.Microinches());
 
         [Fact]
         public void NumberToMicrometersTest() =>
-            Assert.Equal(Length.FromMicrometers(2), 2.Micrometers());
+            Assert.Equal(Length<double>.FromMicrometers(2), 2.Micrometers());
 
         [Fact]
         public void NumberToMilsTest() =>
-            Assert.Equal(Length.FromMils(2), 2.Mils());
+            Assert.Equal(Length<double>.FromMils(2), 2.Mils());
 
         [Fact]
         public void NumberToMilesTest() =>
-            Assert.Equal(Length.FromMiles(2), 2.Miles());
+            Assert.Equal(Length<double>.FromMiles(2), 2.Miles());
 
         [Fact]
         public void NumberToMillimetersTest() =>
-            Assert.Equal(Length.FromMillimeters(2), 2.Millimeters());
+            Assert.Equal(Length<double>.FromMillimeters(2), 2.Millimeters());
 
         [Fact]
         public void NumberToNanometersTest() =>
-            Assert.Equal(Length.FromNanometers(2), 2.Nanometers());
+            Assert.Equal(Length<double>.FromNanometers(2), 2.Nanometers());
 
         [Fact]
         public void NumberToNauticalMilesTest() =>
-            Assert.Equal(Length.FromNauticalMiles(2), 2.NauticalMiles());
+            Assert.Equal(Length<double>.FromNauticalMiles(2), 2.NauticalMiles());
 
         [Fact]
         public void NumberToParsecsTest() =>
-            Assert.Equal(Length.FromParsecs(2), 2.Parsecs());
+            Assert.Equal(Length<double>.FromParsecs(2), 2.Parsecs());
 
         [Fact]
         public void NumberToPrinterPicasTest() =>
-            Assert.Equal(Length.FromPrinterPicas(2), 2.PrinterPicas());
+            Assert.Equal(Length<double>.FromPrinterPicas(2), 2.PrinterPicas());
 
         [Fact]
         public void NumberToPrinterPointsTest() =>
-            Assert.Equal(Length.FromPrinterPoints(2), 2.PrinterPoints());
+            Assert.Equal(Length<double>.FromPrinterPoints(2), 2.PrinterPoints());
 
         [Fact]
         public void NumberToShacklesTest() =>
-            Assert.Equal(Length.FromShackles(2), 2.Shackles());
+            Assert.Equal(Length<double>.FromShackles(2), 2.Shackles());
 
         [Fact]
         public void NumberToSolarRadiusesTest() =>
-            Assert.Equal(Length.FromSolarRadiuses(2), 2.SolarRadiuses());
+            Assert.Equal(Length<double>.FromSolarRadiuses(2), 2.SolarRadiuses());
 
         [Fact]
         public void NumberToTwipsTest() =>
-            Assert.Equal(Length.FromTwips(2), 2.Twips());
+            Assert.Equal(Length<double>.FromTwips(2), 2.Twips());
 
         [Fact]
         public void NumberToUsSurveyFeetTest() =>
-            Assert.Equal(Length.FromUsSurveyFeet(2), 2.UsSurveyFeet());
+            Assert.Equal(Length<double>.FromUsSurveyFeet(2), 2.UsSurveyFeet());
 
         [Fact]
         public void NumberToYardsTest() =>
-            Assert.Equal(Length.FromYards(2), 2.Yards());
+            Assert.Equal(Length<double>.FromYards(2), 2.Yards());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs
index 02fc9efc9c..aca711d89c 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs
@@ -21,16 +21,16 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLevelExtensionsTests
     {
         [Fact]
         public void NumberToDecibelsTest() =>
-            Assert.Equal(Level.FromDecibels(2), 2.Decibels());
+            Assert.Equal(Level<double>.FromDecibels(2), 2.Decibels());
 
         [Fact]
         public void NumberToNepersTest() =>
-            Assert.Equal(Level.FromNepers(2), 2.Nepers());
+            Assert.Equal(Level<double>.FromNepers(2), 2.Nepers());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs
index c070929075..a8d529725a 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs
@@ -21,64 +21,64 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLinearDensityExtensionsTests
     {
         [Fact]
         public void NumberToGramsPerCentimeterTest() =>
-            Assert.Equal(LinearDensity.FromGramsPerCentimeter(2), 2.GramsPerCentimeter());
+            Assert.Equal(LinearDensity<double>.FromGramsPerCentimeter(2), 2.GramsPerCentimeter());
 
         [Fact]
         public void NumberToGramsPerMeterTest() =>
-            Assert.Equal(LinearDensity.FromGramsPerMeter(2), 2.GramsPerMeter());
+            Assert.Equal(LinearDensity<double>.FromGramsPerMeter(2), 2.GramsPerMeter());
 
         [Fact]
         public void NumberToGramsPerMillimeterTest() =>
-            Assert.Equal(LinearDensity.FromGramsPerMillimeter(2), 2.GramsPerMillimeter());
+            Assert.Equal(LinearDensity<double>.FromGramsPerMillimeter(2), 2.GramsPerMillimeter());
 
         [Fact]
         public void NumberToKilogramsPerCentimeterTest() =>
-            Assert.Equal(LinearDensity.FromKilogramsPerCentimeter(2), 2.KilogramsPerCentimeter());
+            Assert.Equal(LinearDensity<double>.FromKilogramsPerCentimeter(2), 2.KilogramsPerCentimeter());
 
         [Fact]
         public void NumberToKilogramsPerMeterTest() =>
-            Assert.Equal(LinearDensity.FromKilogramsPerMeter(2), 2.KilogramsPerMeter());
+            Assert.Equal(LinearDensity<double>.FromKilogramsPerMeter(2), 2.KilogramsPerMeter());
 
         [Fact]
         public void NumberToKilogramsPerMillimeterTest() =>
-            Assert.Equal(LinearDensity.FromKilogramsPerMillimeter(2), 2.KilogramsPerMillimeter());
+            Assert.Equal(LinearDensity<double>.FromKilogramsPerMillimeter(2), 2.KilogramsPerMillimeter());
 
         [Fact]
         public void NumberToMicrogramsPerCentimeterTest() =>
-            Assert.Equal(LinearDensity.FromMicrogramsPerCentimeter(2), 2.MicrogramsPerCentimeter());
+            Assert.Equal(LinearDensity<double>.FromMicrogramsPerCentimeter(2), 2.MicrogramsPerCentimeter());
 
         [Fact]
         public void NumberToMicrogramsPerMeterTest() =>
-            Assert.Equal(LinearDensity.FromMicrogramsPerMeter(2), 2.MicrogramsPerMeter());
+            Assert.Equal(LinearDensity<double>.FromMicrogramsPerMeter(2), 2.MicrogramsPerMeter());
 
         [Fact]
         public void NumberToMicrogramsPerMillimeterTest() =>
-            Assert.Equal(LinearDensity.FromMicrogramsPerMillimeter(2), 2.MicrogramsPerMillimeter());
+            Assert.Equal(LinearDensity<double>.FromMicrogramsPerMillimeter(2), 2.MicrogramsPerMillimeter());
 
         [Fact]
         public void NumberToMilligramsPerCentimeterTest() =>
-            Assert.Equal(LinearDensity.FromMilligramsPerCentimeter(2), 2.MilligramsPerCentimeter());
+            Assert.Equal(LinearDensity<double>.FromMilligramsPerCentimeter(2), 2.MilligramsPerCentimeter());
 
         [Fact]
         public void NumberToMilligramsPerMeterTest() =>
-            Assert.Equal(LinearDensity.FromMilligramsPerMeter(2), 2.MilligramsPerMeter());
+            Assert.Equal(LinearDensity<double>.FromMilligramsPerMeter(2), 2.MilligramsPerMeter());
 
         [Fact]
         public void NumberToMilligramsPerMillimeterTest() =>
-            Assert.Equal(LinearDensity.FromMilligramsPerMillimeter(2), 2.MilligramsPerMillimeter());
+            Assert.Equal(LinearDensity<double>.FromMilligramsPerMillimeter(2), 2.MilligramsPerMillimeter());
 
         [Fact]
         public void NumberToPoundsPerFootTest() =>
-            Assert.Equal(LinearDensity.FromPoundsPerFoot(2), 2.PoundsPerFoot());
+            Assert.Equal(LinearDensity<double>.FromPoundsPerFoot(2), 2.PoundsPerFoot());
 
         [Fact]
         public void NumberToPoundsPerInchTest() =>
-            Assert.Equal(LinearDensity.FromPoundsPerInch(2), 2.PoundsPerInch());
+            Assert.Equal(LinearDensity<double>.FromPoundsPerInch(2), 2.PoundsPerInch());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs
index deb623e4dd..91bd874796 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs
@@ -21,108 +21,108 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLinearPowerDensityExtensionsTests
     {
         [Fact]
         public void NumberToGigawattsPerCentimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromGigawattsPerCentimeter(2), 2.GigawattsPerCentimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromGigawattsPerCentimeter(2), 2.GigawattsPerCentimeter());
 
         [Fact]
         public void NumberToGigawattsPerFootTest() =>
-            Assert.Equal(LinearPowerDensity.FromGigawattsPerFoot(2), 2.GigawattsPerFoot());
+            Assert.Equal(LinearPowerDensity<double>.FromGigawattsPerFoot(2), 2.GigawattsPerFoot());
 
         [Fact]
         public void NumberToGigawattsPerInchTest() =>
-            Assert.Equal(LinearPowerDensity.FromGigawattsPerInch(2), 2.GigawattsPerInch());
+            Assert.Equal(LinearPowerDensity<double>.FromGigawattsPerInch(2), 2.GigawattsPerInch());
 
         [Fact]
         public void NumberToGigawattsPerMeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromGigawattsPerMeter(2), 2.GigawattsPerMeter());
+            Assert.Equal(LinearPowerDensity<double>.FromGigawattsPerMeter(2), 2.GigawattsPerMeter());
 
         [Fact]
         public void NumberToGigawattsPerMillimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromGigawattsPerMillimeter(2), 2.GigawattsPerMillimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromGigawattsPerMillimeter(2), 2.GigawattsPerMillimeter());
 
         [Fact]
         public void NumberToKilowattsPerCentimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromKilowattsPerCentimeter(2), 2.KilowattsPerCentimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromKilowattsPerCentimeter(2), 2.KilowattsPerCentimeter());
 
         [Fact]
         public void NumberToKilowattsPerFootTest() =>
-            Assert.Equal(LinearPowerDensity.FromKilowattsPerFoot(2), 2.KilowattsPerFoot());
+            Assert.Equal(LinearPowerDensity<double>.FromKilowattsPerFoot(2), 2.KilowattsPerFoot());
 
         [Fact]
         public void NumberToKilowattsPerInchTest() =>
-            Assert.Equal(LinearPowerDensity.FromKilowattsPerInch(2), 2.KilowattsPerInch());
+            Assert.Equal(LinearPowerDensity<double>.FromKilowattsPerInch(2), 2.KilowattsPerInch());
 
         [Fact]
         public void NumberToKilowattsPerMeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromKilowattsPerMeter(2), 2.KilowattsPerMeter());
+            Assert.Equal(LinearPowerDensity<double>.FromKilowattsPerMeter(2), 2.KilowattsPerMeter());
 
         [Fact]
         public void NumberToKilowattsPerMillimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromKilowattsPerMillimeter(2), 2.KilowattsPerMillimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromKilowattsPerMillimeter(2), 2.KilowattsPerMillimeter());
 
         [Fact]
         public void NumberToMegawattsPerCentimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromMegawattsPerCentimeter(2), 2.MegawattsPerCentimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromMegawattsPerCentimeter(2), 2.MegawattsPerCentimeter());
 
         [Fact]
         public void NumberToMegawattsPerFootTest() =>
-            Assert.Equal(LinearPowerDensity.FromMegawattsPerFoot(2), 2.MegawattsPerFoot());
+            Assert.Equal(LinearPowerDensity<double>.FromMegawattsPerFoot(2), 2.MegawattsPerFoot());
 
         [Fact]
         public void NumberToMegawattsPerInchTest() =>
-            Assert.Equal(LinearPowerDensity.FromMegawattsPerInch(2), 2.MegawattsPerInch());
+            Assert.Equal(LinearPowerDensity<double>.FromMegawattsPerInch(2), 2.MegawattsPerInch());
 
         [Fact]
         public void NumberToMegawattsPerMeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromMegawattsPerMeter(2), 2.MegawattsPerMeter());
+            Assert.Equal(LinearPowerDensity<double>.FromMegawattsPerMeter(2), 2.MegawattsPerMeter());
 
         [Fact]
         public void NumberToMegawattsPerMillimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromMegawattsPerMillimeter(2), 2.MegawattsPerMillimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromMegawattsPerMillimeter(2), 2.MegawattsPerMillimeter());
 
         [Fact]
         public void NumberToMilliwattsPerCentimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromMilliwattsPerCentimeter(2), 2.MilliwattsPerCentimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromMilliwattsPerCentimeter(2), 2.MilliwattsPerCentimeter());
 
         [Fact]
         public void NumberToMilliwattsPerFootTest() =>
-            Assert.Equal(LinearPowerDensity.FromMilliwattsPerFoot(2), 2.MilliwattsPerFoot());
+            Assert.Equal(LinearPowerDensity<double>.FromMilliwattsPerFoot(2), 2.MilliwattsPerFoot());
 
         [Fact]
         public void NumberToMilliwattsPerInchTest() =>
-            Assert.Equal(LinearPowerDensity.FromMilliwattsPerInch(2), 2.MilliwattsPerInch());
+            Assert.Equal(LinearPowerDensity<double>.FromMilliwattsPerInch(2), 2.MilliwattsPerInch());
 
         [Fact]
         public void NumberToMilliwattsPerMeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromMilliwattsPerMeter(2), 2.MilliwattsPerMeter());
+            Assert.Equal(LinearPowerDensity<double>.FromMilliwattsPerMeter(2), 2.MilliwattsPerMeter());
 
         [Fact]
         public void NumberToMilliwattsPerMillimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromMilliwattsPerMillimeter(2), 2.MilliwattsPerMillimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromMilliwattsPerMillimeter(2), 2.MilliwattsPerMillimeter());
 
         [Fact]
         public void NumberToWattsPerCentimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromWattsPerCentimeter(2), 2.WattsPerCentimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromWattsPerCentimeter(2), 2.WattsPerCentimeter());
 
         [Fact]
         public void NumberToWattsPerFootTest() =>
-            Assert.Equal(LinearPowerDensity.FromWattsPerFoot(2), 2.WattsPerFoot());
+            Assert.Equal(LinearPowerDensity<double>.FromWattsPerFoot(2), 2.WattsPerFoot());
 
         [Fact]
         public void NumberToWattsPerInchTest() =>
-            Assert.Equal(LinearPowerDensity.FromWattsPerInch(2), 2.WattsPerInch());
+            Assert.Equal(LinearPowerDensity<double>.FromWattsPerInch(2), 2.WattsPerInch());
 
         [Fact]
         public void NumberToWattsPerMeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromWattsPerMeter(2), 2.WattsPerMeter());
+            Assert.Equal(LinearPowerDensity<double>.FromWattsPerMeter(2), 2.WattsPerMeter());
 
         [Fact]
         public void NumberToWattsPerMillimeterTest() =>
-            Assert.Equal(LinearPowerDensity.FromWattsPerMillimeter(2), 2.WattsPerMillimeter());
+            Assert.Equal(LinearPowerDensity<double>.FromWattsPerMillimeter(2), 2.WattsPerMillimeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs
index 0e4a7d8c7a..557493131e 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs
@@ -21,64 +21,64 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLuminosityExtensionsTests
     {
         [Fact]
         public void NumberToDecawattsTest() =>
-            Assert.Equal(Luminosity.FromDecawatts(2), 2.Decawatts());
+            Assert.Equal(Luminosity<double>.FromDecawatts(2), 2.Decawatts());
 
         [Fact]
         public void NumberToDeciwattsTest() =>
-            Assert.Equal(Luminosity.FromDeciwatts(2), 2.Deciwatts());
+            Assert.Equal(Luminosity<double>.FromDeciwatts(2), 2.Deciwatts());
 
         [Fact]
         public void NumberToFemtowattsTest() =>
-            Assert.Equal(Luminosity.FromFemtowatts(2), 2.Femtowatts());
+            Assert.Equal(Luminosity<double>.FromFemtowatts(2), 2.Femtowatts());
 
         [Fact]
         public void NumberToGigawattsTest() =>
-            Assert.Equal(Luminosity.FromGigawatts(2), 2.Gigawatts());
+            Assert.Equal(Luminosity<double>.FromGigawatts(2), 2.Gigawatts());
 
         [Fact]
         public void NumberToKilowattsTest() =>
-            Assert.Equal(Luminosity.FromKilowatts(2), 2.Kilowatts());
+            Assert.Equal(Luminosity<double>.FromKilowatts(2), 2.Kilowatts());
 
         [Fact]
         public void NumberToMegawattsTest() =>
-            Assert.Equal(Luminosity.FromMegawatts(2), 2.Megawatts());
+            Assert.Equal(Luminosity<double>.FromMegawatts(2), 2.Megawatts());
 
         [Fact]
         public void NumberToMicrowattsTest() =>
-            Assert.Equal(Luminosity.FromMicrowatts(2), 2.Microwatts());
+            Assert.Equal(Luminosity<double>.FromMicrowatts(2), 2.Microwatts());
 
         [Fact]
         public void NumberToMilliwattsTest() =>
-            Assert.Equal(Luminosity.FromMilliwatts(2), 2.Milliwatts());
+            Assert.Equal(Luminosity<double>.FromMilliwatts(2), 2.Milliwatts());
 
         [Fact]
         public void NumberToNanowattsTest() =>
-            Assert.Equal(Luminosity.FromNanowatts(2), 2.Nanowatts());
+            Assert.Equal(Luminosity<double>.FromNanowatts(2), 2.Nanowatts());
 
         [Fact]
         public void NumberToPetawattsTest() =>
-            Assert.Equal(Luminosity.FromPetawatts(2), 2.Petawatts());
+            Assert.Equal(Luminosity<double>.FromPetawatts(2), 2.Petawatts());
 
         [Fact]
         public void NumberToPicowattsTest() =>
-            Assert.Equal(Luminosity.FromPicowatts(2), 2.Picowatts());
+            Assert.Equal(Luminosity<double>.FromPicowatts(2), 2.Picowatts());
 
         [Fact]
         public void NumberToSolarLuminositiesTest() =>
-            Assert.Equal(Luminosity.FromSolarLuminosities(2), 2.SolarLuminosities());
+            Assert.Equal(Luminosity<double>.FromSolarLuminosities(2), 2.SolarLuminosities());
 
         [Fact]
         public void NumberToTerawattsTest() =>
-            Assert.Equal(Luminosity.FromTerawatts(2), 2.Terawatts());
+            Assert.Equal(Luminosity<double>.FromTerawatts(2), 2.Terawatts());
 
         [Fact]
         public void NumberToWattsTest() =>
-            Assert.Equal(Luminosity.FromWatts(2), 2.Watts());
+            Assert.Equal(Luminosity<double>.FromWatts(2), 2.Watts());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs
index 4f2c476c67..57c03cfac2 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLuminousFluxExtensionsTests
     {
         [Fact]
         public void NumberToLumensTest() =>
-            Assert.Equal(LuminousFlux.FromLumens(2), 2.Lumens());
+            Assert.Equal(LuminousFlux<double>.FromLumens(2), 2.Lumens());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs
index c5b91b4349..65b409be2b 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToLuminousIntensityExtensionsTests
     {
         [Fact]
         public void NumberToCandelaTest() =>
-            Assert.Equal(LuminousIntensity.FromCandela(2), 2.Candela());
+            Assert.Equal(LuminousIntensity<double>.FromCandela(2), 2.Candela());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs
index ed49e1b4d1..3d72c1a677 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs
@@ -21,28 +21,28 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMagneticFieldExtensionsTests
     {
         [Fact]
         public void NumberToGaussesTest() =>
-            Assert.Equal(MagneticField.FromGausses(2), 2.Gausses());
+            Assert.Equal(MagneticField<double>.FromGausses(2), 2.Gausses());
 
         [Fact]
         public void NumberToMicroteslasTest() =>
-            Assert.Equal(MagneticField.FromMicroteslas(2), 2.Microteslas());
+            Assert.Equal(MagneticField<double>.FromMicroteslas(2), 2.Microteslas());
 
         [Fact]
         public void NumberToMilliteslasTest() =>
-            Assert.Equal(MagneticField.FromMilliteslas(2), 2.Milliteslas());
+            Assert.Equal(MagneticField<double>.FromMilliteslas(2), 2.Milliteslas());
 
         [Fact]
         public void NumberToNanoteslasTest() =>
-            Assert.Equal(MagneticField.FromNanoteslas(2), 2.Nanoteslas());
+            Assert.Equal(MagneticField<double>.FromNanoteslas(2), 2.Nanoteslas());
 
         [Fact]
         public void NumberToTeslasTest() =>
-            Assert.Equal(MagneticField.FromTeslas(2), 2.Teslas());
+            Assert.Equal(MagneticField<double>.FromTeslas(2), 2.Teslas());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs
index 5a801aba5f..88ae959f48 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMagneticFluxExtensionsTests
     {
         [Fact]
         public void NumberToWebersTest() =>
-            Assert.Equal(MagneticFlux.FromWebers(2), 2.Webers());
+            Assert.Equal(MagneticFlux<double>.FromWebers(2), 2.Webers());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs
index ed0696ed14..4fd939ac90 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMagnetizationExtensionsTests
     {
         [Fact]
         public void NumberToAmperesPerMeterTest() =>
-            Assert.Equal(Magnetization.FromAmperesPerMeter(2), 2.AmperesPerMeter());
+            Assert.Equal(Magnetization<double>.FromAmperesPerMeter(2), 2.AmperesPerMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
index 0271163856..2fdab98077 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
@@ -21,196 +21,196 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMassConcentrationExtensionsTests
     {
         [Fact]
         public void NumberToCentigramsPerDeciliterTest() =>
-            Assert.Equal(MassConcentration.FromCentigramsPerDeciliter(2), 2.CentigramsPerDeciliter());
+            Assert.Equal(MassConcentration<double>.FromCentigramsPerDeciliter(2), 2.CentigramsPerDeciliter());
 
         [Fact]
         public void NumberToCentigramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromCentigramsPerLiter(2), 2.CentigramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromCentigramsPerLiter(2), 2.CentigramsPerLiter());
 
         [Fact]
         public void NumberToCentigramsPerMicroliterTest() =>
-            Assert.Equal(MassConcentration.FromCentigramsPerMicroliter(2), 2.CentigramsPerMicroliter());
+            Assert.Equal(MassConcentration<double>.FromCentigramsPerMicroliter(2), 2.CentigramsPerMicroliter());
 
         [Fact]
         public void NumberToCentigramsPerMilliliterTest() =>
-            Assert.Equal(MassConcentration.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter());
+            Assert.Equal(MassConcentration<double>.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter());
 
         [Fact]
         public void NumberToDecigramsPerDeciliterTest() =>
-            Assert.Equal(MassConcentration.FromDecigramsPerDeciliter(2), 2.DecigramsPerDeciliter());
+            Assert.Equal(MassConcentration<double>.FromDecigramsPerDeciliter(2), 2.DecigramsPerDeciliter());
 
         [Fact]
         public void NumberToDecigramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromDecigramsPerLiter(2), 2.DecigramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromDecigramsPerLiter(2), 2.DecigramsPerLiter());
 
         [Fact]
         public void NumberToDecigramsPerMicroliterTest() =>
-            Assert.Equal(MassConcentration.FromDecigramsPerMicroliter(2), 2.DecigramsPerMicroliter());
+            Assert.Equal(MassConcentration<double>.FromDecigramsPerMicroliter(2), 2.DecigramsPerMicroliter());
 
         [Fact]
         public void NumberToDecigramsPerMilliliterTest() =>
-            Assert.Equal(MassConcentration.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter());
+            Assert.Equal(MassConcentration<double>.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter());
 
         [Fact]
         public void NumberToGramsPerCubicCentimeterTest() =>
-            Assert.Equal(MassConcentration.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter());
+            Assert.Equal(MassConcentration<double>.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter());
 
         [Fact]
         public void NumberToGramsPerCubicMeterTest() =>
-            Assert.Equal(MassConcentration.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter());
+            Assert.Equal(MassConcentration<double>.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter());
 
         [Fact]
         public void NumberToGramsPerCubicMillimeterTest() =>
-            Assert.Equal(MassConcentration.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter());
+            Assert.Equal(MassConcentration<double>.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter());
 
         [Fact]
         public void NumberToGramsPerDeciliterTest() =>
-            Assert.Equal(MassConcentration.FromGramsPerDeciliter(2), 2.GramsPerDeciliter());
+            Assert.Equal(MassConcentration<double>.FromGramsPerDeciliter(2), 2.GramsPerDeciliter());
 
         [Fact]
         public void NumberToGramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromGramsPerLiter(2), 2.GramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromGramsPerLiter(2), 2.GramsPerLiter());
 
         [Fact]
         public void NumberToGramsPerMicroliterTest() =>
-            Assert.Equal(MassConcentration.FromGramsPerMicroliter(2), 2.GramsPerMicroliter());
+            Assert.Equal(MassConcentration<double>.FromGramsPerMicroliter(2), 2.GramsPerMicroliter());
 
         [Fact]
         public void NumberToGramsPerMilliliterTest() =>
-            Assert.Equal(MassConcentration.FromGramsPerMilliliter(2), 2.GramsPerMilliliter());
+            Assert.Equal(MassConcentration<double>.FromGramsPerMilliliter(2), 2.GramsPerMilliliter());
 
         [Fact]
         public void NumberToKilogramsPerCubicCentimeterTest() =>
-            Assert.Equal(MassConcentration.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter());
+            Assert.Equal(MassConcentration<double>.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter());
 
         [Fact]
         public void NumberToKilogramsPerCubicMeterTest() =>
-            Assert.Equal(MassConcentration.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter());
+            Assert.Equal(MassConcentration<double>.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter());
 
         [Fact]
         public void NumberToKilogramsPerCubicMillimeterTest() =>
-            Assert.Equal(MassConcentration.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter());
+            Assert.Equal(MassConcentration<double>.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter());
 
         [Fact]
         public void NumberToKilogramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromKilogramsPerLiter(2), 2.KilogramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromKilogramsPerLiter(2), 2.KilogramsPerLiter());
 
         [Fact]
         public void NumberToKilopoundsPerCubicFootTest() =>
-            Assert.Equal(MassConcentration.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot());
+            Assert.Equal(MassConcentration<double>.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot());
 
         [Fact]
         public void NumberToKilopoundsPerCubicInchTest() =>
-            Assert.Equal(MassConcentration.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch());
+            Assert.Equal(MassConcentration<double>.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch());
 
         [Fact]
         public void NumberToMicrogramsPerCubicMeterTest() =>
-            Assert.Equal(MassConcentration.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter());
+            Assert.Equal(MassConcentration<double>.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter());
 
         [Fact]
         public void NumberToMicrogramsPerDeciliterTest() =>
-            Assert.Equal(MassConcentration.FromMicrogramsPerDeciliter(2), 2.MicrogramsPerDeciliter());
+            Assert.Equal(MassConcentration<double>.FromMicrogramsPerDeciliter(2), 2.MicrogramsPerDeciliter());
 
         [Fact]
         public void NumberToMicrogramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter());
 
         [Fact]
         public void NumberToMicrogramsPerMicroliterTest() =>
-            Assert.Equal(MassConcentration.FromMicrogramsPerMicroliter(2), 2.MicrogramsPerMicroliter());
+            Assert.Equal(MassConcentration<double>.FromMicrogramsPerMicroliter(2), 2.MicrogramsPerMicroliter());
 
         [Fact]
         public void NumberToMicrogramsPerMilliliterTest() =>
-            Assert.Equal(MassConcentration.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter());
+            Assert.Equal(MassConcentration<double>.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter());
 
         [Fact]
         public void NumberToMilligramsPerCubicMeterTest() =>
-            Assert.Equal(MassConcentration.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter());
+            Assert.Equal(MassConcentration<double>.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter());
 
         [Fact]
         public void NumberToMilligramsPerDeciliterTest() =>
-            Assert.Equal(MassConcentration.FromMilligramsPerDeciliter(2), 2.MilligramsPerDeciliter());
+            Assert.Equal(MassConcentration<double>.FromMilligramsPerDeciliter(2), 2.MilligramsPerDeciliter());
 
         [Fact]
         public void NumberToMilligramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromMilligramsPerLiter(2), 2.MilligramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromMilligramsPerLiter(2), 2.MilligramsPerLiter());
 
         [Fact]
         public void NumberToMilligramsPerMicroliterTest() =>
-            Assert.Equal(MassConcentration.FromMilligramsPerMicroliter(2), 2.MilligramsPerMicroliter());
+            Assert.Equal(MassConcentration<double>.FromMilligramsPerMicroliter(2), 2.MilligramsPerMicroliter());
 
         [Fact]
         public void NumberToMilligramsPerMilliliterTest() =>
-            Assert.Equal(MassConcentration.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter());
+            Assert.Equal(MassConcentration<double>.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter());
 
         [Fact]
         public void NumberToNanogramsPerDeciliterTest() =>
-            Assert.Equal(MassConcentration.FromNanogramsPerDeciliter(2), 2.NanogramsPerDeciliter());
+            Assert.Equal(MassConcentration<double>.FromNanogramsPerDeciliter(2), 2.NanogramsPerDeciliter());
 
         [Fact]
         public void NumberToNanogramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromNanogramsPerLiter(2), 2.NanogramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromNanogramsPerLiter(2), 2.NanogramsPerLiter());
 
         [Fact]
         public void NumberToNanogramsPerMicroliterTest() =>
-            Assert.Equal(MassConcentration.FromNanogramsPerMicroliter(2), 2.NanogramsPerMicroliter());
+            Assert.Equal(MassConcentration<double>.FromNanogramsPerMicroliter(2), 2.NanogramsPerMicroliter());
 
         [Fact]
         public void NumberToNanogramsPerMilliliterTest() =>
-            Assert.Equal(MassConcentration.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter());
+            Assert.Equal(MassConcentration<double>.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter());
 
         [Fact]
         public void NumberToPicogramsPerDeciliterTest() =>
-            Assert.Equal(MassConcentration.FromPicogramsPerDeciliter(2), 2.PicogramsPerDeciliter());
+            Assert.Equal(MassConcentration<double>.FromPicogramsPerDeciliter(2), 2.PicogramsPerDeciliter());
 
         [Fact]
         public void NumberToPicogramsPerLiterTest() =>
-            Assert.Equal(MassConcentration.FromPicogramsPerLiter(2), 2.PicogramsPerLiter());
+            Assert.Equal(MassConcentration<double>.FromPicogramsPerLiter(2), 2.PicogramsPerLiter());
 
         [Fact]
         public void NumberToPicogramsPerMicroliterTest() =>
-            Assert.Equal(MassConcentration.FromPicogramsPerMicroliter(2), 2.PicogramsPerMicroliter());
+            Assert.Equal(MassConcentration<double>.FromPicogramsPerMicroliter(2), 2.PicogramsPerMicroliter());
 
         [Fact]
         public void NumberToPicogramsPerMilliliterTest() =>
-            Assert.Equal(MassConcentration.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter());
+            Assert.Equal(MassConcentration<double>.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter());
 
         [Fact]
         public void NumberToPoundsPerCubicFootTest() =>
-            Assert.Equal(MassConcentration.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot());
+            Assert.Equal(MassConcentration<double>.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot());
 
         [Fact]
         public void NumberToPoundsPerCubicInchTest() =>
-            Assert.Equal(MassConcentration.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch());
+            Assert.Equal(MassConcentration<double>.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch());
 
         [Fact]
         public void NumberToPoundsPerImperialGallonTest() =>
-            Assert.Equal(MassConcentration.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon());
+            Assert.Equal(MassConcentration<double>.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon());
 
         [Fact]
         public void NumberToPoundsPerUSGallonTest() =>
-            Assert.Equal(MassConcentration.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon());
+            Assert.Equal(MassConcentration<double>.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon());
 
         [Fact]
         public void NumberToSlugsPerCubicFootTest() =>
-            Assert.Equal(MassConcentration.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot());
+            Assert.Equal(MassConcentration<double>.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot());
 
         [Fact]
         public void NumberToTonnesPerCubicCentimeterTest() =>
-            Assert.Equal(MassConcentration.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter());
+            Assert.Equal(MassConcentration<double>.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter());
 
         [Fact]
         public void NumberToTonnesPerCubicMeterTest() =>
-            Assert.Equal(MassConcentration.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter());
+            Assert.Equal(MassConcentration<double>.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter());
 
         [Fact]
         public void NumberToTonnesPerCubicMillimeterTest() =>
-            Assert.Equal(MassConcentration.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter());
+            Assert.Equal(MassConcentration<double>.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs
index 55dbe6f344..80fcaebf84 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs
@@ -21,108 +21,108 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMassExtensionsTests
     {
         [Fact]
         public void NumberToCentigramsTest() =>
-            Assert.Equal(Mass.FromCentigrams(2), 2.Centigrams());
+            Assert.Equal(Mass<double>.FromCentigrams(2), 2.Centigrams());
 
         [Fact]
         public void NumberToDecagramsTest() =>
-            Assert.Equal(Mass.FromDecagrams(2), 2.Decagrams());
+            Assert.Equal(Mass<double>.FromDecagrams(2), 2.Decagrams());
 
         [Fact]
         public void NumberToDecigramsTest() =>
-            Assert.Equal(Mass.FromDecigrams(2), 2.Decigrams());
+            Assert.Equal(Mass<double>.FromDecigrams(2), 2.Decigrams());
 
         [Fact]
         public void NumberToEarthMassesTest() =>
-            Assert.Equal(Mass.FromEarthMasses(2), 2.EarthMasses());
+            Assert.Equal(Mass<double>.FromEarthMasses(2), 2.EarthMasses());
 
         [Fact]
         public void NumberToGrainsTest() =>
-            Assert.Equal(Mass.FromGrains(2), 2.Grains());
+            Assert.Equal(Mass<double>.FromGrains(2), 2.Grains());
 
         [Fact]
         public void NumberToGramsTest() =>
-            Assert.Equal(Mass.FromGrams(2), 2.Grams());
+            Assert.Equal(Mass<double>.FromGrams(2), 2.Grams());
 
         [Fact]
         public void NumberToHectogramsTest() =>
-            Assert.Equal(Mass.FromHectograms(2), 2.Hectograms());
+            Assert.Equal(Mass<double>.FromHectograms(2), 2.Hectograms());
 
         [Fact]
         public void NumberToKilogramsTest() =>
-            Assert.Equal(Mass.FromKilograms(2), 2.Kilograms());
+            Assert.Equal(Mass<double>.FromKilograms(2), 2.Kilograms());
 
         [Fact]
         public void NumberToKilopoundsTest() =>
-            Assert.Equal(Mass.FromKilopounds(2), 2.Kilopounds());
+            Assert.Equal(Mass<double>.FromKilopounds(2), 2.Kilopounds());
 
         [Fact]
         public void NumberToKilotonnesTest() =>
-            Assert.Equal(Mass.FromKilotonnes(2), 2.Kilotonnes());
+            Assert.Equal(Mass<double>.FromKilotonnes(2), 2.Kilotonnes());
 
         [Fact]
         public void NumberToLongHundredweightTest() =>
-            Assert.Equal(Mass.FromLongHundredweight(2), 2.LongHundredweight());
+            Assert.Equal(Mass<double>.FromLongHundredweight(2), 2.LongHundredweight());
 
         [Fact]
         public void NumberToLongTonsTest() =>
-            Assert.Equal(Mass.FromLongTons(2), 2.LongTons());
+            Assert.Equal(Mass<double>.FromLongTons(2), 2.LongTons());
 
         [Fact]
         public void NumberToMegapoundsTest() =>
-            Assert.Equal(Mass.FromMegapounds(2), 2.Megapounds());
+            Assert.Equal(Mass<double>.FromMegapounds(2), 2.Megapounds());
 
         [Fact]
         public void NumberToMegatonnesTest() =>
-            Assert.Equal(Mass.FromMegatonnes(2), 2.Megatonnes());
+            Assert.Equal(Mass<double>.FromMegatonnes(2), 2.Megatonnes());
 
         [Fact]
         public void NumberToMicrogramsTest() =>
-            Assert.Equal(Mass.FromMicrograms(2), 2.Micrograms());
+            Assert.Equal(Mass<double>.FromMicrograms(2), 2.Micrograms());
 
         [Fact]
         public void NumberToMilligramsTest() =>
-            Assert.Equal(Mass.FromMilligrams(2), 2.Milligrams());
+            Assert.Equal(Mass<double>.FromMilligrams(2), 2.Milligrams());
 
         [Fact]
         public void NumberToNanogramsTest() =>
-            Assert.Equal(Mass.FromNanograms(2), 2.Nanograms());
+            Assert.Equal(Mass<double>.FromNanograms(2), 2.Nanograms());
 
         [Fact]
         public void NumberToOuncesTest() =>
-            Assert.Equal(Mass.FromOunces(2), 2.Ounces());
+            Assert.Equal(Mass<double>.FromOunces(2), 2.Ounces());
 
         [Fact]
         public void NumberToPoundsTest() =>
-            Assert.Equal(Mass.FromPounds(2), 2.Pounds());
+            Assert.Equal(Mass<double>.FromPounds(2), 2.Pounds());
 
         [Fact]
         public void NumberToShortHundredweightTest() =>
-            Assert.Equal(Mass.FromShortHundredweight(2), 2.ShortHundredweight());
+            Assert.Equal(Mass<double>.FromShortHundredweight(2), 2.ShortHundredweight());
 
         [Fact]
         public void NumberToShortTonsTest() =>
-            Assert.Equal(Mass.FromShortTons(2), 2.ShortTons());
+            Assert.Equal(Mass<double>.FromShortTons(2), 2.ShortTons());
 
         [Fact]
         public void NumberToSlugsTest() =>
-            Assert.Equal(Mass.FromSlugs(2), 2.Slugs());
+            Assert.Equal(Mass<double>.FromSlugs(2), 2.Slugs());
 
         [Fact]
         public void NumberToSolarMassesTest() =>
-            Assert.Equal(Mass.FromSolarMasses(2), 2.SolarMasses());
+            Assert.Equal(Mass<double>.FromSolarMasses(2), 2.SolarMasses());
 
         [Fact]
         public void NumberToStoneTest() =>
-            Assert.Equal(Mass.FromStone(2), 2.Stone());
+            Assert.Equal(Mass<double>.FromStone(2), 2.Stone());
 
         [Fact]
         public void NumberToTonnesTest() =>
-            Assert.Equal(Mass.FromTonnes(2), 2.Tonnes());
+            Assert.Equal(Mass<double>.FromTonnes(2), 2.Tonnes());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs
index 4a18fd2c38..3e8010b3e1 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs
@@ -21,140 +21,140 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMassFlowExtensionsTests
     {
         [Fact]
         public void NumberToCentigramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromCentigramsPerDay(2), 2.CentigramsPerDay());
+            Assert.Equal(MassFlow<double>.FromCentigramsPerDay(2), 2.CentigramsPerDay());
 
         [Fact]
         public void NumberToCentigramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromCentigramsPerSecond(2), 2.CentigramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromCentigramsPerSecond(2), 2.CentigramsPerSecond());
 
         [Fact]
         public void NumberToDecagramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromDecagramsPerDay(2), 2.DecagramsPerDay());
+            Assert.Equal(MassFlow<double>.FromDecagramsPerDay(2), 2.DecagramsPerDay());
 
         [Fact]
         public void NumberToDecagramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromDecagramsPerSecond(2), 2.DecagramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromDecagramsPerSecond(2), 2.DecagramsPerSecond());
 
         [Fact]
         public void NumberToDecigramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromDecigramsPerDay(2), 2.DecigramsPerDay());
+            Assert.Equal(MassFlow<double>.FromDecigramsPerDay(2), 2.DecigramsPerDay());
 
         [Fact]
         public void NumberToDecigramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromDecigramsPerSecond(2), 2.DecigramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromDecigramsPerSecond(2), 2.DecigramsPerSecond());
 
         [Fact]
         public void NumberToGramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromGramsPerDay(2), 2.GramsPerDay());
+            Assert.Equal(MassFlow<double>.FromGramsPerDay(2), 2.GramsPerDay());
 
         [Fact]
         public void NumberToGramsPerHourTest() =>
-            Assert.Equal(MassFlow.FromGramsPerHour(2), 2.GramsPerHour());
+            Assert.Equal(MassFlow<double>.FromGramsPerHour(2), 2.GramsPerHour());
 
         [Fact]
         public void NumberToGramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromGramsPerSecond(2), 2.GramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromGramsPerSecond(2), 2.GramsPerSecond());
 
         [Fact]
         public void NumberToHectogramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromHectogramsPerDay(2), 2.HectogramsPerDay());
+            Assert.Equal(MassFlow<double>.FromHectogramsPerDay(2), 2.HectogramsPerDay());
 
         [Fact]
         public void NumberToHectogramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromHectogramsPerSecond(2), 2.HectogramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromHectogramsPerSecond(2), 2.HectogramsPerSecond());
 
         [Fact]
         public void NumberToKilogramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromKilogramsPerDay(2), 2.KilogramsPerDay());
+            Assert.Equal(MassFlow<double>.FromKilogramsPerDay(2), 2.KilogramsPerDay());
 
         [Fact]
         public void NumberToKilogramsPerHourTest() =>
-            Assert.Equal(MassFlow.FromKilogramsPerHour(2), 2.KilogramsPerHour());
+            Assert.Equal(MassFlow<double>.FromKilogramsPerHour(2), 2.KilogramsPerHour());
 
         [Fact]
         public void NumberToKilogramsPerMinuteTest() =>
-            Assert.Equal(MassFlow.FromKilogramsPerMinute(2), 2.KilogramsPerMinute());
+            Assert.Equal(MassFlow<double>.FromKilogramsPerMinute(2), 2.KilogramsPerMinute());
 
         [Fact]
         public void NumberToKilogramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromKilogramsPerSecond(2), 2.KilogramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromKilogramsPerSecond(2), 2.KilogramsPerSecond());
 
         [Fact]
         public void NumberToMegagramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromMegagramsPerDay(2), 2.MegagramsPerDay());
+            Assert.Equal(MassFlow<double>.FromMegagramsPerDay(2), 2.MegagramsPerDay());
 
         [Fact]
         public void NumberToMegapoundsPerDayTest() =>
-            Assert.Equal(MassFlow.FromMegapoundsPerDay(2), 2.MegapoundsPerDay());
+            Assert.Equal(MassFlow<double>.FromMegapoundsPerDay(2), 2.MegapoundsPerDay());
 
         [Fact]
         public void NumberToMegapoundsPerHourTest() =>
-            Assert.Equal(MassFlow.FromMegapoundsPerHour(2), 2.MegapoundsPerHour());
+            Assert.Equal(MassFlow<double>.FromMegapoundsPerHour(2), 2.MegapoundsPerHour());
 
         [Fact]
         public void NumberToMegapoundsPerMinuteTest() =>
-            Assert.Equal(MassFlow.FromMegapoundsPerMinute(2), 2.MegapoundsPerMinute());
+            Assert.Equal(MassFlow<double>.FromMegapoundsPerMinute(2), 2.MegapoundsPerMinute());
 
         [Fact]
         public void NumberToMegapoundsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromMegapoundsPerSecond(2), 2.MegapoundsPerSecond());
+            Assert.Equal(MassFlow<double>.FromMegapoundsPerSecond(2), 2.MegapoundsPerSecond());
 
         [Fact]
         public void NumberToMicrogramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromMicrogramsPerDay(2), 2.MicrogramsPerDay());
+            Assert.Equal(MassFlow<double>.FromMicrogramsPerDay(2), 2.MicrogramsPerDay());
 
         [Fact]
         public void NumberToMicrogramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromMicrogramsPerSecond(2), 2.MicrogramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromMicrogramsPerSecond(2), 2.MicrogramsPerSecond());
 
         [Fact]
         public void NumberToMilligramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromMilligramsPerDay(2), 2.MilligramsPerDay());
+            Assert.Equal(MassFlow<double>.FromMilligramsPerDay(2), 2.MilligramsPerDay());
 
         [Fact]
         public void NumberToMilligramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromMilligramsPerSecond(2), 2.MilligramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromMilligramsPerSecond(2), 2.MilligramsPerSecond());
 
         [Fact]
         public void NumberToNanogramsPerDayTest() =>
-            Assert.Equal(MassFlow.FromNanogramsPerDay(2), 2.NanogramsPerDay());
+            Assert.Equal(MassFlow<double>.FromNanogramsPerDay(2), 2.NanogramsPerDay());
 
         [Fact]
         public void NumberToNanogramsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromNanogramsPerSecond(2), 2.NanogramsPerSecond());
+            Assert.Equal(MassFlow<double>.FromNanogramsPerSecond(2), 2.NanogramsPerSecond());
 
         [Fact]
         public void NumberToPoundsPerDayTest() =>
-            Assert.Equal(MassFlow.FromPoundsPerDay(2), 2.PoundsPerDay());
+            Assert.Equal(MassFlow<double>.FromPoundsPerDay(2), 2.PoundsPerDay());
 
         [Fact]
         public void NumberToPoundsPerHourTest() =>
-            Assert.Equal(MassFlow.FromPoundsPerHour(2), 2.PoundsPerHour());
+            Assert.Equal(MassFlow<double>.FromPoundsPerHour(2), 2.PoundsPerHour());
 
         [Fact]
         public void NumberToPoundsPerMinuteTest() =>
-            Assert.Equal(MassFlow.FromPoundsPerMinute(2), 2.PoundsPerMinute());
+            Assert.Equal(MassFlow<double>.FromPoundsPerMinute(2), 2.PoundsPerMinute());
 
         [Fact]
         public void NumberToPoundsPerSecondTest() =>
-            Assert.Equal(MassFlow.FromPoundsPerSecond(2), 2.PoundsPerSecond());
+            Assert.Equal(MassFlow<double>.FromPoundsPerSecond(2), 2.PoundsPerSecond());
 
         [Fact]
         public void NumberToShortTonsPerHourTest() =>
-            Assert.Equal(MassFlow.FromShortTonsPerHour(2), 2.ShortTonsPerHour());
+            Assert.Equal(MassFlow<double>.FromShortTonsPerHour(2), 2.ShortTonsPerHour());
 
         [Fact]
         public void NumberToTonnesPerDayTest() =>
-            Assert.Equal(MassFlow.FromTonnesPerDay(2), 2.TonnesPerDay());
+            Assert.Equal(MassFlow<double>.FromTonnesPerDay(2), 2.TonnesPerDay());
 
         [Fact]
         public void NumberToTonnesPerHourTest() =>
-            Assert.Equal(MassFlow.FromTonnesPerHour(2), 2.TonnesPerHour());
+            Assert.Equal(MassFlow<double>.FromTonnesPerHour(2), 2.TonnesPerHour());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs
index cab140f603..ff83f1dc5a 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs
@@ -21,56 +21,56 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMassFluxExtensionsTests
     {
         [Fact]
         public void NumberToGramsPerHourPerSquareCentimeterTest() =>
-            Assert.Equal(MassFlux.FromGramsPerHourPerSquareCentimeter(2), 2.GramsPerHourPerSquareCentimeter());
+            Assert.Equal(MassFlux<double>.FromGramsPerHourPerSquareCentimeter(2), 2.GramsPerHourPerSquareCentimeter());
 
         [Fact]
         public void NumberToGramsPerHourPerSquareMeterTest() =>
-            Assert.Equal(MassFlux.FromGramsPerHourPerSquareMeter(2), 2.GramsPerHourPerSquareMeter());
+            Assert.Equal(MassFlux<double>.FromGramsPerHourPerSquareMeter(2), 2.GramsPerHourPerSquareMeter());
 
         [Fact]
         public void NumberToGramsPerHourPerSquareMillimeterTest() =>
-            Assert.Equal(MassFlux.FromGramsPerHourPerSquareMillimeter(2), 2.GramsPerHourPerSquareMillimeter());
+            Assert.Equal(MassFlux<double>.FromGramsPerHourPerSquareMillimeter(2), 2.GramsPerHourPerSquareMillimeter());
 
         [Fact]
         public void NumberToGramsPerSecondPerSquareCentimeterTest() =>
-            Assert.Equal(MassFlux.FromGramsPerSecondPerSquareCentimeter(2), 2.GramsPerSecondPerSquareCentimeter());
+            Assert.Equal(MassFlux<double>.FromGramsPerSecondPerSquareCentimeter(2), 2.GramsPerSecondPerSquareCentimeter());
 
         [Fact]
         public void NumberToGramsPerSecondPerSquareMeterTest() =>
-            Assert.Equal(MassFlux.FromGramsPerSecondPerSquareMeter(2), 2.GramsPerSecondPerSquareMeter());
+            Assert.Equal(MassFlux<double>.FromGramsPerSecondPerSquareMeter(2), 2.GramsPerSecondPerSquareMeter());
 
         [Fact]
         public void NumberToGramsPerSecondPerSquareMillimeterTest() =>
-            Assert.Equal(MassFlux.FromGramsPerSecondPerSquareMillimeter(2), 2.GramsPerSecondPerSquareMillimeter());
+            Assert.Equal(MassFlux<double>.FromGramsPerSecondPerSquareMillimeter(2), 2.GramsPerSecondPerSquareMillimeter());
 
         [Fact]
         public void NumberToKilogramsPerHourPerSquareCentimeterTest() =>
-            Assert.Equal(MassFlux.FromKilogramsPerHourPerSquareCentimeter(2), 2.KilogramsPerHourPerSquareCentimeter());
+            Assert.Equal(MassFlux<double>.FromKilogramsPerHourPerSquareCentimeter(2), 2.KilogramsPerHourPerSquareCentimeter());
 
         [Fact]
         public void NumberToKilogramsPerHourPerSquareMeterTest() =>
-            Assert.Equal(MassFlux.FromKilogramsPerHourPerSquareMeter(2), 2.KilogramsPerHourPerSquareMeter());
+            Assert.Equal(MassFlux<double>.FromKilogramsPerHourPerSquareMeter(2), 2.KilogramsPerHourPerSquareMeter());
 
         [Fact]
         public void NumberToKilogramsPerHourPerSquareMillimeterTest() =>
-            Assert.Equal(MassFlux.FromKilogramsPerHourPerSquareMillimeter(2), 2.KilogramsPerHourPerSquareMillimeter());
+            Assert.Equal(MassFlux<double>.FromKilogramsPerHourPerSquareMillimeter(2), 2.KilogramsPerHourPerSquareMillimeter());
 
         [Fact]
         public void NumberToKilogramsPerSecondPerSquareCentimeterTest() =>
-            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareCentimeter(2), 2.KilogramsPerSecondPerSquareCentimeter());
+            Assert.Equal(MassFlux<double>.FromKilogramsPerSecondPerSquareCentimeter(2), 2.KilogramsPerSecondPerSquareCentimeter());
 
         [Fact]
         public void NumberToKilogramsPerSecondPerSquareMeterTest() =>
-            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(2), 2.KilogramsPerSecondPerSquareMeter());
+            Assert.Equal(MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2), 2.KilogramsPerSecondPerSquareMeter());
 
         [Fact]
         public void NumberToKilogramsPerSecondPerSquareMillimeterTest() =>
-            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMillimeter(2), 2.KilogramsPerSecondPerSquareMillimeter());
+            Assert.Equal(MassFlux<double>.FromKilogramsPerSecondPerSquareMillimeter(2), 2.KilogramsPerSecondPerSquareMillimeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs
index 30a444bb35..7e9d147a91 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs
@@ -21,104 +21,104 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMassFractionExtensionsTests
     {
         [Fact]
         public void NumberToCentigramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromCentigramsPerGram(2), 2.CentigramsPerGram());
+            Assert.Equal(MassFraction<double>.FromCentigramsPerGram(2), 2.CentigramsPerGram());
 
         [Fact]
         public void NumberToCentigramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromCentigramsPerKilogram(2), 2.CentigramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromCentigramsPerKilogram(2), 2.CentigramsPerKilogram());
 
         [Fact]
         public void NumberToDecagramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromDecagramsPerGram(2), 2.DecagramsPerGram());
+            Assert.Equal(MassFraction<double>.FromDecagramsPerGram(2), 2.DecagramsPerGram());
 
         [Fact]
         public void NumberToDecagramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromDecagramsPerKilogram(2), 2.DecagramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromDecagramsPerKilogram(2), 2.DecagramsPerKilogram());
 
         [Fact]
         public void NumberToDecigramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromDecigramsPerGram(2), 2.DecigramsPerGram());
+            Assert.Equal(MassFraction<double>.FromDecigramsPerGram(2), 2.DecigramsPerGram());
 
         [Fact]
         public void NumberToDecigramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromDecigramsPerKilogram(2), 2.DecigramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromDecigramsPerKilogram(2), 2.DecigramsPerKilogram());
 
         [Fact]
         public void NumberToDecimalFractionsTest() =>
-            Assert.Equal(MassFraction.FromDecimalFractions(2), 2.DecimalFractions());
+            Assert.Equal(MassFraction<double>.FromDecimalFractions(2), 2.DecimalFractions());
 
         [Fact]
         public void NumberToGramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromGramsPerGram(2), 2.GramsPerGram());
+            Assert.Equal(MassFraction<double>.FromGramsPerGram(2), 2.GramsPerGram());
 
         [Fact]
         public void NumberToGramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromGramsPerKilogram(2), 2.GramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromGramsPerKilogram(2), 2.GramsPerKilogram());
 
         [Fact]
         public void NumberToHectogramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromHectogramsPerGram(2), 2.HectogramsPerGram());
+            Assert.Equal(MassFraction<double>.FromHectogramsPerGram(2), 2.HectogramsPerGram());
 
         [Fact]
         public void NumberToHectogramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromHectogramsPerKilogram(2), 2.HectogramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromHectogramsPerKilogram(2), 2.HectogramsPerKilogram());
 
         [Fact]
         public void NumberToKilogramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromKilogramsPerGram(2), 2.KilogramsPerGram());
+            Assert.Equal(MassFraction<double>.FromKilogramsPerGram(2), 2.KilogramsPerGram());
 
         [Fact]
         public void NumberToKilogramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromKilogramsPerKilogram(2), 2.KilogramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromKilogramsPerKilogram(2), 2.KilogramsPerKilogram());
 
         [Fact]
         public void NumberToMicrogramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromMicrogramsPerGram(2), 2.MicrogramsPerGram());
+            Assert.Equal(MassFraction<double>.FromMicrogramsPerGram(2), 2.MicrogramsPerGram());
 
         [Fact]
         public void NumberToMicrogramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromMicrogramsPerKilogram(2), 2.MicrogramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromMicrogramsPerKilogram(2), 2.MicrogramsPerKilogram());
 
         [Fact]
         public void NumberToMilligramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromMilligramsPerGram(2), 2.MilligramsPerGram());
+            Assert.Equal(MassFraction<double>.FromMilligramsPerGram(2), 2.MilligramsPerGram());
 
         [Fact]
         public void NumberToMilligramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromMilligramsPerKilogram(2), 2.MilligramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromMilligramsPerKilogram(2), 2.MilligramsPerKilogram());
 
         [Fact]
         public void NumberToNanogramsPerGramTest() =>
-            Assert.Equal(MassFraction.FromNanogramsPerGram(2), 2.NanogramsPerGram());
+            Assert.Equal(MassFraction<double>.FromNanogramsPerGram(2), 2.NanogramsPerGram());
 
         [Fact]
         public void NumberToNanogramsPerKilogramTest() =>
-            Assert.Equal(MassFraction.FromNanogramsPerKilogram(2), 2.NanogramsPerKilogram());
+            Assert.Equal(MassFraction<double>.FromNanogramsPerKilogram(2), 2.NanogramsPerKilogram());
 
         [Fact]
         public void NumberToPartsPerBillionTest() =>
-            Assert.Equal(MassFraction.FromPartsPerBillion(2), 2.PartsPerBillion());
+            Assert.Equal(MassFraction<double>.FromPartsPerBillion(2), 2.PartsPerBillion());
 
         [Fact]
         public void NumberToPartsPerMillionTest() =>
-            Assert.Equal(MassFraction.FromPartsPerMillion(2), 2.PartsPerMillion());
+            Assert.Equal(MassFraction<double>.FromPartsPerMillion(2), 2.PartsPerMillion());
 
         [Fact]
         public void NumberToPartsPerThousandTest() =>
-            Assert.Equal(MassFraction.FromPartsPerThousand(2), 2.PartsPerThousand());
+            Assert.Equal(MassFraction<double>.FromPartsPerThousand(2), 2.PartsPerThousand());
 
         [Fact]
         public void NumberToPartsPerTrillionTest() =>
-            Assert.Equal(MassFraction.FromPartsPerTrillion(2), 2.PartsPerTrillion());
+            Assert.Equal(MassFraction<double>.FromPartsPerTrillion(2), 2.PartsPerTrillion());
 
         [Fact]
         public void NumberToPercentTest() =>
-            Assert.Equal(MassFraction.FromPercent(2), 2.Percent());
+            Assert.Equal(MassFraction<double>.FromPercent(2), 2.Percent());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs
index 533cb88df1..99beeed2a5 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs
@@ -21,120 +21,120 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMassMomentOfInertiaExtensionsTests
     {
         [Fact]
         public void NumberToGramSquareCentimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromGramSquareCentimeters(2), 2.GramSquareCentimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromGramSquareCentimeters(2), 2.GramSquareCentimeters());
 
         [Fact]
         public void NumberToGramSquareDecimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromGramSquareDecimeters(2), 2.GramSquareDecimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromGramSquareDecimeters(2), 2.GramSquareDecimeters());
 
         [Fact]
         public void NumberToGramSquareMetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromGramSquareMeters(2), 2.GramSquareMeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromGramSquareMeters(2), 2.GramSquareMeters());
 
         [Fact]
         public void NumberToGramSquareMillimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromGramSquareMillimeters(2), 2.GramSquareMillimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromGramSquareMillimeters(2), 2.GramSquareMillimeters());
 
         [Fact]
         public void NumberToKilogramSquareCentimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilogramSquareCentimeters(2), 2.KilogramSquareCentimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilogramSquareCentimeters(2), 2.KilogramSquareCentimeters());
 
         [Fact]
         public void NumberToKilogramSquareDecimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilogramSquareDecimeters(2), 2.KilogramSquareDecimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilogramSquareDecimeters(2), 2.KilogramSquareDecimeters());
 
         [Fact]
         public void NumberToKilogramSquareMetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilogramSquareMeters(2), 2.KilogramSquareMeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilogramSquareMeters(2), 2.KilogramSquareMeters());
 
         [Fact]
         public void NumberToKilogramSquareMillimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilogramSquareMillimeters(2), 2.KilogramSquareMillimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilogramSquareMillimeters(2), 2.KilogramSquareMillimeters());
 
         [Fact]
         public void NumberToKilotonneSquareCentimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareCentimeters(2), 2.KilotonneSquareCentimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilotonneSquareCentimeters(2), 2.KilotonneSquareCentimeters());
 
         [Fact]
         public void NumberToKilotonneSquareDecimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareDecimeters(2), 2.KilotonneSquareDecimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilotonneSquareDecimeters(2), 2.KilotonneSquareDecimeters());
 
         [Fact]
         public void NumberToKilotonneSquareMetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareMeters(2), 2.KilotonneSquareMeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilotonneSquareMeters(2), 2.KilotonneSquareMeters());
 
         [Fact]
         public void NumberToKilotonneSquareMilimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareMilimeters(2), 2.KilotonneSquareMilimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromKilotonneSquareMilimeters(2), 2.KilotonneSquareMilimeters());
 
         [Fact]
         public void NumberToMegatonneSquareCentimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareCentimeters(2), 2.MegatonneSquareCentimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMegatonneSquareCentimeters(2), 2.MegatonneSquareCentimeters());
 
         [Fact]
         public void NumberToMegatonneSquareDecimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareDecimeters(2), 2.MegatonneSquareDecimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMegatonneSquareDecimeters(2), 2.MegatonneSquareDecimeters());
 
         [Fact]
         public void NumberToMegatonneSquareMetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareMeters(2), 2.MegatonneSquareMeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMegatonneSquareMeters(2), 2.MegatonneSquareMeters());
 
         [Fact]
         public void NumberToMegatonneSquareMilimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareMilimeters(2), 2.MegatonneSquareMilimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMegatonneSquareMilimeters(2), 2.MegatonneSquareMilimeters());
 
         [Fact]
         public void NumberToMilligramSquareCentimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMilligramSquareCentimeters(2), 2.MilligramSquareCentimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMilligramSquareCentimeters(2), 2.MilligramSquareCentimeters());
 
         [Fact]
         public void NumberToMilligramSquareDecimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMilligramSquareDecimeters(2), 2.MilligramSquareDecimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMilligramSquareDecimeters(2), 2.MilligramSquareDecimeters());
 
         [Fact]
         public void NumberToMilligramSquareMetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMilligramSquareMeters(2), 2.MilligramSquareMeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMilligramSquareMeters(2), 2.MilligramSquareMeters());
 
         [Fact]
         public void NumberToMilligramSquareMillimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromMilligramSquareMillimeters(2), 2.MilligramSquareMillimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromMilligramSquareMillimeters(2), 2.MilligramSquareMillimeters());
 
         [Fact]
         public void NumberToPoundSquareFeetTest() =>
-            Assert.Equal(MassMomentOfInertia.FromPoundSquareFeet(2), 2.PoundSquareFeet());
+            Assert.Equal(MassMomentOfInertia<double>.FromPoundSquareFeet(2), 2.PoundSquareFeet());
 
         [Fact]
         public void NumberToPoundSquareInchesTest() =>
-            Assert.Equal(MassMomentOfInertia.FromPoundSquareInches(2), 2.PoundSquareInches());
+            Assert.Equal(MassMomentOfInertia<double>.FromPoundSquareInches(2), 2.PoundSquareInches());
 
         [Fact]
         public void NumberToSlugSquareFeetTest() =>
-            Assert.Equal(MassMomentOfInertia.FromSlugSquareFeet(2), 2.SlugSquareFeet());
+            Assert.Equal(MassMomentOfInertia<double>.FromSlugSquareFeet(2), 2.SlugSquareFeet());
 
         [Fact]
         public void NumberToSlugSquareInchesTest() =>
-            Assert.Equal(MassMomentOfInertia.FromSlugSquareInches(2), 2.SlugSquareInches());
+            Assert.Equal(MassMomentOfInertia<double>.FromSlugSquareInches(2), 2.SlugSquareInches());
 
         [Fact]
         public void NumberToTonneSquareCentimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromTonneSquareCentimeters(2), 2.TonneSquareCentimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromTonneSquareCentimeters(2), 2.TonneSquareCentimeters());
 
         [Fact]
         public void NumberToTonneSquareDecimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromTonneSquareDecimeters(2), 2.TonneSquareDecimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromTonneSquareDecimeters(2), 2.TonneSquareDecimeters());
 
         [Fact]
         public void NumberToTonneSquareMetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromTonneSquareMeters(2), 2.TonneSquareMeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromTonneSquareMeters(2), 2.TonneSquareMeters());
 
         [Fact]
         public void NumberToTonneSquareMilimetersTest() =>
-            Assert.Equal(MassMomentOfInertia.FromTonneSquareMilimeters(2), 2.TonneSquareMilimeters());
+            Assert.Equal(MassMomentOfInertia<double>.FromTonneSquareMilimeters(2), 2.TonneSquareMilimeters());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs
index 888625a0aa..64a5dd5f03 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMolarEnergyExtensionsTests
     {
         [Fact]
         public void NumberToJoulesPerMoleTest() =>
-            Assert.Equal(MolarEnergy.FromJoulesPerMole(2), 2.JoulesPerMole());
+            Assert.Equal(MolarEnergy<double>.FromJoulesPerMole(2), 2.JoulesPerMole());
 
         [Fact]
         public void NumberToKilojoulesPerMoleTest() =>
-            Assert.Equal(MolarEnergy.FromKilojoulesPerMole(2), 2.KilojoulesPerMole());
+            Assert.Equal(MolarEnergy<double>.FromKilojoulesPerMole(2), 2.KilojoulesPerMole());
 
         [Fact]
         public void NumberToMegajoulesPerMoleTest() =>
-            Assert.Equal(MolarEnergy.FromMegajoulesPerMole(2), 2.MegajoulesPerMole());
+            Assert.Equal(MolarEnergy<double>.FromMegajoulesPerMole(2), 2.MegajoulesPerMole());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs
index c38670149e..86dea9633f 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMolarEntropyExtensionsTests
     {
         [Fact]
         public void NumberToJoulesPerMoleKelvinTest() =>
-            Assert.Equal(MolarEntropy.FromJoulesPerMoleKelvin(2), 2.JoulesPerMoleKelvin());
+            Assert.Equal(MolarEntropy<double>.FromJoulesPerMoleKelvin(2), 2.JoulesPerMoleKelvin());
 
         [Fact]
         public void NumberToKilojoulesPerMoleKelvinTest() =>
-            Assert.Equal(MolarEntropy.FromKilojoulesPerMoleKelvin(2), 2.KilojoulesPerMoleKelvin());
+            Assert.Equal(MolarEntropy<double>.FromKilojoulesPerMoleKelvin(2), 2.KilojoulesPerMoleKelvin());
 
         [Fact]
         public void NumberToMegajoulesPerMoleKelvinTest() =>
-            Assert.Equal(MolarEntropy.FromMegajoulesPerMoleKelvin(2), 2.MegajoulesPerMoleKelvin());
+            Assert.Equal(MolarEntropy<double>.FromMegajoulesPerMoleKelvin(2), 2.MegajoulesPerMoleKelvin());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
index 435f467260..1d572ed114 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
@@ -21,56 +21,56 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMolarMassExtensionsTests
     {
         [Fact]
         public void NumberToCentigramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromCentigramsPerMole(2), 2.CentigramsPerMole());
+            Assert.Equal(MolarMass<double>.FromCentigramsPerMole(2), 2.CentigramsPerMole());
 
         [Fact]
         public void NumberToDecagramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromDecagramsPerMole(2), 2.DecagramsPerMole());
+            Assert.Equal(MolarMass<double>.FromDecagramsPerMole(2), 2.DecagramsPerMole());
 
         [Fact]
         public void NumberToDecigramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromDecigramsPerMole(2), 2.DecigramsPerMole());
+            Assert.Equal(MolarMass<double>.FromDecigramsPerMole(2), 2.DecigramsPerMole());
 
         [Fact]
         public void NumberToGramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromGramsPerMole(2), 2.GramsPerMole());
+            Assert.Equal(MolarMass<double>.FromGramsPerMole(2), 2.GramsPerMole());
 
         [Fact]
         public void NumberToHectogramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromHectogramsPerMole(2), 2.HectogramsPerMole());
+            Assert.Equal(MolarMass<double>.FromHectogramsPerMole(2), 2.HectogramsPerMole());
 
         [Fact]
         public void NumberToKilogramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromKilogramsPerMole(2), 2.KilogramsPerMole());
+            Assert.Equal(MolarMass<double>.FromKilogramsPerMole(2), 2.KilogramsPerMole());
 
         [Fact]
         public void NumberToKilopoundsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromKilopoundsPerMole(2), 2.KilopoundsPerMole());
+            Assert.Equal(MolarMass<double>.FromKilopoundsPerMole(2), 2.KilopoundsPerMole());
 
         [Fact]
         public void NumberToMegapoundsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromMegapoundsPerMole(2), 2.MegapoundsPerMole());
+            Assert.Equal(MolarMass<double>.FromMegapoundsPerMole(2), 2.MegapoundsPerMole());
 
         [Fact]
         public void NumberToMicrogramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromMicrogramsPerMole(2), 2.MicrogramsPerMole());
+            Assert.Equal(MolarMass<double>.FromMicrogramsPerMole(2), 2.MicrogramsPerMole());
 
         [Fact]
         public void NumberToMilligramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromMilligramsPerMole(2), 2.MilligramsPerMole());
+            Assert.Equal(MolarMass<double>.FromMilligramsPerMole(2), 2.MilligramsPerMole());
 
         [Fact]
         public void NumberToNanogramsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromNanogramsPerMole(2), 2.NanogramsPerMole());
+            Assert.Equal(MolarMass<double>.FromNanogramsPerMole(2), 2.NanogramsPerMole());
 
         [Fact]
         public void NumberToPoundsPerMoleTest() =>
-            Assert.Equal(MolarMass.FromPoundsPerMole(2), 2.PoundsPerMole());
+            Assert.Equal(MolarMass<double>.FromPoundsPerMole(2), 2.PoundsPerMole());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs
index 6e77305d5d..bc7540d82b 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs
@@ -21,40 +21,40 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToMolarityExtensionsTests
     {
         [Fact]
         public void NumberToCentimolesPerLiterTest() =>
-            Assert.Equal(Molarity.FromCentimolesPerLiter(2), 2.CentimolesPerLiter());
+            Assert.Equal(Molarity<double>.FromCentimolesPerLiter(2), 2.CentimolesPerLiter());
 
         [Fact]
         public void NumberToDecimolesPerLiterTest() =>
-            Assert.Equal(Molarity.FromDecimolesPerLiter(2), 2.DecimolesPerLiter());
+            Assert.Equal(Molarity<double>.FromDecimolesPerLiter(2), 2.DecimolesPerLiter());
 
         [Fact]
         public void NumberToMicromolesPerLiterTest() =>
-            Assert.Equal(Molarity.FromMicromolesPerLiter(2), 2.MicromolesPerLiter());
+            Assert.Equal(Molarity<double>.FromMicromolesPerLiter(2), 2.MicromolesPerLiter());
 
         [Fact]
         public void NumberToMillimolesPerLiterTest() =>
-            Assert.Equal(Molarity.FromMillimolesPerLiter(2), 2.MillimolesPerLiter());
+            Assert.Equal(Molarity<double>.FromMillimolesPerLiter(2), 2.MillimolesPerLiter());
 
         [Fact]
         public void NumberToMolesPerCubicMeterTest() =>
-            Assert.Equal(Molarity.FromMolesPerCubicMeter(2), 2.MolesPerCubicMeter());
+            Assert.Equal(Molarity<double>.FromMolesPerCubicMeter(2), 2.MolesPerCubicMeter());
 
         [Fact]
         public void NumberToMolesPerLiterTest() =>
-            Assert.Equal(Molarity.FromMolesPerLiter(2), 2.MolesPerLiter());
+            Assert.Equal(Molarity<double>.FromMolesPerLiter(2), 2.MolesPerLiter());
 
         [Fact]
         public void NumberToNanomolesPerLiterTest() =>
-            Assert.Equal(Molarity.FromNanomolesPerLiter(2), 2.NanomolesPerLiter());
+            Assert.Equal(Molarity<double>.FromNanomolesPerLiter(2), 2.NanomolesPerLiter());
 
         [Fact]
         public void NumberToPicomolesPerLiterTest() =>
-            Assert.Equal(Molarity.FromPicomolesPerLiter(2), 2.PicomolesPerLiter());
+            Assert.Equal(Molarity<double>.FromPicomolesPerLiter(2), 2.PicomolesPerLiter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs
index adcc4a1ec7..3f99ce0971 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToPermeabilityExtensionsTests
     {
         [Fact]
         public void NumberToHenriesPerMeterTest() =>
-            Assert.Equal(Permeability.FromHenriesPerMeter(2), 2.HenriesPerMeter());
+            Assert.Equal(Permeability<double>.FromHenriesPerMeter(2), 2.HenriesPerMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs
index 7dbc097268..de253de1f7 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToPermittivityExtensionsTests
     {
         [Fact]
         public void NumberToFaradsPerMeterTest() =>
-            Assert.Equal(Permittivity.FromFaradsPerMeter(2), 2.FaradsPerMeter());
+            Assert.Equal(Permittivity<double>.FromFaradsPerMeter(2), 2.FaradsPerMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
index 44a77db4e3..8b8a308ed8 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
@@ -21,184 +21,184 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToPowerDensityExtensionsTests
     {
         [Fact]
         public void NumberToDecawattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromDecawattsPerCubicFoot(2), 2.DecawattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromDecawattsPerCubicFoot(2), 2.DecawattsPerCubicFoot());
 
         [Fact]
         public void NumberToDecawattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromDecawattsPerCubicInch(2), 2.DecawattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromDecawattsPerCubicInch(2), 2.DecawattsPerCubicInch());
 
         [Fact]
         public void NumberToDecawattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromDecawattsPerCubicMeter(2), 2.DecawattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromDecawattsPerCubicMeter(2), 2.DecawattsPerCubicMeter());
 
         [Fact]
         public void NumberToDecawattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromDecawattsPerLiter(2), 2.DecawattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromDecawattsPerLiter(2), 2.DecawattsPerLiter());
 
         [Fact]
         public void NumberToDeciwattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromDeciwattsPerCubicFoot(2), 2.DeciwattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromDeciwattsPerCubicFoot(2), 2.DeciwattsPerCubicFoot());
 
         [Fact]
         public void NumberToDeciwattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromDeciwattsPerCubicInch(2), 2.DeciwattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromDeciwattsPerCubicInch(2), 2.DeciwattsPerCubicInch());
 
         [Fact]
         public void NumberToDeciwattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromDeciwattsPerCubicMeter(2), 2.DeciwattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromDeciwattsPerCubicMeter(2), 2.DeciwattsPerCubicMeter());
 
         [Fact]
         public void NumberToDeciwattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromDeciwattsPerLiter(2), 2.DeciwattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromDeciwattsPerLiter(2), 2.DeciwattsPerLiter());
 
         [Fact]
         public void NumberToGigawattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromGigawattsPerCubicFoot(2), 2.GigawattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromGigawattsPerCubicFoot(2), 2.GigawattsPerCubicFoot());
 
         [Fact]
         public void NumberToGigawattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromGigawattsPerCubicInch(2), 2.GigawattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromGigawattsPerCubicInch(2), 2.GigawattsPerCubicInch());
 
         [Fact]
         public void NumberToGigawattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromGigawattsPerCubicMeter(2), 2.GigawattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromGigawattsPerCubicMeter(2), 2.GigawattsPerCubicMeter());
 
         [Fact]
         public void NumberToGigawattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromGigawattsPerLiter(2), 2.GigawattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromGigawattsPerLiter(2), 2.GigawattsPerLiter());
 
         [Fact]
         public void NumberToKilowattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromKilowattsPerCubicFoot(2), 2.KilowattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromKilowattsPerCubicFoot(2), 2.KilowattsPerCubicFoot());
 
         [Fact]
         public void NumberToKilowattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromKilowattsPerCubicInch(2), 2.KilowattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromKilowattsPerCubicInch(2), 2.KilowattsPerCubicInch());
 
         [Fact]
         public void NumberToKilowattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromKilowattsPerCubicMeter(2), 2.KilowattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromKilowattsPerCubicMeter(2), 2.KilowattsPerCubicMeter());
 
         [Fact]
         public void NumberToKilowattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromKilowattsPerLiter(2), 2.KilowattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromKilowattsPerLiter(2), 2.KilowattsPerLiter());
 
         [Fact]
         public void NumberToMegawattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromMegawattsPerCubicFoot(2), 2.MegawattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromMegawattsPerCubicFoot(2), 2.MegawattsPerCubicFoot());
 
         [Fact]
         public void NumberToMegawattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromMegawattsPerCubicInch(2), 2.MegawattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromMegawattsPerCubicInch(2), 2.MegawattsPerCubicInch());
 
         [Fact]
         public void NumberToMegawattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromMegawattsPerCubicMeter(2), 2.MegawattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromMegawattsPerCubicMeter(2), 2.MegawattsPerCubicMeter());
 
         [Fact]
         public void NumberToMegawattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromMegawattsPerLiter(2), 2.MegawattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromMegawattsPerLiter(2), 2.MegawattsPerLiter());
 
         [Fact]
         public void NumberToMicrowattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromMicrowattsPerCubicFoot(2), 2.MicrowattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromMicrowattsPerCubicFoot(2), 2.MicrowattsPerCubicFoot());
 
         [Fact]
         public void NumberToMicrowattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromMicrowattsPerCubicInch(2), 2.MicrowattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromMicrowattsPerCubicInch(2), 2.MicrowattsPerCubicInch());
 
         [Fact]
         public void NumberToMicrowattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromMicrowattsPerCubicMeter(2), 2.MicrowattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromMicrowattsPerCubicMeter(2), 2.MicrowattsPerCubicMeter());
 
         [Fact]
         public void NumberToMicrowattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromMicrowattsPerLiter(2), 2.MicrowattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromMicrowattsPerLiter(2), 2.MicrowattsPerLiter());
 
         [Fact]
         public void NumberToMilliwattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromMilliwattsPerCubicFoot(2), 2.MilliwattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromMilliwattsPerCubicFoot(2), 2.MilliwattsPerCubicFoot());
 
         [Fact]
         public void NumberToMilliwattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromMilliwattsPerCubicInch(2), 2.MilliwattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromMilliwattsPerCubicInch(2), 2.MilliwattsPerCubicInch());
 
         [Fact]
         public void NumberToMilliwattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromMilliwattsPerCubicMeter(2), 2.MilliwattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromMilliwattsPerCubicMeter(2), 2.MilliwattsPerCubicMeter());
 
         [Fact]
         public void NumberToMilliwattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromMilliwattsPerLiter(2), 2.MilliwattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromMilliwattsPerLiter(2), 2.MilliwattsPerLiter());
 
         [Fact]
         public void NumberToNanowattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromNanowattsPerCubicFoot(2), 2.NanowattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromNanowattsPerCubicFoot(2), 2.NanowattsPerCubicFoot());
 
         [Fact]
         public void NumberToNanowattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromNanowattsPerCubicInch(2), 2.NanowattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromNanowattsPerCubicInch(2), 2.NanowattsPerCubicInch());
 
         [Fact]
         public void NumberToNanowattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromNanowattsPerCubicMeter(2), 2.NanowattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromNanowattsPerCubicMeter(2), 2.NanowattsPerCubicMeter());
 
         [Fact]
         public void NumberToNanowattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromNanowattsPerLiter(2), 2.NanowattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromNanowattsPerLiter(2), 2.NanowattsPerLiter());
 
         [Fact]
         public void NumberToPicowattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromPicowattsPerCubicFoot(2), 2.PicowattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromPicowattsPerCubicFoot(2), 2.PicowattsPerCubicFoot());
 
         [Fact]
         public void NumberToPicowattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromPicowattsPerCubicInch(2), 2.PicowattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromPicowattsPerCubicInch(2), 2.PicowattsPerCubicInch());
 
         [Fact]
         public void NumberToPicowattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromPicowattsPerCubicMeter(2), 2.PicowattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromPicowattsPerCubicMeter(2), 2.PicowattsPerCubicMeter());
 
         [Fact]
         public void NumberToPicowattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromPicowattsPerLiter(2), 2.PicowattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromPicowattsPerLiter(2), 2.PicowattsPerLiter());
 
         [Fact]
         public void NumberToTerawattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromTerawattsPerCubicFoot(2), 2.TerawattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromTerawattsPerCubicFoot(2), 2.TerawattsPerCubicFoot());
 
         [Fact]
         public void NumberToTerawattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromTerawattsPerCubicInch(2), 2.TerawattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromTerawattsPerCubicInch(2), 2.TerawattsPerCubicInch());
 
         [Fact]
         public void NumberToTerawattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromTerawattsPerCubicMeter(2), 2.TerawattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromTerawattsPerCubicMeter(2), 2.TerawattsPerCubicMeter());
 
         [Fact]
         public void NumberToTerawattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromTerawattsPerLiter(2), 2.TerawattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromTerawattsPerLiter(2), 2.TerawattsPerLiter());
 
         [Fact]
         public void NumberToWattsPerCubicFootTest() =>
-            Assert.Equal(PowerDensity.FromWattsPerCubicFoot(2), 2.WattsPerCubicFoot());
+            Assert.Equal(PowerDensity<double>.FromWattsPerCubicFoot(2), 2.WattsPerCubicFoot());
 
         [Fact]
         public void NumberToWattsPerCubicInchTest() =>
-            Assert.Equal(PowerDensity.FromWattsPerCubicInch(2), 2.WattsPerCubicInch());
+            Assert.Equal(PowerDensity<double>.FromWattsPerCubicInch(2), 2.WattsPerCubicInch());
 
         [Fact]
         public void NumberToWattsPerCubicMeterTest() =>
-            Assert.Equal(PowerDensity.FromWattsPerCubicMeter(2), 2.WattsPerCubicMeter());
+            Assert.Equal(PowerDensity<double>.FromWattsPerCubicMeter(2), 2.WattsPerCubicMeter());
 
         [Fact]
         public void NumberToWattsPerLiterTest() =>
-            Assert.Equal(PowerDensity.FromWattsPerLiter(2), 2.WattsPerLiter());
+            Assert.Equal(PowerDensity<double>.FromWattsPerLiter(2), 2.WattsPerLiter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs
index a9cf5b5f94..6fc25b4b36 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs
@@ -21,108 +21,108 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToPowerExtensionsTests
     {
         [Fact]
         public void NumberToBoilerHorsepowerTest() =>
-            Assert.Equal(Power.FromBoilerHorsepower(2), 2.BoilerHorsepower());
+            Assert.Equal(Power<double>.FromBoilerHorsepower(2), 2.BoilerHorsepower());
 
         [Fact]
         public void NumberToBritishThermalUnitsPerHourTest() =>
-            Assert.Equal(Power.FromBritishThermalUnitsPerHour(2), 2.BritishThermalUnitsPerHour());
+            Assert.Equal(Power<double>.FromBritishThermalUnitsPerHour(2), 2.BritishThermalUnitsPerHour());
 
         [Fact]
         public void NumberToDecawattsTest() =>
-            Assert.Equal(Power.FromDecawatts(2), 2.Decawatts());
+            Assert.Equal(Power<double>.FromDecawatts(2), 2.Decawatts());
 
         [Fact]
         public void NumberToDeciwattsTest() =>
-            Assert.Equal(Power.FromDeciwatts(2), 2.Deciwatts());
+            Assert.Equal(Power<double>.FromDeciwatts(2), 2.Deciwatts());
 
         [Fact]
         public void NumberToElectricalHorsepowerTest() =>
-            Assert.Equal(Power.FromElectricalHorsepower(2), 2.ElectricalHorsepower());
+            Assert.Equal(Power<double>.FromElectricalHorsepower(2), 2.ElectricalHorsepower());
 
         [Fact]
         public void NumberToFemtowattsTest() =>
-            Assert.Equal(Power.FromFemtowatts(2), 2.Femtowatts());
+            Assert.Equal(Power<double>.FromFemtowatts(2), 2.Femtowatts());
 
         [Fact]
         public void NumberToGigajoulesPerHourTest() =>
-            Assert.Equal(Power.FromGigajoulesPerHour(2), 2.GigajoulesPerHour());
+            Assert.Equal(Power<double>.FromGigajoulesPerHour(2), 2.GigajoulesPerHour());
 
         [Fact]
         public void NumberToGigawattsTest() =>
-            Assert.Equal(Power.FromGigawatts(2), 2.Gigawatts());
+            Assert.Equal(Power<double>.FromGigawatts(2), 2.Gigawatts());
 
         [Fact]
         public void NumberToHydraulicHorsepowerTest() =>
-            Assert.Equal(Power.FromHydraulicHorsepower(2), 2.HydraulicHorsepower());
+            Assert.Equal(Power<double>.FromHydraulicHorsepower(2), 2.HydraulicHorsepower());
 
         [Fact]
         public void NumberToJoulesPerHourTest() =>
-            Assert.Equal(Power.FromJoulesPerHour(2), 2.JoulesPerHour());
+            Assert.Equal(Power<double>.FromJoulesPerHour(2), 2.JoulesPerHour());
 
         [Fact]
         public void NumberToKilobritishThermalUnitsPerHourTest() =>
-            Assert.Equal(Power.FromKilobritishThermalUnitsPerHour(2), 2.KilobritishThermalUnitsPerHour());
+            Assert.Equal(Power<double>.FromKilobritishThermalUnitsPerHour(2), 2.KilobritishThermalUnitsPerHour());
 
         [Fact]
         public void NumberToKilojoulesPerHourTest() =>
-            Assert.Equal(Power.FromKilojoulesPerHour(2), 2.KilojoulesPerHour());
+            Assert.Equal(Power<double>.FromKilojoulesPerHour(2), 2.KilojoulesPerHour());
 
         [Fact]
         public void NumberToKilowattsTest() =>
-            Assert.Equal(Power.FromKilowatts(2), 2.Kilowatts());
+            Assert.Equal(Power<double>.FromKilowatts(2), 2.Kilowatts());
 
         [Fact]
         public void NumberToMechanicalHorsepowerTest() =>
-            Assert.Equal(Power.FromMechanicalHorsepower(2), 2.MechanicalHorsepower());
+            Assert.Equal(Power<double>.FromMechanicalHorsepower(2), 2.MechanicalHorsepower());
 
         [Fact]
         public void NumberToMegajoulesPerHourTest() =>
-            Assert.Equal(Power.FromMegajoulesPerHour(2), 2.MegajoulesPerHour());
+            Assert.Equal(Power<double>.FromMegajoulesPerHour(2), 2.MegajoulesPerHour());
 
         [Fact]
         public void NumberToMegawattsTest() =>
-            Assert.Equal(Power.FromMegawatts(2), 2.Megawatts());
+            Assert.Equal(Power<double>.FromMegawatts(2), 2.Megawatts());
 
         [Fact]
         public void NumberToMetricHorsepowerTest() =>
-            Assert.Equal(Power.FromMetricHorsepower(2), 2.MetricHorsepower());
+            Assert.Equal(Power<double>.FromMetricHorsepower(2), 2.MetricHorsepower());
 
         [Fact]
         public void NumberToMicrowattsTest() =>
-            Assert.Equal(Power.FromMicrowatts(2), 2.Microwatts());
+            Assert.Equal(Power<double>.FromMicrowatts(2), 2.Microwatts());
 
         [Fact]
         public void NumberToMillijoulesPerHourTest() =>
-            Assert.Equal(Power.FromMillijoulesPerHour(2), 2.MillijoulesPerHour());
+            Assert.Equal(Power<double>.FromMillijoulesPerHour(2), 2.MillijoulesPerHour());
 
         [Fact]
         public void NumberToMilliwattsTest() =>
-            Assert.Equal(Power.FromMilliwatts(2), 2.Milliwatts());
+            Assert.Equal(Power<double>.FromMilliwatts(2), 2.Milliwatts());
 
         [Fact]
         public void NumberToNanowattsTest() =>
-            Assert.Equal(Power.FromNanowatts(2), 2.Nanowatts());
+            Assert.Equal(Power<double>.FromNanowatts(2), 2.Nanowatts());
 
         [Fact]
         public void NumberToPetawattsTest() =>
-            Assert.Equal(Power.FromPetawatts(2), 2.Petawatts());
+            Assert.Equal(Power<double>.FromPetawatts(2), 2.Petawatts());
 
         [Fact]
         public void NumberToPicowattsTest() =>
-            Assert.Equal(Power.FromPicowatts(2), 2.Picowatts());
+            Assert.Equal(Power<double>.FromPicowatts(2), 2.Picowatts());
 
         [Fact]
         public void NumberToTerawattsTest() =>
-            Assert.Equal(Power.FromTerawatts(2), 2.Terawatts());
+            Assert.Equal(Power<double>.FromTerawatts(2), 2.Terawatts());
 
         [Fact]
         public void NumberToWattsTest() =>
-            Assert.Equal(Power.FromWatts(2), 2.Watts());
+            Assert.Equal(Power<double>.FromWatts(2), 2.Watts());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs
index f9cb9ce23d..394d3d139d 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs
@@ -21,16 +21,16 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToPowerRatioExtensionsTests
     {
         [Fact]
         public void NumberToDecibelMilliwattsTest() =>
-            Assert.Equal(PowerRatio.FromDecibelMilliwatts(2), 2.DecibelMilliwatts());
+            Assert.Equal(PowerRatio<double>.FromDecibelMilliwatts(2), 2.DecibelMilliwatts());
 
         [Fact]
         public void NumberToDecibelWattsTest() =>
-            Assert.Equal(PowerRatio.FromDecibelWatts(2), 2.DecibelWatts());
+            Assert.Equal(PowerRatio<double>.FromDecibelWatts(2), 2.DecibelWatts());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs
index 5187b44395..c0d1a3db15 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs
@@ -21,36 +21,36 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToPressureChangeRateExtensionsTests
     {
         [Fact]
         public void NumberToAtmospheresPerSecondTest() =>
-            Assert.Equal(PressureChangeRate.FromAtmospheresPerSecond(2), 2.AtmospheresPerSecond());
+            Assert.Equal(PressureChangeRate<double>.FromAtmospheresPerSecond(2), 2.AtmospheresPerSecond());
 
         [Fact]
         public void NumberToKilopascalsPerMinuteTest() =>
-            Assert.Equal(PressureChangeRate.FromKilopascalsPerMinute(2), 2.KilopascalsPerMinute());
+            Assert.Equal(PressureChangeRate<double>.FromKilopascalsPerMinute(2), 2.KilopascalsPerMinute());
 
         [Fact]
         public void NumberToKilopascalsPerSecondTest() =>
-            Assert.Equal(PressureChangeRate.FromKilopascalsPerSecond(2), 2.KilopascalsPerSecond());
+            Assert.Equal(PressureChangeRate<double>.FromKilopascalsPerSecond(2), 2.KilopascalsPerSecond());
 
         [Fact]
         public void NumberToMegapascalsPerMinuteTest() =>
-            Assert.Equal(PressureChangeRate.FromMegapascalsPerMinute(2), 2.MegapascalsPerMinute());
+            Assert.Equal(PressureChangeRate<double>.FromMegapascalsPerMinute(2), 2.MegapascalsPerMinute());
 
         [Fact]
         public void NumberToMegapascalsPerSecondTest() =>
-            Assert.Equal(PressureChangeRate.FromMegapascalsPerSecond(2), 2.MegapascalsPerSecond());
+            Assert.Equal(PressureChangeRate<double>.FromMegapascalsPerSecond(2), 2.MegapascalsPerSecond());
 
         [Fact]
         public void NumberToPascalsPerMinuteTest() =>
-            Assert.Equal(PressureChangeRate.FromPascalsPerMinute(2), 2.PascalsPerMinute());
+            Assert.Equal(PressureChangeRate<double>.FromPascalsPerMinute(2), 2.PascalsPerMinute());
 
         [Fact]
         public void NumberToPascalsPerSecondTest() =>
-            Assert.Equal(PressureChangeRate.FromPascalsPerSecond(2), 2.PascalsPerSecond());
+            Assert.Equal(PressureChangeRate<double>.FromPascalsPerSecond(2), 2.PascalsPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
index 5995faa37c..a8c0b5e364 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
@@ -21,176 +21,176 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToPressureExtensionsTests
     {
         [Fact]
         public void NumberToAtmospheresTest() =>
-            Assert.Equal(Pressure.FromAtmospheres(2), 2.Atmospheres());
+            Assert.Equal(Pressure<double>.FromAtmospheres(2), 2.Atmospheres());
 
         [Fact]
         public void NumberToBarsTest() =>
-            Assert.Equal(Pressure.FromBars(2), 2.Bars());
+            Assert.Equal(Pressure<double>.FromBars(2), 2.Bars());
 
         [Fact]
         public void NumberToCentibarsTest() =>
-            Assert.Equal(Pressure.FromCentibars(2), 2.Centibars());
+            Assert.Equal(Pressure<double>.FromCentibars(2), 2.Centibars());
 
         [Fact]
         public void NumberToDecapascalsTest() =>
-            Assert.Equal(Pressure.FromDecapascals(2), 2.Decapascals());
+            Assert.Equal(Pressure<double>.FromDecapascals(2), 2.Decapascals());
 
         [Fact]
         public void NumberToDecibarsTest() =>
-            Assert.Equal(Pressure.FromDecibars(2), 2.Decibars());
+            Assert.Equal(Pressure<double>.FromDecibars(2), 2.Decibars());
 
         [Fact]
         public void NumberToDynesPerSquareCentimeterTest() =>
-            Assert.Equal(Pressure.FromDynesPerSquareCentimeter(2), 2.DynesPerSquareCentimeter());
+            Assert.Equal(Pressure<double>.FromDynesPerSquareCentimeter(2), 2.DynesPerSquareCentimeter());
 
         [Fact]
         public void NumberToFeetOfHeadTest() =>
-            Assert.Equal(Pressure.FromFeetOfHead(2), 2.FeetOfHead());
+            Assert.Equal(Pressure<double>.FromFeetOfHead(2), 2.FeetOfHead());
 
         [Fact]
         public void NumberToGigapascalsTest() =>
-            Assert.Equal(Pressure.FromGigapascals(2), 2.Gigapascals());
+            Assert.Equal(Pressure<double>.FromGigapascals(2), 2.Gigapascals());
 
         [Fact]
         public void NumberToHectopascalsTest() =>
-            Assert.Equal(Pressure.FromHectopascals(2), 2.Hectopascals());
+            Assert.Equal(Pressure<double>.FromHectopascals(2), 2.Hectopascals());
 
         [Fact]
         public void NumberToInchesOfMercuryTest() =>
-            Assert.Equal(Pressure.FromInchesOfMercury(2), 2.InchesOfMercury());
+            Assert.Equal(Pressure<double>.FromInchesOfMercury(2), 2.InchesOfMercury());
 
         [Fact]
         public void NumberToInchesOfWaterColumnTest() =>
-            Assert.Equal(Pressure.FromInchesOfWaterColumn(2), 2.InchesOfWaterColumn());
+            Assert.Equal(Pressure<double>.FromInchesOfWaterColumn(2), 2.InchesOfWaterColumn());
 
         [Fact]
         public void NumberToKilobarsTest() =>
-            Assert.Equal(Pressure.FromKilobars(2), 2.Kilobars());
+            Assert.Equal(Pressure<double>.FromKilobars(2), 2.Kilobars());
 
         [Fact]
         public void NumberToKilogramsForcePerSquareCentimeterTest() =>
-            Assert.Equal(Pressure.FromKilogramsForcePerSquareCentimeter(2), 2.KilogramsForcePerSquareCentimeter());
+            Assert.Equal(Pressure<double>.FromKilogramsForcePerSquareCentimeter(2), 2.KilogramsForcePerSquareCentimeter());
 
         [Fact]
         public void NumberToKilogramsForcePerSquareMeterTest() =>
-            Assert.Equal(Pressure.FromKilogramsForcePerSquareMeter(2), 2.KilogramsForcePerSquareMeter());
+            Assert.Equal(Pressure<double>.FromKilogramsForcePerSquareMeter(2), 2.KilogramsForcePerSquareMeter());
 
         [Fact]
         public void NumberToKilogramsForcePerSquareMillimeterTest() =>
-            Assert.Equal(Pressure.FromKilogramsForcePerSquareMillimeter(2), 2.KilogramsForcePerSquareMillimeter());
+            Assert.Equal(Pressure<double>.FromKilogramsForcePerSquareMillimeter(2), 2.KilogramsForcePerSquareMillimeter());
 
         [Fact]
         public void NumberToKilonewtonsPerSquareCentimeterTest() =>
-            Assert.Equal(Pressure.FromKilonewtonsPerSquareCentimeter(2), 2.KilonewtonsPerSquareCentimeter());
+            Assert.Equal(Pressure<double>.FromKilonewtonsPerSquareCentimeter(2), 2.KilonewtonsPerSquareCentimeter());
 
         [Fact]
         public void NumberToKilonewtonsPerSquareMeterTest() =>
-            Assert.Equal(Pressure.FromKilonewtonsPerSquareMeter(2), 2.KilonewtonsPerSquareMeter());
+            Assert.Equal(Pressure<double>.FromKilonewtonsPerSquareMeter(2), 2.KilonewtonsPerSquareMeter());
 
         [Fact]
         public void NumberToKilonewtonsPerSquareMillimeterTest() =>
-            Assert.Equal(Pressure.FromKilonewtonsPerSquareMillimeter(2), 2.KilonewtonsPerSquareMillimeter());
+            Assert.Equal(Pressure<double>.FromKilonewtonsPerSquareMillimeter(2), 2.KilonewtonsPerSquareMillimeter());
 
         [Fact]
         public void NumberToKilopascalsTest() =>
-            Assert.Equal(Pressure.FromKilopascals(2), 2.Kilopascals());
+            Assert.Equal(Pressure<double>.FromKilopascals(2), 2.Kilopascals());
 
         [Fact]
         public void NumberToKilopoundsForcePerSquareFootTest() =>
-            Assert.Equal(Pressure.FromKilopoundsForcePerSquareFoot(2), 2.KilopoundsForcePerSquareFoot());
+            Assert.Equal(Pressure<double>.FromKilopoundsForcePerSquareFoot(2), 2.KilopoundsForcePerSquareFoot());
 
         [Fact]
         public void NumberToKilopoundsForcePerSquareInchTest() =>
-            Assert.Equal(Pressure.FromKilopoundsForcePerSquareInch(2), 2.KilopoundsForcePerSquareInch());
+            Assert.Equal(Pressure<double>.FromKilopoundsForcePerSquareInch(2), 2.KilopoundsForcePerSquareInch());
 
         [Fact]
         public void NumberToMegabarsTest() =>
-            Assert.Equal(Pressure.FromMegabars(2), 2.Megabars());
+            Assert.Equal(Pressure<double>.FromMegabars(2), 2.Megabars());
 
         [Fact]
         public void NumberToMeganewtonsPerSquareMeterTest() =>
-            Assert.Equal(Pressure.FromMeganewtonsPerSquareMeter(2), 2.MeganewtonsPerSquareMeter());
+            Assert.Equal(Pressure<double>.FromMeganewtonsPerSquareMeter(2), 2.MeganewtonsPerSquareMeter());
 
         [Fact]
         public void NumberToMegapascalsTest() =>
-            Assert.Equal(Pressure.FromMegapascals(2), 2.Megapascals());
+            Assert.Equal(Pressure<double>.FromMegapascals(2), 2.Megapascals());
 
         [Fact]
         public void NumberToMetersOfHeadTest() =>
-            Assert.Equal(Pressure.FromMetersOfHead(2), 2.MetersOfHead());
+            Assert.Equal(Pressure<double>.FromMetersOfHead(2), 2.MetersOfHead());
 
         [Fact]
         public void NumberToMicrobarsTest() =>
-            Assert.Equal(Pressure.FromMicrobars(2), 2.Microbars());
+            Assert.Equal(Pressure<double>.FromMicrobars(2), 2.Microbars());
 
         [Fact]
         public void NumberToMicropascalsTest() =>
-            Assert.Equal(Pressure.FromMicropascals(2), 2.Micropascals());
+            Assert.Equal(Pressure<double>.FromMicropascals(2), 2.Micropascals());
 
         [Fact]
         public void NumberToMillibarsTest() =>
-            Assert.Equal(Pressure.FromMillibars(2), 2.Millibars());
+            Assert.Equal(Pressure<double>.FromMillibars(2), 2.Millibars());
 
         [Fact]
         public void NumberToMillimetersOfMercuryTest() =>
-            Assert.Equal(Pressure.FromMillimetersOfMercury(2), 2.MillimetersOfMercury());
+            Assert.Equal(Pressure<double>.FromMillimetersOfMercury(2), 2.MillimetersOfMercury());
 
         [Fact]
         public void NumberToMillipascalsTest() =>
-            Assert.Equal(Pressure.FromMillipascals(2), 2.Millipascals());
+            Assert.Equal(Pressure<double>.FromMillipascals(2), 2.Millipascals());
 
         [Fact]
         public void NumberToNewtonsPerSquareCentimeterTest() =>
-            Assert.Equal(Pressure.FromNewtonsPerSquareCentimeter(2), 2.NewtonsPerSquareCentimeter());
+            Assert.Equal(Pressure<double>.FromNewtonsPerSquareCentimeter(2), 2.NewtonsPerSquareCentimeter());
 
         [Fact]
         public void NumberToNewtonsPerSquareMeterTest() =>
-            Assert.Equal(Pressure.FromNewtonsPerSquareMeter(2), 2.NewtonsPerSquareMeter());
+            Assert.Equal(Pressure<double>.FromNewtonsPerSquareMeter(2), 2.NewtonsPerSquareMeter());
 
         [Fact]
         public void NumberToNewtonsPerSquareMillimeterTest() =>
-            Assert.Equal(Pressure.FromNewtonsPerSquareMillimeter(2), 2.NewtonsPerSquareMillimeter());
+            Assert.Equal(Pressure<double>.FromNewtonsPerSquareMillimeter(2), 2.NewtonsPerSquareMillimeter());
 
         [Fact]
         public void NumberToPascalsTest() =>
-            Assert.Equal(Pressure.FromPascals(2), 2.Pascals());
+            Assert.Equal(Pressure<double>.FromPascals(2), 2.Pascals());
 
         [Fact]
         public void NumberToPoundsForcePerSquareFootTest() =>
-            Assert.Equal(Pressure.FromPoundsForcePerSquareFoot(2), 2.PoundsForcePerSquareFoot());
+            Assert.Equal(Pressure<double>.FromPoundsForcePerSquareFoot(2), 2.PoundsForcePerSquareFoot());
 
         [Fact]
         public void NumberToPoundsForcePerSquareInchTest() =>
-            Assert.Equal(Pressure.FromPoundsForcePerSquareInch(2), 2.PoundsForcePerSquareInch());
+            Assert.Equal(Pressure<double>.FromPoundsForcePerSquareInch(2), 2.PoundsForcePerSquareInch());
 
         [Fact]
         public void NumberToPoundsPerInchSecondSquaredTest() =>
-            Assert.Equal(Pressure.FromPoundsPerInchSecondSquared(2), 2.PoundsPerInchSecondSquared());
+            Assert.Equal(Pressure<double>.FromPoundsPerInchSecondSquared(2), 2.PoundsPerInchSecondSquared());
 
         [Fact]
         public void NumberToTechnicalAtmospheresTest() =>
-            Assert.Equal(Pressure.FromTechnicalAtmospheres(2), 2.TechnicalAtmospheres());
+            Assert.Equal(Pressure<double>.FromTechnicalAtmospheres(2), 2.TechnicalAtmospheres());
 
         [Fact]
         public void NumberToTonnesForcePerSquareCentimeterTest() =>
-            Assert.Equal(Pressure.FromTonnesForcePerSquareCentimeter(2), 2.TonnesForcePerSquareCentimeter());
+            Assert.Equal(Pressure<double>.FromTonnesForcePerSquareCentimeter(2), 2.TonnesForcePerSquareCentimeter());
 
         [Fact]
         public void NumberToTonnesForcePerSquareMeterTest() =>
-            Assert.Equal(Pressure.FromTonnesForcePerSquareMeter(2), 2.TonnesForcePerSquareMeter());
+            Assert.Equal(Pressure<double>.FromTonnesForcePerSquareMeter(2), 2.TonnesForcePerSquareMeter());
 
         [Fact]
         public void NumberToTonnesForcePerSquareMillimeterTest() =>
-            Assert.Equal(Pressure.FromTonnesForcePerSquareMillimeter(2), 2.TonnesForcePerSquareMillimeter());
+            Assert.Equal(Pressure<double>.FromTonnesForcePerSquareMillimeter(2), 2.TonnesForcePerSquareMillimeter());
 
         [Fact]
         public void NumberToTorrsTest() =>
-            Assert.Equal(Pressure.FromTorrs(2), 2.Torrs());
+            Assert.Equal(Pressure<double>.FromTorrs(2), 2.Torrs());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs
index 2c8909a213..c860e0a7c9 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs
@@ -21,16 +21,16 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToRatioChangeRateExtensionsTests
     {
         [Fact]
         public void NumberToDecimalFractionsPerSecondTest() =>
-            Assert.Equal(RatioChangeRate.FromDecimalFractionsPerSecond(2), 2.DecimalFractionsPerSecond());
+            Assert.Equal(RatioChangeRate<double>.FromDecimalFractionsPerSecond(2), 2.DecimalFractionsPerSecond());
 
         [Fact]
         public void NumberToPercentsPerSecondTest() =>
-            Assert.Equal(RatioChangeRate.FromPercentsPerSecond(2), 2.PercentsPerSecond());
+            Assert.Equal(RatioChangeRate<double>.FromPercentsPerSecond(2), 2.PercentsPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs
index 29cd75e5d6..c50a54759f 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs
@@ -21,32 +21,32 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToRatioExtensionsTests
     {
         [Fact]
         public void NumberToDecimalFractionsTest() =>
-            Assert.Equal(Ratio.FromDecimalFractions(2), 2.DecimalFractions());
+            Assert.Equal(Ratio<double>.FromDecimalFractions(2), 2.DecimalFractions());
 
         [Fact]
         public void NumberToPartsPerBillionTest() =>
-            Assert.Equal(Ratio.FromPartsPerBillion(2), 2.PartsPerBillion());
+            Assert.Equal(Ratio<double>.FromPartsPerBillion(2), 2.PartsPerBillion());
 
         [Fact]
         public void NumberToPartsPerMillionTest() =>
-            Assert.Equal(Ratio.FromPartsPerMillion(2), 2.PartsPerMillion());
+            Assert.Equal(Ratio<double>.FromPartsPerMillion(2), 2.PartsPerMillion());
 
         [Fact]
         public void NumberToPartsPerThousandTest() =>
-            Assert.Equal(Ratio.FromPartsPerThousand(2), 2.PartsPerThousand());
+            Assert.Equal(Ratio<double>.FromPartsPerThousand(2), 2.PartsPerThousand());
 
         [Fact]
         public void NumberToPartsPerTrillionTest() =>
-            Assert.Equal(Ratio.FromPartsPerTrillion(2), 2.PartsPerTrillion());
+            Assert.Equal(Ratio<double>.FromPartsPerTrillion(2), 2.PartsPerTrillion());
 
         [Fact]
         public void NumberToPercentTest() =>
-            Assert.Equal(Ratio.FromPercent(2), 2.Percent());
+            Assert.Equal(Ratio<double>.FromPercent(2), 2.Percent());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs
index 76b08293df..9e6b4a01ae 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToReactiveEnergyExtensionsTests
     {
         [Fact]
         public void NumberToKilovoltampereReactiveHoursTest() =>
-            Assert.Equal(ReactiveEnergy.FromKilovoltampereReactiveHours(2), 2.KilovoltampereReactiveHours());
+            Assert.Equal(ReactiveEnergy<double>.FromKilovoltampereReactiveHours(2), 2.KilovoltampereReactiveHours());
 
         [Fact]
         public void NumberToMegavoltampereReactiveHoursTest() =>
-            Assert.Equal(ReactiveEnergy.FromMegavoltampereReactiveHours(2), 2.MegavoltampereReactiveHours());
+            Assert.Equal(ReactiveEnergy<double>.FromMegavoltampereReactiveHours(2), 2.MegavoltampereReactiveHours());
 
         [Fact]
         public void NumberToVoltampereReactiveHoursTest() =>
-            Assert.Equal(ReactiveEnergy.FromVoltampereReactiveHours(2), 2.VoltampereReactiveHours());
+            Assert.Equal(ReactiveEnergy<double>.FromVoltampereReactiveHours(2), 2.VoltampereReactiveHours());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs
index 5634f70bef..d54a48eac5 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToReactivePowerExtensionsTests
     {
         [Fact]
         public void NumberToGigavoltamperesReactiveTest() =>
-            Assert.Equal(ReactivePower.FromGigavoltamperesReactive(2), 2.GigavoltamperesReactive());
+            Assert.Equal(ReactivePower<double>.FromGigavoltamperesReactive(2), 2.GigavoltamperesReactive());
 
         [Fact]
         public void NumberToKilovoltamperesReactiveTest() =>
-            Assert.Equal(ReactivePower.FromKilovoltamperesReactive(2), 2.KilovoltamperesReactive());
+            Assert.Equal(ReactivePower<double>.FromKilovoltamperesReactive(2), 2.KilovoltamperesReactive());
 
         [Fact]
         public void NumberToMegavoltamperesReactiveTest() =>
-            Assert.Equal(ReactivePower.FromMegavoltamperesReactive(2), 2.MegavoltamperesReactive());
+            Assert.Equal(ReactivePower<double>.FromMegavoltamperesReactive(2), 2.MegavoltamperesReactive());
 
         [Fact]
         public void NumberToVoltamperesReactiveTest() =>
-            Assert.Equal(ReactivePower.FromVoltamperesReactive(2), 2.VoltamperesReactive());
+            Assert.Equal(ReactivePower<double>.FromVoltamperesReactive(2), 2.VoltamperesReactive());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRelativeHumidityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRelativeHumidityExtensionsTest.g.cs
index 22c13239c9..b016980395 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRelativeHumidityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRelativeHumidityExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToRelativeHumidityExtensionsTests
     {
         [Fact]
         public void NumberToPercentTest() =>
-            Assert.Equal(RelativeHumidity.FromPercent(2), 2.Percent());
+            Assert.Equal(RelativeHumidity<double>.FromPercent(2), 2.Percent());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs
index 76ec15463c..58b4f5965d 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs
@@ -21,24 +21,24 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToRotationalAccelerationExtensionsTests
     {
         [Fact]
         public void NumberToDegreesPerSecondSquaredTest() =>
-            Assert.Equal(RotationalAcceleration.FromDegreesPerSecondSquared(2), 2.DegreesPerSecondSquared());
+            Assert.Equal(RotationalAcceleration<double>.FromDegreesPerSecondSquared(2), 2.DegreesPerSecondSquared());
 
         [Fact]
         public void NumberToRadiansPerSecondSquaredTest() =>
-            Assert.Equal(RotationalAcceleration.FromRadiansPerSecondSquared(2), 2.RadiansPerSecondSquared());
+            Assert.Equal(RotationalAcceleration<double>.FromRadiansPerSecondSquared(2), 2.RadiansPerSecondSquared());
 
         [Fact]
         public void NumberToRevolutionsPerMinutePerSecondTest() =>
-            Assert.Equal(RotationalAcceleration.FromRevolutionsPerMinutePerSecond(2), 2.RevolutionsPerMinutePerSecond());
+            Assert.Equal(RotationalAcceleration<double>.FromRevolutionsPerMinutePerSecond(2), 2.RevolutionsPerMinutePerSecond());
 
         [Fact]
         public void NumberToRevolutionsPerSecondSquaredTest() =>
-            Assert.Equal(RotationalAcceleration.FromRevolutionsPerSecondSquared(2), 2.RevolutionsPerSecondSquared());
+            Assert.Equal(RotationalAcceleration<double>.FromRevolutionsPerSecondSquared(2), 2.RevolutionsPerSecondSquared());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs
index 15ee76c684..1fb3015038 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs
@@ -21,60 +21,60 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToRotationalSpeedExtensionsTests
     {
         [Fact]
         public void NumberToCentiradiansPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromCentiradiansPerSecond(2), 2.CentiradiansPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromCentiradiansPerSecond(2), 2.CentiradiansPerSecond());
 
         [Fact]
         public void NumberToDeciradiansPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromDeciradiansPerSecond(2), 2.DeciradiansPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromDeciradiansPerSecond(2), 2.DeciradiansPerSecond());
 
         [Fact]
         public void NumberToDegreesPerMinuteTest() =>
-            Assert.Equal(RotationalSpeed.FromDegreesPerMinute(2), 2.DegreesPerMinute());
+            Assert.Equal(RotationalSpeed<double>.FromDegreesPerMinute(2), 2.DegreesPerMinute());
 
         [Fact]
         public void NumberToDegreesPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromDegreesPerSecond(2), 2.DegreesPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromDegreesPerSecond(2), 2.DegreesPerSecond());
 
         [Fact]
         public void NumberToMicrodegreesPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromMicrodegreesPerSecond(2), 2.MicrodegreesPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromMicrodegreesPerSecond(2), 2.MicrodegreesPerSecond());
 
         [Fact]
         public void NumberToMicroradiansPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromMicroradiansPerSecond(2), 2.MicroradiansPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromMicroradiansPerSecond(2), 2.MicroradiansPerSecond());
 
         [Fact]
         public void NumberToMillidegreesPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromMillidegreesPerSecond(2), 2.MillidegreesPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromMillidegreesPerSecond(2), 2.MillidegreesPerSecond());
 
         [Fact]
         public void NumberToMilliradiansPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromMilliradiansPerSecond(2), 2.MilliradiansPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromMilliradiansPerSecond(2), 2.MilliradiansPerSecond());
 
         [Fact]
         public void NumberToNanodegreesPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromNanodegreesPerSecond(2), 2.NanodegreesPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromNanodegreesPerSecond(2), 2.NanodegreesPerSecond());
 
         [Fact]
         public void NumberToNanoradiansPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromNanoradiansPerSecond(2), 2.NanoradiansPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromNanoradiansPerSecond(2), 2.NanoradiansPerSecond());
 
         [Fact]
         public void NumberToRadiansPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromRadiansPerSecond(2), 2.RadiansPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromRadiansPerSecond(2), 2.RadiansPerSecond());
 
         [Fact]
         public void NumberToRevolutionsPerMinuteTest() =>
-            Assert.Equal(RotationalSpeed.FromRevolutionsPerMinute(2), 2.RevolutionsPerMinute());
+            Assert.Equal(RotationalSpeed<double>.FromRevolutionsPerMinute(2), 2.RevolutionsPerMinute());
 
         [Fact]
         public void NumberToRevolutionsPerSecondTest() =>
-            Assert.Equal(RotationalSpeed.FromRevolutionsPerSecond(2), 2.RevolutionsPerSecond());
+            Assert.Equal(RotationalSpeed<double>.FromRevolutionsPerSecond(2), 2.RevolutionsPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs
index ad4161b976..9a089e7c20 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs
@@ -21,140 +21,140 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToRotationalStiffnessExtensionsTests
     {
         [Fact]
         public void NumberToCentinewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromCentinewtonMetersPerDegree(2), 2.CentinewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromCentinewtonMetersPerDegree(2), 2.CentinewtonMetersPerDegree());
 
         [Fact]
         public void NumberToCentinewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromCentinewtonMillimetersPerDegree(2), 2.CentinewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromCentinewtonMillimetersPerDegree(2), 2.CentinewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToCentinewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromCentinewtonMillimetersPerRadian(2), 2.CentinewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromCentinewtonMillimetersPerRadian(2), 2.CentinewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToDecanewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromDecanewtonMetersPerDegree(2), 2.DecanewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromDecanewtonMetersPerDegree(2), 2.DecanewtonMetersPerDegree());
 
         [Fact]
         public void NumberToDecanewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromDecanewtonMillimetersPerDegree(2), 2.DecanewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromDecanewtonMillimetersPerDegree(2), 2.DecanewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToDecanewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromDecanewtonMillimetersPerRadian(2), 2.DecanewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromDecanewtonMillimetersPerRadian(2), 2.DecanewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToDecinewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromDecinewtonMetersPerDegree(2), 2.DecinewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromDecinewtonMetersPerDegree(2), 2.DecinewtonMetersPerDegree());
 
         [Fact]
         public void NumberToDecinewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromDecinewtonMillimetersPerDegree(2), 2.DecinewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromDecinewtonMillimetersPerDegree(2), 2.DecinewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToDecinewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromDecinewtonMillimetersPerRadian(2), 2.DecinewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromDecinewtonMillimetersPerRadian(2), 2.DecinewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToKilonewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromKilonewtonMetersPerDegree(2), 2.KilonewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromKilonewtonMetersPerDegree(2), 2.KilonewtonMetersPerDegree());
 
         [Fact]
         public void NumberToKilonewtonMetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromKilonewtonMetersPerRadian(2), 2.KilonewtonMetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromKilonewtonMetersPerRadian(2), 2.KilonewtonMetersPerRadian());
 
         [Fact]
         public void NumberToKilonewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromKilonewtonMillimetersPerDegree(2), 2.KilonewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromKilonewtonMillimetersPerDegree(2), 2.KilonewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToKilonewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromKilonewtonMillimetersPerRadian(2), 2.KilonewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromKilonewtonMillimetersPerRadian(2), 2.KilonewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToKilopoundForceFeetPerDegreesTest() =>
-            Assert.Equal(RotationalStiffness.FromKilopoundForceFeetPerDegrees(2), 2.KilopoundForceFeetPerDegrees());
+            Assert.Equal(RotationalStiffness<double>.FromKilopoundForceFeetPerDegrees(2), 2.KilopoundForceFeetPerDegrees());
 
         [Fact]
         public void NumberToMeganewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromMeganewtonMetersPerDegree(2), 2.MeganewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromMeganewtonMetersPerDegree(2), 2.MeganewtonMetersPerDegree());
 
         [Fact]
         public void NumberToMeganewtonMetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromMeganewtonMetersPerRadian(2), 2.MeganewtonMetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromMeganewtonMetersPerRadian(2), 2.MeganewtonMetersPerRadian());
 
         [Fact]
         public void NumberToMeganewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromMeganewtonMillimetersPerDegree(2), 2.MeganewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromMeganewtonMillimetersPerDegree(2), 2.MeganewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToMeganewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromMeganewtonMillimetersPerRadian(2), 2.MeganewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromMeganewtonMillimetersPerRadian(2), 2.MeganewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToMicronewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromMicronewtonMetersPerDegree(2), 2.MicronewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromMicronewtonMetersPerDegree(2), 2.MicronewtonMetersPerDegree());
 
         [Fact]
         public void NumberToMicronewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromMicronewtonMillimetersPerDegree(2), 2.MicronewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromMicronewtonMillimetersPerDegree(2), 2.MicronewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToMicronewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromMicronewtonMillimetersPerRadian(2), 2.MicronewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromMicronewtonMillimetersPerRadian(2), 2.MicronewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToMillinewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromMillinewtonMetersPerDegree(2), 2.MillinewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromMillinewtonMetersPerDegree(2), 2.MillinewtonMetersPerDegree());
 
         [Fact]
         public void NumberToMillinewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromMillinewtonMillimetersPerDegree(2), 2.MillinewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromMillinewtonMillimetersPerDegree(2), 2.MillinewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToMillinewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromMillinewtonMillimetersPerRadian(2), 2.MillinewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromMillinewtonMillimetersPerRadian(2), 2.MillinewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToNanonewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromNanonewtonMetersPerDegree(2), 2.NanonewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromNanonewtonMetersPerDegree(2), 2.NanonewtonMetersPerDegree());
 
         [Fact]
         public void NumberToNanonewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromNanonewtonMillimetersPerDegree(2), 2.NanonewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromNanonewtonMillimetersPerDegree(2), 2.NanonewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToNanonewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromNanonewtonMillimetersPerRadian(2), 2.NanonewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromNanonewtonMillimetersPerRadian(2), 2.NanonewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToNewtonMetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromNewtonMetersPerDegree(2), 2.NewtonMetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromNewtonMetersPerDegree(2), 2.NewtonMetersPerDegree());
 
         [Fact]
         public void NumberToNewtonMetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromNewtonMetersPerRadian(2), 2.NewtonMetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromNewtonMetersPerRadian(2), 2.NewtonMetersPerRadian());
 
         [Fact]
         public void NumberToNewtonMillimetersPerDegreeTest() =>
-            Assert.Equal(RotationalStiffness.FromNewtonMillimetersPerDegree(2), 2.NewtonMillimetersPerDegree());
+            Assert.Equal(RotationalStiffness<double>.FromNewtonMillimetersPerDegree(2), 2.NewtonMillimetersPerDegree());
 
         [Fact]
         public void NumberToNewtonMillimetersPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromNewtonMillimetersPerRadian(2), 2.NewtonMillimetersPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromNewtonMillimetersPerRadian(2), 2.NewtonMillimetersPerRadian());
 
         [Fact]
         public void NumberToPoundForceFeetPerRadianTest() =>
-            Assert.Equal(RotationalStiffness.FromPoundForceFeetPerRadian(2), 2.PoundForceFeetPerRadian());
+            Assert.Equal(RotationalStiffness<double>.FromPoundForceFeetPerRadian(2), 2.PoundForceFeetPerRadian());
 
         [Fact]
         public void NumberToPoundForceFeetPerDegreesTest() =>
-            Assert.Equal(RotationalStiffness.FromPoundForceFeetPerDegrees(2), 2.PoundForceFeetPerDegrees());
+            Assert.Equal(RotationalStiffness<double>.FromPoundForceFeetPerDegrees(2), 2.PoundForceFeetPerDegrees());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs
index 8f93a44bd1..15350812bf 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs
@@ -21,28 +21,28 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToRotationalStiffnessPerLengthExtensionsTests
     {
         [Fact]
         public void NumberToKilonewtonMetersPerRadianPerMeterTest() =>
-            Assert.Equal(RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(2), 2.KilonewtonMetersPerRadianPerMeter());
+            Assert.Equal(RotationalStiffnessPerLength<double>.FromKilonewtonMetersPerRadianPerMeter(2), 2.KilonewtonMetersPerRadianPerMeter());
 
         [Fact]
         public void NumberToKilopoundForceFeetPerDegreesPerFeetTest() =>
-            Assert.Equal(RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(2), 2.KilopoundForceFeetPerDegreesPerFeet());
+            Assert.Equal(RotationalStiffnessPerLength<double>.FromKilopoundForceFeetPerDegreesPerFeet(2), 2.KilopoundForceFeetPerDegreesPerFeet());
 
         [Fact]
         public void NumberToMeganewtonMetersPerRadianPerMeterTest() =>
-            Assert.Equal(RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(2), 2.MeganewtonMetersPerRadianPerMeter());
+            Assert.Equal(RotationalStiffnessPerLength<double>.FromMeganewtonMetersPerRadianPerMeter(2), 2.MeganewtonMetersPerRadianPerMeter());
 
         [Fact]
         public void NumberToNewtonMetersPerRadianPerMeterTest() =>
-            Assert.Equal(RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2), 2.NewtonMetersPerRadianPerMeter());
+            Assert.Equal(RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(2), 2.NewtonMetersPerRadianPerMeter());
 
         [Fact]
         public void NumberToPoundForceFeetPerDegreesPerFeetTest() =>
-            Assert.Equal(RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(2), 2.PoundForceFeetPerDegreesPerFeet());
+            Assert.Equal(RotationalStiffnessPerLength<double>.FromPoundForceFeetPerDegreesPerFeet(2), 2.PoundForceFeetPerDegreesPerFeet());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs
index 2f62ef1c62..0dc93b1df4 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToSolidAngleExtensionsTests
     {
         [Fact]
         public void NumberToSteradiansTest() =>
-            Assert.Equal(SolidAngle.FromSteradians(2), 2.Steradians());
+            Assert.Equal(SolidAngle<double>.FromSteradians(2), 2.Steradians());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs
index 93e772d161..6d21b31e5f 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs
@@ -21,108 +21,108 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToSpecificEnergyExtensionsTests
     {
         [Fact]
         public void NumberToBtuPerPoundTest() =>
-            Assert.Equal(SpecificEnergy.FromBtuPerPound(2), 2.BtuPerPound());
+            Assert.Equal(SpecificEnergy<double>.FromBtuPerPound(2), 2.BtuPerPound());
 
         [Fact]
         public void NumberToCaloriesPerGramTest() =>
-            Assert.Equal(SpecificEnergy.FromCaloriesPerGram(2), 2.CaloriesPerGram());
+            Assert.Equal(SpecificEnergy<double>.FromCaloriesPerGram(2), 2.CaloriesPerGram());
 
         [Fact]
         public void NumberToGigawattDaysPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromGigawattDaysPerKilogram(2), 2.GigawattDaysPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromGigawattDaysPerKilogram(2), 2.GigawattDaysPerKilogram());
 
         [Fact]
         public void NumberToGigawattDaysPerShortTonTest() =>
-            Assert.Equal(SpecificEnergy.FromGigawattDaysPerShortTon(2), 2.GigawattDaysPerShortTon());
+            Assert.Equal(SpecificEnergy<double>.FromGigawattDaysPerShortTon(2), 2.GigawattDaysPerShortTon());
 
         [Fact]
         public void NumberToGigawattDaysPerTonneTest() =>
-            Assert.Equal(SpecificEnergy.FromGigawattDaysPerTonne(2), 2.GigawattDaysPerTonne());
+            Assert.Equal(SpecificEnergy<double>.FromGigawattDaysPerTonne(2), 2.GigawattDaysPerTonne());
 
         [Fact]
         public void NumberToGigawattHoursPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromGigawattHoursPerKilogram(2), 2.GigawattHoursPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromGigawattHoursPerKilogram(2), 2.GigawattHoursPerKilogram());
 
         [Fact]
         public void NumberToJoulesPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(2), 2.JoulesPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromJoulesPerKilogram(2), 2.JoulesPerKilogram());
 
         [Fact]
         public void NumberToKilocaloriesPerGramTest() =>
-            Assert.Equal(SpecificEnergy.FromKilocaloriesPerGram(2), 2.KilocaloriesPerGram());
+            Assert.Equal(SpecificEnergy<double>.FromKilocaloriesPerGram(2), 2.KilocaloriesPerGram());
 
         [Fact]
         public void NumberToKilojoulesPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromKilojoulesPerKilogram(2), 2.KilojoulesPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromKilojoulesPerKilogram(2), 2.KilojoulesPerKilogram());
 
         [Fact]
         public void NumberToKilowattDaysPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromKilowattDaysPerKilogram(2), 2.KilowattDaysPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromKilowattDaysPerKilogram(2), 2.KilowattDaysPerKilogram());
 
         [Fact]
         public void NumberToKilowattDaysPerShortTonTest() =>
-            Assert.Equal(SpecificEnergy.FromKilowattDaysPerShortTon(2), 2.KilowattDaysPerShortTon());
+            Assert.Equal(SpecificEnergy<double>.FromKilowattDaysPerShortTon(2), 2.KilowattDaysPerShortTon());
 
         [Fact]
         public void NumberToKilowattDaysPerTonneTest() =>
-            Assert.Equal(SpecificEnergy.FromKilowattDaysPerTonne(2), 2.KilowattDaysPerTonne());
+            Assert.Equal(SpecificEnergy<double>.FromKilowattDaysPerTonne(2), 2.KilowattDaysPerTonne());
 
         [Fact]
         public void NumberToKilowattHoursPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromKilowattHoursPerKilogram(2), 2.KilowattHoursPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromKilowattHoursPerKilogram(2), 2.KilowattHoursPerKilogram());
 
         [Fact]
         public void NumberToMegajoulesPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromMegajoulesPerKilogram(2), 2.MegajoulesPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromMegajoulesPerKilogram(2), 2.MegajoulesPerKilogram());
 
         [Fact]
         public void NumberToMegawattDaysPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromMegawattDaysPerKilogram(2), 2.MegawattDaysPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromMegawattDaysPerKilogram(2), 2.MegawattDaysPerKilogram());
 
         [Fact]
         public void NumberToMegawattDaysPerShortTonTest() =>
-            Assert.Equal(SpecificEnergy.FromMegawattDaysPerShortTon(2), 2.MegawattDaysPerShortTon());
+            Assert.Equal(SpecificEnergy<double>.FromMegawattDaysPerShortTon(2), 2.MegawattDaysPerShortTon());
 
         [Fact]
         public void NumberToMegawattDaysPerTonneTest() =>
-            Assert.Equal(SpecificEnergy.FromMegawattDaysPerTonne(2), 2.MegawattDaysPerTonne());
+            Assert.Equal(SpecificEnergy<double>.FromMegawattDaysPerTonne(2), 2.MegawattDaysPerTonne());
 
         [Fact]
         public void NumberToMegawattHoursPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromMegawattHoursPerKilogram(2), 2.MegawattHoursPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromMegawattHoursPerKilogram(2), 2.MegawattHoursPerKilogram());
 
         [Fact]
         public void NumberToTerawattDaysPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromTerawattDaysPerKilogram(2), 2.TerawattDaysPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromTerawattDaysPerKilogram(2), 2.TerawattDaysPerKilogram());
 
         [Fact]
         public void NumberToTerawattDaysPerShortTonTest() =>
-            Assert.Equal(SpecificEnergy.FromTerawattDaysPerShortTon(2), 2.TerawattDaysPerShortTon());
+            Assert.Equal(SpecificEnergy<double>.FromTerawattDaysPerShortTon(2), 2.TerawattDaysPerShortTon());
 
         [Fact]
         public void NumberToTerawattDaysPerTonneTest() =>
-            Assert.Equal(SpecificEnergy.FromTerawattDaysPerTonne(2), 2.TerawattDaysPerTonne());
+            Assert.Equal(SpecificEnergy<double>.FromTerawattDaysPerTonne(2), 2.TerawattDaysPerTonne());
 
         [Fact]
         public void NumberToWattDaysPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromWattDaysPerKilogram(2), 2.WattDaysPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromWattDaysPerKilogram(2), 2.WattDaysPerKilogram());
 
         [Fact]
         public void NumberToWattDaysPerShortTonTest() =>
-            Assert.Equal(SpecificEnergy.FromWattDaysPerShortTon(2), 2.WattDaysPerShortTon());
+            Assert.Equal(SpecificEnergy<double>.FromWattDaysPerShortTon(2), 2.WattDaysPerShortTon());
 
         [Fact]
         public void NumberToWattDaysPerTonneTest() =>
-            Assert.Equal(SpecificEnergy.FromWattDaysPerTonne(2), 2.WattDaysPerTonne());
+            Assert.Equal(SpecificEnergy<double>.FromWattDaysPerTonne(2), 2.WattDaysPerTonne());
 
         [Fact]
         public void NumberToWattHoursPerKilogramTest() =>
-            Assert.Equal(SpecificEnergy.FromWattHoursPerKilogram(2), 2.WattHoursPerKilogram());
+            Assert.Equal(SpecificEnergy<double>.FromWattHoursPerKilogram(2), 2.WattHoursPerKilogram());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs
index 95593fbdf9..116910a4ad 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs
@@ -21,44 +21,44 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToSpecificEntropyExtensionsTests
     {
         [Fact]
         public void NumberToBtusPerPoundFahrenheitTest() =>
-            Assert.Equal(SpecificEntropy.FromBtusPerPoundFahrenheit(2), 2.BtusPerPoundFahrenheit());
+            Assert.Equal(SpecificEntropy<double>.FromBtusPerPoundFahrenheit(2), 2.BtusPerPoundFahrenheit());
 
         [Fact]
         public void NumberToCaloriesPerGramKelvinTest() =>
-            Assert.Equal(SpecificEntropy.FromCaloriesPerGramKelvin(2), 2.CaloriesPerGramKelvin());
+            Assert.Equal(SpecificEntropy<double>.FromCaloriesPerGramKelvin(2), 2.CaloriesPerGramKelvin());
 
         [Fact]
         public void NumberToJoulesPerKilogramDegreeCelsiusTest() =>
-            Assert.Equal(SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(2), 2.JoulesPerKilogramDegreeCelsius());
+            Assert.Equal(SpecificEntropy<double>.FromJoulesPerKilogramDegreeCelsius(2), 2.JoulesPerKilogramDegreeCelsius());
 
         [Fact]
         public void NumberToJoulesPerKilogramKelvinTest() =>
-            Assert.Equal(SpecificEntropy.FromJoulesPerKilogramKelvin(2), 2.JoulesPerKilogramKelvin());
+            Assert.Equal(SpecificEntropy<double>.FromJoulesPerKilogramKelvin(2), 2.JoulesPerKilogramKelvin());
 
         [Fact]
         public void NumberToKilocaloriesPerGramKelvinTest() =>
-            Assert.Equal(SpecificEntropy.FromKilocaloriesPerGramKelvin(2), 2.KilocaloriesPerGramKelvin());
+            Assert.Equal(SpecificEntropy<double>.FromKilocaloriesPerGramKelvin(2), 2.KilocaloriesPerGramKelvin());
 
         [Fact]
         public void NumberToKilojoulesPerKilogramDegreeCelsiusTest() =>
-            Assert.Equal(SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(2), 2.KilojoulesPerKilogramDegreeCelsius());
+            Assert.Equal(SpecificEntropy<double>.FromKilojoulesPerKilogramDegreeCelsius(2), 2.KilojoulesPerKilogramDegreeCelsius());
 
         [Fact]
         public void NumberToKilojoulesPerKilogramKelvinTest() =>
-            Assert.Equal(SpecificEntropy.FromKilojoulesPerKilogramKelvin(2), 2.KilojoulesPerKilogramKelvin());
+            Assert.Equal(SpecificEntropy<double>.FromKilojoulesPerKilogramKelvin(2), 2.KilojoulesPerKilogramKelvin());
 
         [Fact]
         public void NumberToMegajoulesPerKilogramDegreeCelsiusTest() =>
-            Assert.Equal(SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(2), 2.MegajoulesPerKilogramDegreeCelsius());
+            Assert.Equal(SpecificEntropy<double>.FromMegajoulesPerKilogramDegreeCelsius(2), 2.MegajoulesPerKilogramDegreeCelsius());
 
         [Fact]
         public void NumberToMegajoulesPerKilogramKelvinTest() =>
-            Assert.Equal(SpecificEntropy.FromMegajoulesPerKilogramKelvin(2), 2.MegajoulesPerKilogramKelvin());
+            Assert.Equal(SpecificEntropy<double>.FromMegajoulesPerKilogramKelvin(2), 2.MegajoulesPerKilogramKelvin());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
index f38987467e..7310366ec4 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
@@ -21,20 +21,20 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToSpecificVolumeExtensionsTests
     {
         [Fact]
         public void NumberToCubicFeetPerPoundTest() =>
-            Assert.Equal(SpecificVolume.FromCubicFeetPerPound(2), 2.CubicFeetPerPound());
+            Assert.Equal(SpecificVolume<double>.FromCubicFeetPerPound(2), 2.CubicFeetPerPound());
 
         [Fact]
         public void NumberToCubicMetersPerKilogramTest() =>
-            Assert.Equal(SpecificVolume.FromCubicMetersPerKilogram(2), 2.CubicMetersPerKilogram());
+            Assert.Equal(SpecificVolume<double>.FromCubicMetersPerKilogram(2), 2.CubicMetersPerKilogram());
 
         [Fact]
         public void NumberToMillicubicMetersPerKilogramTest() =>
-            Assert.Equal(SpecificVolume.FromMillicubicMetersPerKilogram(2), 2.MillicubicMetersPerKilogram());
+            Assert.Equal(SpecificVolume<double>.FromMillicubicMetersPerKilogram(2), 2.MillicubicMetersPerKilogram());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs
index 5b86231aee..a5c1a1d3df 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs
@@ -21,76 +21,76 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToSpecificWeightExtensionsTests
     {
         [Fact]
         public void NumberToKilogramsForcePerCubicCentimeterTest() =>
-            Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicCentimeter(2), 2.KilogramsForcePerCubicCentimeter());
+            Assert.Equal(SpecificWeight<double>.FromKilogramsForcePerCubicCentimeter(2), 2.KilogramsForcePerCubicCentimeter());
 
         [Fact]
         public void NumberToKilogramsForcePerCubicMeterTest() =>
-            Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicMeter(2), 2.KilogramsForcePerCubicMeter());
+            Assert.Equal(SpecificWeight<double>.FromKilogramsForcePerCubicMeter(2), 2.KilogramsForcePerCubicMeter());
 
         [Fact]
         public void NumberToKilogramsForcePerCubicMillimeterTest() =>
-            Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicMillimeter(2), 2.KilogramsForcePerCubicMillimeter());
+            Assert.Equal(SpecificWeight<double>.FromKilogramsForcePerCubicMillimeter(2), 2.KilogramsForcePerCubicMillimeter());
 
         [Fact]
         public void NumberToKilonewtonsPerCubicCentimeterTest() =>
-            Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicCentimeter(2), 2.KilonewtonsPerCubicCentimeter());
+            Assert.Equal(SpecificWeight<double>.FromKilonewtonsPerCubicCentimeter(2), 2.KilonewtonsPerCubicCentimeter());
 
         [Fact]
         public void NumberToKilonewtonsPerCubicMeterTest() =>
-            Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicMeter(2), 2.KilonewtonsPerCubicMeter());
+            Assert.Equal(SpecificWeight<double>.FromKilonewtonsPerCubicMeter(2), 2.KilonewtonsPerCubicMeter());
 
         [Fact]
         public void NumberToKilonewtonsPerCubicMillimeterTest() =>
-            Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicMillimeter(2), 2.KilonewtonsPerCubicMillimeter());
+            Assert.Equal(SpecificWeight<double>.FromKilonewtonsPerCubicMillimeter(2), 2.KilonewtonsPerCubicMillimeter());
 
         [Fact]
         public void NumberToKilopoundsForcePerCubicFootTest() =>
-            Assert.Equal(SpecificWeight.FromKilopoundsForcePerCubicFoot(2), 2.KilopoundsForcePerCubicFoot());
+            Assert.Equal(SpecificWeight<double>.FromKilopoundsForcePerCubicFoot(2), 2.KilopoundsForcePerCubicFoot());
 
         [Fact]
         public void NumberToKilopoundsForcePerCubicInchTest() =>
-            Assert.Equal(SpecificWeight.FromKilopoundsForcePerCubicInch(2), 2.KilopoundsForcePerCubicInch());
+            Assert.Equal(SpecificWeight<double>.FromKilopoundsForcePerCubicInch(2), 2.KilopoundsForcePerCubicInch());
 
         [Fact]
         public void NumberToMeganewtonsPerCubicMeterTest() =>
-            Assert.Equal(SpecificWeight.FromMeganewtonsPerCubicMeter(2), 2.MeganewtonsPerCubicMeter());
+            Assert.Equal(SpecificWeight<double>.FromMeganewtonsPerCubicMeter(2), 2.MeganewtonsPerCubicMeter());
 
         [Fact]
         public void NumberToNewtonsPerCubicCentimeterTest() =>
-            Assert.Equal(SpecificWeight.FromNewtonsPerCubicCentimeter(2), 2.NewtonsPerCubicCentimeter());
+            Assert.Equal(SpecificWeight<double>.FromNewtonsPerCubicCentimeter(2), 2.NewtonsPerCubicCentimeter());
 
         [Fact]
         public void NumberToNewtonsPerCubicMeterTest() =>
-            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(2), 2.NewtonsPerCubicMeter());
+            Assert.Equal(SpecificWeight<double>.FromNewtonsPerCubicMeter(2), 2.NewtonsPerCubicMeter());
 
         [Fact]
         public void NumberToNewtonsPerCubicMillimeterTest() =>
-            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMillimeter(2), 2.NewtonsPerCubicMillimeter());
+            Assert.Equal(SpecificWeight<double>.FromNewtonsPerCubicMillimeter(2), 2.NewtonsPerCubicMillimeter());
 
         [Fact]
         public void NumberToPoundsForcePerCubicFootTest() =>
-            Assert.Equal(SpecificWeight.FromPoundsForcePerCubicFoot(2), 2.PoundsForcePerCubicFoot());
+            Assert.Equal(SpecificWeight<double>.FromPoundsForcePerCubicFoot(2), 2.PoundsForcePerCubicFoot());
 
         [Fact]
         public void NumberToPoundsForcePerCubicInchTest() =>
-            Assert.Equal(SpecificWeight.FromPoundsForcePerCubicInch(2), 2.PoundsForcePerCubicInch());
+            Assert.Equal(SpecificWeight<double>.FromPoundsForcePerCubicInch(2), 2.PoundsForcePerCubicInch());
 
         [Fact]
         public void NumberToTonnesForcePerCubicCentimeterTest() =>
-            Assert.Equal(SpecificWeight.FromTonnesForcePerCubicCentimeter(2), 2.TonnesForcePerCubicCentimeter());
+            Assert.Equal(SpecificWeight<double>.FromTonnesForcePerCubicCentimeter(2), 2.TonnesForcePerCubicCentimeter());
 
         [Fact]
         public void NumberToTonnesForcePerCubicMeterTest() =>
-            Assert.Equal(SpecificWeight.FromTonnesForcePerCubicMeter(2), 2.TonnesForcePerCubicMeter());
+            Assert.Equal(SpecificWeight<double>.FromTonnesForcePerCubicMeter(2), 2.TonnesForcePerCubicMeter());
 
         [Fact]
         public void NumberToTonnesForcePerCubicMillimeterTest() =>
-            Assert.Equal(SpecificWeight.FromTonnesForcePerCubicMillimeter(2), 2.TonnesForcePerCubicMillimeter());
+            Assert.Equal(SpecificWeight<double>.FromTonnesForcePerCubicMillimeter(2), 2.TonnesForcePerCubicMillimeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs
index cf82f33e6c..5100b97ca6 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs
@@ -21,136 +21,136 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToSpeedExtensionsTests
     {
         [Fact]
         public void NumberToCentimetersPerHourTest() =>
-            Assert.Equal(Speed.FromCentimetersPerHour(2), 2.CentimetersPerHour());
+            Assert.Equal(Speed<double>.FromCentimetersPerHour(2), 2.CentimetersPerHour());
 
         [Fact]
         public void NumberToCentimetersPerMinutesTest() =>
-            Assert.Equal(Speed.FromCentimetersPerMinutes(2), 2.CentimetersPerMinutes());
+            Assert.Equal(Speed<double>.FromCentimetersPerMinutes(2), 2.CentimetersPerMinutes());
 
         [Fact]
         public void NumberToCentimetersPerSecondTest() =>
-            Assert.Equal(Speed.FromCentimetersPerSecond(2), 2.CentimetersPerSecond());
+            Assert.Equal(Speed<double>.FromCentimetersPerSecond(2), 2.CentimetersPerSecond());
 
         [Fact]
         public void NumberToDecimetersPerMinutesTest() =>
-            Assert.Equal(Speed.FromDecimetersPerMinutes(2), 2.DecimetersPerMinutes());
+            Assert.Equal(Speed<double>.FromDecimetersPerMinutes(2), 2.DecimetersPerMinutes());
 
         [Fact]
         public void NumberToDecimetersPerSecondTest() =>
-            Assert.Equal(Speed.FromDecimetersPerSecond(2), 2.DecimetersPerSecond());
+            Assert.Equal(Speed<double>.FromDecimetersPerSecond(2), 2.DecimetersPerSecond());
 
         [Fact]
         public void NumberToFeetPerHourTest() =>
-            Assert.Equal(Speed.FromFeetPerHour(2), 2.FeetPerHour());
+            Assert.Equal(Speed<double>.FromFeetPerHour(2), 2.FeetPerHour());
 
         [Fact]
         public void NumberToFeetPerMinuteTest() =>
-            Assert.Equal(Speed.FromFeetPerMinute(2), 2.FeetPerMinute());
+            Assert.Equal(Speed<double>.FromFeetPerMinute(2), 2.FeetPerMinute());
 
         [Fact]
         public void NumberToFeetPerSecondTest() =>
-            Assert.Equal(Speed.FromFeetPerSecond(2), 2.FeetPerSecond());
+            Assert.Equal(Speed<double>.FromFeetPerSecond(2), 2.FeetPerSecond());
 
         [Fact]
         public void NumberToInchesPerHourTest() =>
-            Assert.Equal(Speed.FromInchesPerHour(2), 2.InchesPerHour());
+            Assert.Equal(Speed<double>.FromInchesPerHour(2), 2.InchesPerHour());
 
         [Fact]
         public void NumberToInchesPerMinuteTest() =>
-            Assert.Equal(Speed.FromInchesPerMinute(2), 2.InchesPerMinute());
+            Assert.Equal(Speed<double>.FromInchesPerMinute(2), 2.InchesPerMinute());
 
         [Fact]
         public void NumberToInchesPerSecondTest() =>
-            Assert.Equal(Speed.FromInchesPerSecond(2), 2.InchesPerSecond());
+            Assert.Equal(Speed<double>.FromInchesPerSecond(2), 2.InchesPerSecond());
 
         [Fact]
         public void NumberToKilometersPerHourTest() =>
-            Assert.Equal(Speed.FromKilometersPerHour(2), 2.KilometersPerHour());
+            Assert.Equal(Speed<double>.FromKilometersPerHour(2), 2.KilometersPerHour());
 
         [Fact]
         public void NumberToKilometersPerMinutesTest() =>
-            Assert.Equal(Speed.FromKilometersPerMinutes(2), 2.KilometersPerMinutes());
+            Assert.Equal(Speed<double>.FromKilometersPerMinutes(2), 2.KilometersPerMinutes());
 
         [Fact]
         public void NumberToKilometersPerSecondTest() =>
-            Assert.Equal(Speed.FromKilometersPerSecond(2), 2.KilometersPerSecond());
+            Assert.Equal(Speed<double>.FromKilometersPerSecond(2), 2.KilometersPerSecond());
 
         [Fact]
         public void NumberToKnotsTest() =>
-            Assert.Equal(Speed.FromKnots(2), 2.Knots());
+            Assert.Equal(Speed<double>.FromKnots(2), 2.Knots());
 
         [Fact]
         public void NumberToMetersPerHourTest() =>
-            Assert.Equal(Speed.FromMetersPerHour(2), 2.MetersPerHour());
+            Assert.Equal(Speed<double>.FromMetersPerHour(2), 2.MetersPerHour());
 
         [Fact]
         public void NumberToMetersPerMinutesTest() =>
-            Assert.Equal(Speed.FromMetersPerMinutes(2), 2.MetersPerMinutes());
+            Assert.Equal(Speed<double>.FromMetersPerMinutes(2), 2.MetersPerMinutes());
 
         [Fact]
         public void NumberToMetersPerSecondTest() =>
-            Assert.Equal(Speed.FromMetersPerSecond(2), 2.MetersPerSecond());
+            Assert.Equal(Speed<double>.FromMetersPerSecond(2), 2.MetersPerSecond());
 
         [Fact]
         public void NumberToMicrometersPerMinutesTest() =>
-            Assert.Equal(Speed.FromMicrometersPerMinutes(2), 2.MicrometersPerMinutes());
+            Assert.Equal(Speed<double>.FromMicrometersPerMinutes(2), 2.MicrometersPerMinutes());
 
         [Fact]
         public void NumberToMicrometersPerSecondTest() =>
-            Assert.Equal(Speed.FromMicrometersPerSecond(2), 2.MicrometersPerSecond());
+            Assert.Equal(Speed<double>.FromMicrometersPerSecond(2), 2.MicrometersPerSecond());
 
         [Fact]
         public void NumberToMilesPerHourTest() =>
-            Assert.Equal(Speed.FromMilesPerHour(2), 2.MilesPerHour());
+            Assert.Equal(Speed<double>.FromMilesPerHour(2), 2.MilesPerHour());
 
         [Fact]
         public void NumberToMillimetersPerHourTest() =>
-            Assert.Equal(Speed.FromMillimetersPerHour(2), 2.MillimetersPerHour());
+            Assert.Equal(Speed<double>.FromMillimetersPerHour(2), 2.MillimetersPerHour());
 
         [Fact]
         public void NumberToMillimetersPerMinutesTest() =>
-            Assert.Equal(Speed.FromMillimetersPerMinutes(2), 2.MillimetersPerMinutes());
+            Assert.Equal(Speed<double>.FromMillimetersPerMinutes(2), 2.MillimetersPerMinutes());
 
         [Fact]
         public void NumberToMillimetersPerSecondTest() =>
-            Assert.Equal(Speed.FromMillimetersPerSecond(2), 2.MillimetersPerSecond());
+            Assert.Equal(Speed<double>.FromMillimetersPerSecond(2), 2.MillimetersPerSecond());
 
         [Fact]
         public void NumberToNanometersPerMinutesTest() =>
-            Assert.Equal(Speed.FromNanometersPerMinutes(2), 2.NanometersPerMinutes());
+            Assert.Equal(Speed<double>.FromNanometersPerMinutes(2), 2.NanometersPerMinutes());
 
         [Fact]
         public void NumberToNanometersPerSecondTest() =>
-            Assert.Equal(Speed.FromNanometersPerSecond(2), 2.NanometersPerSecond());
+            Assert.Equal(Speed<double>.FromNanometersPerSecond(2), 2.NanometersPerSecond());
 
         [Fact]
         public void NumberToUsSurveyFeetPerHourTest() =>
-            Assert.Equal(Speed.FromUsSurveyFeetPerHour(2), 2.UsSurveyFeetPerHour());
+            Assert.Equal(Speed<double>.FromUsSurveyFeetPerHour(2), 2.UsSurveyFeetPerHour());
 
         [Fact]
         public void NumberToUsSurveyFeetPerMinuteTest() =>
-            Assert.Equal(Speed.FromUsSurveyFeetPerMinute(2), 2.UsSurveyFeetPerMinute());
+            Assert.Equal(Speed<double>.FromUsSurveyFeetPerMinute(2), 2.UsSurveyFeetPerMinute());
 
         [Fact]
         public void NumberToUsSurveyFeetPerSecondTest() =>
-            Assert.Equal(Speed.FromUsSurveyFeetPerSecond(2), 2.UsSurveyFeetPerSecond());
+            Assert.Equal(Speed<double>.FromUsSurveyFeetPerSecond(2), 2.UsSurveyFeetPerSecond());
 
         [Fact]
         public void NumberToYardsPerHourTest() =>
-            Assert.Equal(Speed.FromYardsPerHour(2), 2.YardsPerHour());
+            Assert.Equal(Speed<double>.FromYardsPerHour(2), 2.YardsPerHour());
 
         [Fact]
         public void NumberToYardsPerMinuteTest() =>
-            Assert.Equal(Speed.FromYardsPerMinute(2), 2.YardsPerMinute());
+            Assert.Equal(Speed<double>.FromYardsPerMinute(2), 2.YardsPerMinute());
 
         [Fact]
         public void NumberToYardsPerSecondTest() =>
-            Assert.Equal(Speed.FromYardsPerSecond(2), 2.YardsPerSecond());
+            Assert.Equal(Speed<double>.FromYardsPerSecond(2), 2.YardsPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs
index 957a586266..cb87b03be7 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs
@@ -21,48 +21,48 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToTemperatureChangeRateExtensionsTests
     {
         [Fact]
         public void NumberToCentidegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(2), 2.CentidegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromCentidegreesCelsiusPerSecond(2), 2.CentidegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToDecadegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(2), 2.DecadegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromDecadegreesCelsiusPerSecond(2), 2.DecadegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToDecidegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(2), 2.DecidegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromDecidegreesCelsiusPerSecond(2), 2.DecidegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToDegreesCelsiusPerMinuteTest() =>
-            Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerMinute(2), 2.DegreesCelsiusPerMinute());
+            Assert.Equal(TemperatureChangeRate<double>.FromDegreesCelsiusPerMinute(2), 2.DegreesCelsiusPerMinute());
 
         [Fact]
         public void NumberToDegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerSecond(2), 2.DegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(2), 2.DegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToHectodegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(2), 2.HectodegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromHectodegreesCelsiusPerSecond(2), 2.HectodegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToKilodegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(2), 2.KilodegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromKilodegreesCelsiusPerSecond(2), 2.KilodegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToMicrodegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(2), 2.MicrodegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromMicrodegreesCelsiusPerSecond(2), 2.MicrodegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToMillidegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(2), 2.MillidegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromMillidegreesCelsiusPerSecond(2), 2.MillidegreesCelsiusPerSecond());
 
         [Fact]
         public void NumberToNanodegreesCelsiusPerSecondTest() =>
-            Assert.Equal(TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(2), 2.NanodegreesCelsiusPerSecond());
+            Assert.Equal(TemperatureChangeRate<double>.FromNanodegreesCelsiusPerSecond(2), 2.NanodegreesCelsiusPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs
index ca32dbe18b..c36b58765c 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs
@@ -21,44 +21,44 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToTemperatureDeltaExtensionsTests
     {
         [Fact]
         public void NumberToDegreesCelsiusTest() =>
-            Assert.Equal(TemperatureDelta.FromDegreesCelsius(2), 2.DegreesCelsius());
+            Assert.Equal(TemperatureDelta<double>.FromDegreesCelsius(2), 2.DegreesCelsius());
 
         [Fact]
         public void NumberToDegreesDelisleTest() =>
-            Assert.Equal(TemperatureDelta.FromDegreesDelisle(2), 2.DegreesDelisle());
+            Assert.Equal(TemperatureDelta<double>.FromDegreesDelisle(2), 2.DegreesDelisle());
 
         [Fact]
         public void NumberToDegreesFahrenheitTest() =>
-            Assert.Equal(TemperatureDelta.FromDegreesFahrenheit(2), 2.DegreesFahrenheit());
+            Assert.Equal(TemperatureDelta<double>.FromDegreesFahrenheit(2), 2.DegreesFahrenheit());
 
         [Fact]
         public void NumberToDegreesNewtonTest() =>
-            Assert.Equal(TemperatureDelta.FromDegreesNewton(2), 2.DegreesNewton());
+            Assert.Equal(TemperatureDelta<double>.FromDegreesNewton(2), 2.DegreesNewton());
 
         [Fact]
         public void NumberToDegreesRankineTest() =>
-            Assert.Equal(TemperatureDelta.FromDegreesRankine(2), 2.DegreesRankine());
+            Assert.Equal(TemperatureDelta<double>.FromDegreesRankine(2), 2.DegreesRankine());
 
         [Fact]
         public void NumberToDegreesReaumurTest() =>
-            Assert.Equal(TemperatureDelta.FromDegreesReaumur(2), 2.DegreesReaumur());
+            Assert.Equal(TemperatureDelta<double>.FromDegreesReaumur(2), 2.DegreesReaumur());
 
         [Fact]
         public void NumberToDegreesRoemerTest() =>
-            Assert.Equal(TemperatureDelta.FromDegreesRoemer(2), 2.DegreesRoemer());
+            Assert.Equal(TemperatureDelta<double>.FromDegreesRoemer(2), 2.DegreesRoemer());
 
         [Fact]
         public void NumberToKelvinsTest() =>
-            Assert.Equal(TemperatureDelta.FromKelvins(2), 2.Kelvins());
+            Assert.Equal(TemperatureDelta<double>.FromKelvins(2), 2.Kelvins());
 
         [Fact]
         public void NumberToMillidegreesCelsiusTest() =>
-            Assert.Equal(TemperatureDelta.FromMillidegreesCelsius(2), 2.MillidegreesCelsius());
+            Assert.Equal(TemperatureDelta<double>.FromMillidegreesCelsius(2), 2.MillidegreesCelsius());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs
index fd5ca1843a..d462297f34 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs
@@ -21,48 +21,48 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToTemperatureExtensionsTests
     {
         [Fact]
         public void NumberToDegreesCelsiusTest() =>
-            Assert.Equal(Temperature.FromDegreesCelsius(2), 2.DegreesCelsius());
+            Assert.Equal(Temperature<double>.FromDegreesCelsius(2), 2.DegreesCelsius());
 
         [Fact]
         public void NumberToDegreesDelisleTest() =>
-            Assert.Equal(Temperature.FromDegreesDelisle(2), 2.DegreesDelisle());
+            Assert.Equal(Temperature<double>.FromDegreesDelisle(2), 2.DegreesDelisle());
 
         [Fact]
         public void NumberToDegreesFahrenheitTest() =>
-            Assert.Equal(Temperature.FromDegreesFahrenheit(2), 2.DegreesFahrenheit());
+            Assert.Equal(Temperature<double>.FromDegreesFahrenheit(2), 2.DegreesFahrenheit());
 
         [Fact]
         public void NumberToDegreesNewtonTest() =>
-            Assert.Equal(Temperature.FromDegreesNewton(2), 2.DegreesNewton());
+            Assert.Equal(Temperature<double>.FromDegreesNewton(2), 2.DegreesNewton());
 
         [Fact]
         public void NumberToDegreesRankineTest() =>
-            Assert.Equal(Temperature.FromDegreesRankine(2), 2.DegreesRankine());
+            Assert.Equal(Temperature<double>.FromDegreesRankine(2), 2.DegreesRankine());
 
         [Fact]
         public void NumberToDegreesReaumurTest() =>
-            Assert.Equal(Temperature.FromDegreesReaumur(2), 2.DegreesReaumur());
+            Assert.Equal(Temperature<double>.FromDegreesReaumur(2), 2.DegreesReaumur());
 
         [Fact]
         public void NumberToDegreesRoemerTest() =>
-            Assert.Equal(Temperature.FromDegreesRoemer(2), 2.DegreesRoemer());
+            Assert.Equal(Temperature<double>.FromDegreesRoemer(2), 2.DegreesRoemer());
 
         [Fact]
         public void NumberToKelvinsTest() =>
-            Assert.Equal(Temperature.FromKelvins(2), 2.Kelvins());
+            Assert.Equal(Temperature<double>.FromKelvins(2), 2.Kelvins());
 
         [Fact]
         public void NumberToMillidegreesCelsiusTest() =>
-            Assert.Equal(Temperature.FromMillidegreesCelsius(2), 2.MillidegreesCelsius());
+            Assert.Equal(Temperature<double>.FromMillidegreesCelsius(2), 2.MillidegreesCelsius());
 
         [Fact]
         public void NumberToSolarTemperaturesTest() =>
-            Assert.Equal(Temperature.FromSolarTemperatures(2), 2.SolarTemperatures());
+            Assert.Equal(Temperature<double>.FromSolarTemperatures(2), 2.SolarTemperatures());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
index 8a5e51b160..c5eddbe155 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
@@ -21,16 +21,16 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToThermalConductivityExtensionsTests
     {
         [Fact]
         public void NumberToBtusPerHourFootFahrenheitTest() =>
-            Assert.Equal(ThermalConductivity.FromBtusPerHourFootFahrenheit(2), 2.BtusPerHourFootFahrenheit());
+            Assert.Equal(ThermalConductivity<double>.FromBtusPerHourFootFahrenheit(2), 2.BtusPerHourFootFahrenheit());
 
         [Fact]
         public void NumberToWattsPerMeterKelvinTest() =>
-            Assert.Equal(ThermalConductivity.FromWattsPerMeterKelvin(2), 2.WattsPerMeterKelvin());
+            Assert.Equal(ThermalConductivity<double>.FromWattsPerMeterKelvin(2), 2.WattsPerMeterKelvin());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs
index bd498813b2..a636d7fe16 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs
@@ -21,28 +21,28 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToThermalResistanceExtensionsTests
     {
         [Fact]
         public void NumberToHourSquareFeetDegreesFahrenheitPerBtuTest() =>
-            Assert.Equal(ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(2), 2.HourSquareFeetDegreesFahrenheitPerBtu());
+            Assert.Equal(ThermalResistance<double>.FromHourSquareFeetDegreesFahrenheitPerBtu(2), 2.HourSquareFeetDegreesFahrenheitPerBtu());
 
         [Fact]
         public void NumberToSquareCentimeterHourDegreesCelsiusPerKilocalorieTest() =>
-            Assert.Equal(ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(2), 2.SquareCentimeterHourDegreesCelsiusPerKilocalorie());
+            Assert.Equal(ThermalResistance<double>.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(2), 2.SquareCentimeterHourDegreesCelsiusPerKilocalorie());
 
         [Fact]
         public void NumberToSquareCentimeterKelvinsPerWattTest() =>
-            Assert.Equal(ThermalResistance.FromSquareCentimeterKelvinsPerWatt(2), 2.SquareCentimeterKelvinsPerWatt());
+            Assert.Equal(ThermalResistance<double>.FromSquareCentimeterKelvinsPerWatt(2), 2.SquareCentimeterKelvinsPerWatt());
 
         [Fact]
         public void NumberToSquareMeterDegreesCelsiusPerWattTest() =>
-            Assert.Equal(ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(2), 2.SquareMeterDegreesCelsiusPerWatt());
+            Assert.Equal(ThermalResistance<double>.FromSquareMeterDegreesCelsiusPerWatt(2), 2.SquareMeterDegreesCelsiusPerWatt());
 
         [Fact]
         public void NumberToSquareMeterKelvinsPerKilowattTest() =>
-            Assert.Equal(ThermalResistance.FromSquareMeterKelvinsPerKilowatt(2), 2.SquareMeterKelvinsPerKilowatt());
+            Assert.Equal(ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(2), 2.SquareMeterKelvinsPerKilowatt());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
index ed843a6c9c..0876ecf5b7 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
@@ -21,96 +21,96 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToTorqueExtensionsTests
     {
         [Fact]
         public void NumberToKilogramForceCentimetersTest() =>
-            Assert.Equal(Torque.FromKilogramForceCentimeters(2), 2.KilogramForceCentimeters());
+            Assert.Equal(Torque<double>.FromKilogramForceCentimeters(2), 2.KilogramForceCentimeters());
 
         [Fact]
         public void NumberToKilogramForceMetersTest() =>
-            Assert.Equal(Torque.FromKilogramForceMeters(2), 2.KilogramForceMeters());
+            Assert.Equal(Torque<double>.FromKilogramForceMeters(2), 2.KilogramForceMeters());
 
         [Fact]
         public void NumberToKilogramForceMillimetersTest() =>
-            Assert.Equal(Torque.FromKilogramForceMillimeters(2), 2.KilogramForceMillimeters());
+            Assert.Equal(Torque<double>.FromKilogramForceMillimeters(2), 2.KilogramForceMillimeters());
 
         [Fact]
         public void NumberToKilonewtonCentimetersTest() =>
-            Assert.Equal(Torque.FromKilonewtonCentimeters(2), 2.KilonewtonCentimeters());
+            Assert.Equal(Torque<double>.FromKilonewtonCentimeters(2), 2.KilonewtonCentimeters());
 
         [Fact]
         public void NumberToKilonewtonMetersTest() =>
-            Assert.Equal(Torque.FromKilonewtonMeters(2), 2.KilonewtonMeters());
+            Assert.Equal(Torque<double>.FromKilonewtonMeters(2), 2.KilonewtonMeters());
 
         [Fact]
         public void NumberToKilonewtonMillimetersTest() =>
-            Assert.Equal(Torque.FromKilonewtonMillimeters(2), 2.KilonewtonMillimeters());
+            Assert.Equal(Torque<double>.FromKilonewtonMillimeters(2), 2.KilonewtonMillimeters());
 
         [Fact]
         public void NumberToKilopoundForceFeetTest() =>
-            Assert.Equal(Torque.FromKilopoundForceFeet(2), 2.KilopoundForceFeet());
+            Assert.Equal(Torque<double>.FromKilopoundForceFeet(2), 2.KilopoundForceFeet());
 
         [Fact]
         public void NumberToKilopoundForceInchesTest() =>
-            Assert.Equal(Torque.FromKilopoundForceInches(2), 2.KilopoundForceInches());
+            Assert.Equal(Torque<double>.FromKilopoundForceInches(2), 2.KilopoundForceInches());
 
         [Fact]
         public void NumberToMeganewtonCentimetersTest() =>
-            Assert.Equal(Torque.FromMeganewtonCentimeters(2), 2.MeganewtonCentimeters());
+            Assert.Equal(Torque<double>.FromMeganewtonCentimeters(2), 2.MeganewtonCentimeters());
 
         [Fact]
         public void NumberToMeganewtonMetersTest() =>
-            Assert.Equal(Torque.FromMeganewtonMeters(2), 2.MeganewtonMeters());
+            Assert.Equal(Torque<double>.FromMeganewtonMeters(2), 2.MeganewtonMeters());
 
         [Fact]
         public void NumberToMeganewtonMillimetersTest() =>
-            Assert.Equal(Torque.FromMeganewtonMillimeters(2), 2.MeganewtonMillimeters());
+            Assert.Equal(Torque<double>.FromMeganewtonMillimeters(2), 2.MeganewtonMillimeters());
 
         [Fact]
         public void NumberToMegapoundForceFeetTest() =>
-            Assert.Equal(Torque.FromMegapoundForceFeet(2), 2.MegapoundForceFeet());
+            Assert.Equal(Torque<double>.FromMegapoundForceFeet(2), 2.MegapoundForceFeet());
 
         [Fact]
         public void NumberToMegapoundForceInchesTest() =>
-            Assert.Equal(Torque.FromMegapoundForceInches(2), 2.MegapoundForceInches());
+            Assert.Equal(Torque<double>.FromMegapoundForceInches(2), 2.MegapoundForceInches());
 
         [Fact]
         public void NumberToNewtonCentimetersTest() =>
-            Assert.Equal(Torque.FromNewtonCentimeters(2), 2.NewtonCentimeters());
+            Assert.Equal(Torque<double>.FromNewtonCentimeters(2), 2.NewtonCentimeters());
 
         [Fact]
         public void NumberToNewtonMetersTest() =>
-            Assert.Equal(Torque.FromNewtonMeters(2), 2.NewtonMeters());
+            Assert.Equal(Torque<double>.FromNewtonMeters(2), 2.NewtonMeters());
 
         [Fact]
         public void NumberToNewtonMillimetersTest() =>
-            Assert.Equal(Torque.FromNewtonMillimeters(2), 2.NewtonMillimeters());
+            Assert.Equal(Torque<double>.FromNewtonMillimeters(2), 2.NewtonMillimeters());
 
         [Fact]
         public void NumberToPoundalFeetTest() =>
-            Assert.Equal(Torque.FromPoundalFeet(2), 2.PoundalFeet());
+            Assert.Equal(Torque<double>.FromPoundalFeet(2), 2.PoundalFeet());
 
         [Fact]
         public void NumberToPoundForceFeetTest() =>
-            Assert.Equal(Torque.FromPoundForceFeet(2), 2.PoundForceFeet());
+            Assert.Equal(Torque<double>.FromPoundForceFeet(2), 2.PoundForceFeet());
 
         [Fact]
         public void NumberToPoundForceInchesTest() =>
-            Assert.Equal(Torque.FromPoundForceInches(2), 2.PoundForceInches());
+            Assert.Equal(Torque<double>.FromPoundForceInches(2), 2.PoundForceInches());
 
         [Fact]
         public void NumberToTonneForceCentimetersTest() =>
-            Assert.Equal(Torque.FromTonneForceCentimeters(2), 2.TonneForceCentimeters());
+            Assert.Equal(Torque<double>.FromTonneForceCentimeters(2), 2.TonneForceCentimeters());
 
         [Fact]
         public void NumberToTonneForceMetersTest() =>
-            Assert.Equal(Torque.FromTonneForceMeters(2), 2.TonneForceMeters());
+            Assert.Equal(Torque<double>.FromTonneForceMeters(2), 2.TonneForceMeters());
 
         [Fact]
         public void NumberToTonneForceMillimetersTest() =>
-            Assert.Equal(Torque.FromTonneForceMillimeters(2), 2.TonneForceMillimeters());
+            Assert.Equal(Torque<double>.FromTonneForceMillimeters(2), 2.TonneForceMillimeters());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs
index ea0406f6b3..c87e55fd37 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs
@@ -21,92 +21,92 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToTorquePerLengthExtensionsTests
     {
         [Fact]
         public void NumberToKilogramForceCentimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromKilogramForceCentimetersPerMeter(2), 2.KilogramForceCentimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromKilogramForceCentimetersPerMeter(2), 2.KilogramForceCentimetersPerMeter());
 
         [Fact]
         public void NumberToKilogramForceMetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromKilogramForceMetersPerMeter(2), 2.KilogramForceMetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromKilogramForceMetersPerMeter(2), 2.KilogramForceMetersPerMeter());
 
         [Fact]
         public void NumberToKilogramForceMillimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromKilogramForceMillimetersPerMeter(2), 2.KilogramForceMillimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromKilogramForceMillimetersPerMeter(2), 2.KilogramForceMillimetersPerMeter());
 
         [Fact]
         public void NumberToKilonewtonCentimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromKilonewtonCentimetersPerMeter(2), 2.KilonewtonCentimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromKilonewtonCentimetersPerMeter(2), 2.KilonewtonCentimetersPerMeter());
 
         [Fact]
         public void NumberToKilonewtonMetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromKilonewtonMetersPerMeter(2), 2.KilonewtonMetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromKilonewtonMetersPerMeter(2), 2.KilonewtonMetersPerMeter());
 
         [Fact]
         public void NumberToKilonewtonMillimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromKilonewtonMillimetersPerMeter(2), 2.KilonewtonMillimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromKilonewtonMillimetersPerMeter(2), 2.KilonewtonMillimetersPerMeter());
 
         [Fact]
         public void NumberToKilopoundForceFeetPerFootTest() =>
-            Assert.Equal(TorquePerLength.FromKilopoundForceFeetPerFoot(2), 2.KilopoundForceFeetPerFoot());
+            Assert.Equal(TorquePerLength<double>.FromKilopoundForceFeetPerFoot(2), 2.KilopoundForceFeetPerFoot());
 
         [Fact]
         public void NumberToKilopoundForceInchesPerFootTest() =>
-            Assert.Equal(TorquePerLength.FromKilopoundForceInchesPerFoot(2), 2.KilopoundForceInchesPerFoot());
+            Assert.Equal(TorquePerLength<double>.FromKilopoundForceInchesPerFoot(2), 2.KilopoundForceInchesPerFoot());
 
         [Fact]
         public void NumberToMeganewtonCentimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromMeganewtonCentimetersPerMeter(2), 2.MeganewtonCentimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromMeganewtonCentimetersPerMeter(2), 2.MeganewtonCentimetersPerMeter());
 
         [Fact]
         public void NumberToMeganewtonMetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromMeganewtonMetersPerMeter(2), 2.MeganewtonMetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromMeganewtonMetersPerMeter(2), 2.MeganewtonMetersPerMeter());
 
         [Fact]
         public void NumberToMeganewtonMillimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromMeganewtonMillimetersPerMeter(2), 2.MeganewtonMillimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromMeganewtonMillimetersPerMeter(2), 2.MeganewtonMillimetersPerMeter());
 
         [Fact]
         public void NumberToMegapoundForceFeetPerFootTest() =>
-            Assert.Equal(TorquePerLength.FromMegapoundForceFeetPerFoot(2), 2.MegapoundForceFeetPerFoot());
+            Assert.Equal(TorquePerLength<double>.FromMegapoundForceFeetPerFoot(2), 2.MegapoundForceFeetPerFoot());
 
         [Fact]
         public void NumberToMegapoundForceInchesPerFootTest() =>
-            Assert.Equal(TorquePerLength.FromMegapoundForceInchesPerFoot(2), 2.MegapoundForceInchesPerFoot());
+            Assert.Equal(TorquePerLength<double>.FromMegapoundForceInchesPerFoot(2), 2.MegapoundForceInchesPerFoot());
 
         [Fact]
         public void NumberToNewtonCentimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromNewtonCentimetersPerMeter(2), 2.NewtonCentimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromNewtonCentimetersPerMeter(2), 2.NewtonCentimetersPerMeter());
 
         [Fact]
         public void NumberToNewtonMetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromNewtonMetersPerMeter(2), 2.NewtonMetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromNewtonMetersPerMeter(2), 2.NewtonMetersPerMeter());
 
         [Fact]
         public void NumberToNewtonMillimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromNewtonMillimetersPerMeter(2), 2.NewtonMillimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromNewtonMillimetersPerMeter(2), 2.NewtonMillimetersPerMeter());
 
         [Fact]
         public void NumberToPoundForceFeetPerFootTest() =>
-            Assert.Equal(TorquePerLength.FromPoundForceFeetPerFoot(2), 2.PoundForceFeetPerFoot());
+            Assert.Equal(TorquePerLength<double>.FromPoundForceFeetPerFoot(2), 2.PoundForceFeetPerFoot());
 
         [Fact]
         public void NumberToPoundForceInchesPerFootTest() =>
-            Assert.Equal(TorquePerLength.FromPoundForceInchesPerFoot(2), 2.PoundForceInchesPerFoot());
+            Assert.Equal(TorquePerLength<double>.FromPoundForceInchesPerFoot(2), 2.PoundForceInchesPerFoot());
 
         [Fact]
         public void NumberToTonneForceCentimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromTonneForceCentimetersPerMeter(2), 2.TonneForceCentimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromTonneForceCentimetersPerMeter(2), 2.TonneForceCentimetersPerMeter());
 
         [Fact]
         public void NumberToTonneForceMetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromTonneForceMetersPerMeter(2), 2.TonneForceMetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromTonneForceMetersPerMeter(2), 2.TonneForceMetersPerMeter());
 
         [Fact]
         public void NumberToTonneForceMillimetersPerMeterTest() =>
-            Assert.Equal(TorquePerLength.FromTonneForceMillimetersPerMeter(2), 2.TonneForceMillimetersPerMeter());
+            Assert.Equal(TorquePerLength<double>.FromTonneForceMillimetersPerMeter(2), 2.TonneForceMillimetersPerMeter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTurbidityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTurbidityExtensionsTest.g.cs
index 139508cfb1..7395a32eb8 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTurbidityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTurbidityExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToTurbidityExtensionsTests
     {
         [Fact]
         public void NumberToNTUTest() =>
-            Assert.Equal(Turbidity.FromNTU(2), 2.NTU());
+            Assert.Equal(Turbidity<double>.FromNTU(2), 2.NTU());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs
index 8db270be0c..30386e71eb 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs
@@ -21,12 +21,12 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToVitaminAExtensionsTests
     {
         [Fact]
         public void NumberToInternationalUnitsTest() =>
-            Assert.Equal(VitaminA.FromInternationalUnits(2), 2.InternationalUnits());
+            Assert.Equal(VitaminA<double>.FromInternationalUnits(2), 2.InternationalUnits());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs
index 2fe16bdcdf..ac762ce5e9 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs
@@ -21,88 +21,88 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToVolumeConcentrationExtensionsTests
     {
         [Fact]
         public void NumberToCentilitersPerLiterTest() =>
-            Assert.Equal(VolumeConcentration.FromCentilitersPerLiter(2), 2.CentilitersPerLiter());
+            Assert.Equal(VolumeConcentration<double>.FromCentilitersPerLiter(2), 2.CentilitersPerLiter());
 
         [Fact]
         public void NumberToCentilitersPerMililiterTest() =>
-            Assert.Equal(VolumeConcentration.FromCentilitersPerMililiter(2), 2.CentilitersPerMililiter());
+            Assert.Equal(VolumeConcentration<double>.FromCentilitersPerMililiter(2), 2.CentilitersPerMililiter());
 
         [Fact]
         public void NumberToDecilitersPerLiterTest() =>
-            Assert.Equal(VolumeConcentration.FromDecilitersPerLiter(2), 2.DecilitersPerLiter());
+            Assert.Equal(VolumeConcentration<double>.FromDecilitersPerLiter(2), 2.DecilitersPerLiter());
 
         [Fact]
         public void NumberToDecilitersPerMililiterTest() =>
-            Assert.Equal(VolumeConcentration.FromDecilitersPerMililiter(2), 2.DecilitersPerMililiter());
+            Assert.Equal(VolumeConcentration<double>.FromDecilitersPerMililiter(2), 2.DecilitersPerMililiter());
 
         [Fact]
         public void NumberToDecimalFractionsTest() =>
-            Assert.Equal(VolumeConcentration.FromDecimalFractions(2), 2.DecimalFractions());
+            Assert.Equal(VolumeConcentration<double>.FromDecimalFractions(2), 2.DecimalFractions());
 
         [Fact]
         public void NumberToLitersPerLiterTest() =>
-            Assert.Equal(VolumeConcentration.FromLitersPerLiter(2), 2.LitersPerLiter());
+            Assert.Equal(VolumeConcentration<double>.FromLitersPerLiter(2), 2.LitersPerLiter());
 
         [Fact]
         public void NumberToLitersPerMililiterTest() =>
-            Assert.Equal(VolumeConcentration.FromLitersPerMililiter(2), 2.LitersPerMililiter());
+            Assert.Equal(VolumeConcentration<double>.FromLitersPerMililiter(2), 2.LitersPerMililiter());
 
         [Fact]
         public void NumberToMicrolitersPerLiterTest() =>
-            Assert.Equal(VolumeConcentration.FromMicrolitersPerLiter(2), 2.MicrolitersPerLiter());
+            Assert.Equal(VolumeConcentration<double>.FromMicrolitersPerLiter(2), 2.MicrolitersPerLiter());
 
         [Fact]
         public void NumberToMicrolitersPerMililiterTest() =>
-            Assert.Equal(VolumeConcentration.FromMicrolitersPerMililiter(2), 2.MicrolitersPerMililiter());
+            Assert.Equal(VolumeConcentration<double>.FromMicrolitersPerMililiter(2), 2.MicrolitersPerMililiter());
 
         [Fact]
         public void NumberToMillilitersPerLiterTest() =>
-            Assert.Equal(VolumeConcentration.FromMillilitersPerLiter(2), 2.MillilitersPerLiter());
+            Assert.Equal(VolumeConcentration<double>.FromMillilitersPerLiter(2), 2.MillilitersPerLiter());
 
         [Fact]
         public void NumberToMillilitersPerMililiterTest() =>
-            Assert.Equal(VolumeConcentration.FromMillilitersPerMililiter(2), 2.MillilitersPerMililiter());
+            Assert.Equal(VolumeConcentration<double>.FromMillilitersPerMililiter(2), 2.MillilitersPerMililiter());
 
         [Fact]
         public void NumberToNanolitersPerLiterTest() =>
-            Assert.Equal(VolumeConcentration.FromNanolitersPerLiter(2), 2.NanolitersPerLiter());
+            Assert.Equal(VolumeConcentration<double>.FromNanolitersPerLiter(2), 2.NanolitersPerLiter());
 
         [Fact]
         public void NumberToNanolitersPerMililiterTest() =>
-            Assert.Equal(VolumeConcentration.FromNanolitersPerMililiter(2), 2.NanolitersPerMililiter());
+            Assert.Equal(VolumeConcentration<double>.FromNanolitersPerMililiter(2), 2.NanolitersPerMililiter());
 
         [Fact]
         public void NumberToPartsPerBillionTest() =>
-            Assert.Equal(VolumeConcentration.FromPartsPerBillion(2), 2.PartsPerBillion());
+            Assert.Equal(VolumeConcentration<double>.FromPartsPerBillion(2), 2.PartsPerBillion());
 
         [Fact]
         public void NumberToPartsPerMillionTest() =>
-            Assert.Equal(VolumeConcentration.FromPartsPerMillion(2), 2.PartsPerMillion());
+            Assert.Equal(VolumeConcentration<double>.FromPartsPerMillion(2), 2.PartsPerMillion());
 
         [Fact]
         public void NumberToPartsPerThousandTest() =>
-            Assert.Equal(VolumeConcentration.FromPartsPerThousand(2), 2.PartsPerThousand());
+            Assert.Equal(VolumeConcentration<double>.FromPartsPerThousand(2), 2.PartsPerThousand());
 
         [Fact]
         public void NumberToPartsPerTrillionTest() =>
-            Assert.Equal(VolumeConcentration.FromPartsPerTrillion(2), 2.PartsPerTrillion());
+            Assert.Equal(VolumeConcentration<double>.FromPartsPerTrillion(2), 2.PartsPerTrillion());
 
         [Fact]
         public void NumberToPercentTest() =>
-            Assert.Equal(VolumeConcentration.FromPercent(2), 2.Percent());
+            Assert.Equal(VolumeConcentration<double>.FromPercent(2), 2.Percent());
 
         [Fact]
         public void NumberToPicolitersPerLiterTest() =>
-            Assert.Equal(VolumeConcentration.FromPicolitersPerLiter(2), 2.PicolitersPerLiter());
+            Assert.Equal(VolumeConcentration<double>.FromPicolitersPerLiter(2), 2.PicolitersPerLiter());
 
         [Fact]
         public void NumberToPicolitersPerMililiterTest() =>
-            Assert.Equal(VolumeConcentration.FromPicolitersPerMililiter(2), 2.PicolitersPerMililiter());
+            Assert.Equal(VolumeConcentration<double>.FromPicolitersPerMililiter(2), 2.PicolitersPerMililiter());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
index e157164a66..f338b078d1 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
@@ -21,212 +21,212 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToVolumeExtensionsTests
     {
         [Fact]
         public void NumberToAcreFeetTest() =>
-            Assert.Equal(Volume.FromAcreFeet(2), 2.AcreFeet());
+            Assert.Equal(Volume<double>.FromAcreFeet(2), 2.AcreFeet());
 
         [Fact]
         public void NumberToAuTablespoonsTest() =>
-            Assert.Equal(Volume.FromAuTablespoons(2), 2.AuTablespoons());
+            Assert.Equal(Volume<double>.FromAuTablespoons(2), 2.AuTablespoons());
 
         [Fact]
         public void NumberToBoardFeetTest() =>
-            Assert.Equal(Volume.FromBoardFeet(2), 2.BoardFeet());
+            Assert.Equal(Volume<double>.FromBoardFeet(2), 2.BoardFeet());
 
         [Fact]
         public void NumberToCentilitersTest() =>
-            Assert.Equal(Volume.FromCentiliters(2), 2.Centiliters());
+            Assert.Equal(Volume<double>.FromCentiliters(2), 2.Centiliters());
 
         [Fact]
         public void NumberToCubicCentimetersTest() =>
-            Assert.Equal(Volume.FromCubicCentimeters(2), 2.CubicCentimeters());
+            Assert.Equal(Volume<double>.FromCubicCentimeters(2), 2.CubicCentimeters());
 
         [Fact]
         public void NumberToCubicDecimetersTest() =>
-            Assert.Equal(Volume.FromCubicDecimeters(2), 2.CubicDecimeters());
+            Assert.Equal(Volume<double>.FromCubicDecimeters(2), 2.CubicDecimeters());
 
         [Fact]
         public void NumberToCubicFeetTest() =>
-            Assert.Equal(Volume.FromCubicFeet(2), 2.CubicFeet());
+            Assert.Equal(Volume<double>.FromCubicFeet(2), 2.CubicFeet());
 
         [Fact]
         public void NumberToCubicHectometersTest() =>
-            Assert.Equal(Volume.FromCubicHectometers(2), 2.CubicHectometers());
+            Assert.Equal(Volume<double>.FromCubicHectometers(2), 2.CubicHectometers());
 
         [Fact]
         public void NumberToCubicInchesTest() =>
-            Assert.Equal(Volume.FromCubicInches(2), 2.CubicInches());
+            Assert.Equal(Volume<double>.FromCubicInches(2), 2.CubicInches());
 
         [Fact]
         public void NumberToCubicKilometersTest() =>
-            Assert.Equal(Volume.FromCubicKilometers(2), 2.CubicKilometers());
+            Assert.Equal(Volume<double>.FromCubicKilometers(2), 2.CubicKilometers());
 
         [Fact]
         public void NumberToCubicMetersTest() =>
-            Assert.Equal(Volume.FromCubicMeters(2), 2.CubicMeters());
+            Assert.Equal(Volume<double>.FromCubicMeters(2), 2.CubicMeters());
 
         [Fact]
         public void NumberToCubicMicrometersTest() =>
-            Assert.Equal(Volume.FromCubicMicrometers(2), 2.CubicMicrometers());
+            Assert.Equal(Volume<double>.FromCubicMicrometers(2), 2.CubicMicrometers());
 
         [Fact]
         public void NumberToCubicMilesTest() =>
-            Assert.Equal(Volume.FromCubicMiles(2), 2.CubicMiles());
+            Assert.Equal(Volume<double>.FromCubicMiles(2), 2.CubicMiles());
 
         [Fact]
         public void NumberToCubicMillimetersTest() =>
-            Assert.Equal(Volume.FromCubicMillimeters(2), 2.CubicMillimeters());
+            Assert.Equal(Volume<double>.FromCubicMillimeters(2), 2.CubicMillimeters());
 
         [Fact]
         public void NumberToCubicYardsTest() =>
-            Assert.Equal(Volume.FromCubicYards(2), 2.CubicYards());
+            Assert.Equal(Volume<double>.FromCubicYards(2), 2.CubicYards());
 
         [Fact]
         public void NumberToDecausGallonsTest() =>
-            Assert.Equal(Volume.FromDecausGallons(2), 2.DecausGallons());
+            Assert.Equal(Volume<double>.FromDecausGallons(2), 2.DecausGallons());
 
         [Fact]
         public void NumberToDecilitersTest() =>
-            Assert.Equal(Volume.FromDeciliters(2), 2.Deciliters());
+            Assert.Equal(Volume<double>.FromDeciliters(2), 2.Deciliters());
 
         [Fact]
         public void NumberToDeciusGallonsTest() =>
-            Assert.Equal(Volume.FromDeciusGallons(2), 2.DeciusGallons());
+            Assert.Equal(Volume<double>.FromDeciusGallons(2), 2.DeciusGallons());
 
         [Fact]
         public void NumberToHectocubicFeetTest() =>
-            Assert.Equal(Volume.FromHectocubicFeet(2), 2.HectocubicFeet());
+            Assert.Equal(Volume<double>.FromHectocubicFeet(2), 2.HectocubicFeet());
 
         [Fact]
         public void NumberToHectocubicMetersTest() =>
-            Assert.Equal(Volume.FromHectocubicMeters(2), 2.HectocubicMeters());
+            Assert.Equal(Volume<double>.FromHectocubicMeters(2), 2.HectocubicMeters());
 
         [Fact]
         public void NumberToHectolitersTest() =>
-            Assert.Equal(Volume.FromHectoliters(2), 2.Hectoliters());
+            Assert.Equal(Volume<double>.FromHectoliters(2), 2.Hectoliters());
 
         [Fact]
         public void NumberToHectousGallonsTest() =>
-            Assert.Equal(Volume.FromHectousGallons(2), 2.HectousGallons());
+            Assert.Equal(Volume<double>.FromHectousGallons(2), 2.HectousGallons());
 
         [Fact]
         public void NumberToImperialBeerBarrelsTest() =>
-            Assert.Equal(Volume.FromImperialBeerBarrels(2), 2.ImperialBeerBarrels());
+            Assert.Equal(Volume<double>.FromImperialBeerBarrels(2), 2.ImperialBeerBarrels());
 
         [Fact]
         public void NumberToImperialGallonsTest() =>
-            Assert.Equal(Volume.FromImperialGallons(2), 2.ImperialGallons());
+            Assert.Equal(Volume<double>.FromImperialGallons(2), 2.ImperialGallons());
 
         [Fact]
         public void NumberToImperialOuncesTest() =>
-            Assert.Equal(Volume.FromImperialOunces(2), 2.ImperialOunces());
+            Assert.Equal(Volume<double>.FromImperialOunces(2), 2.ImperialOunces());
 
         [Fact]
         public void NumberToImperialPintsTest() =>
-            Assert.Equal(Volume.FromImperialPints(2), 2.ImperialPints());
+            Assert.Equal(Volume<double>.FromImperialPints(2), 2.ImperialPints());
 
         [Fact]
         public void NumberToKilocubicFeetTest() =>
-            Assert.Equal(Volume.FromKilocubicFeet(2), 2.KilocubicFeet());
+            Assert.Equal(Volume<double>.FromKilocubicFeet(2), 2.KilocubicFeet());
 
         [Fact]
         public void NumberToKilocubicMetersTest() =>
-            Assert.Equal(Volume.FromKilocubicMeters(2), 2.KilocubicMeters());
+            Assert.Equal(Volume<double>.FromKilocubicMeters(2), 2.KilocubicMeters());
 
         [Fact]
         public void NumberToKiloimperialGallonsTest() =>
-            Assert.Equal(Volume.FromKiloimperialGallons(2), 2.KiloimperialGallons());
+            Assert.Equal(Volume<double>.FromKiloimperialGallons(2), 2.KiloimperialGallons());
 
         [Fact]
         public void NumberToKilolitersTest() =>
-            Assert.Equal(Volume.FromKiloliters(2), 2.Kiloliters());
+            Assert.Equal(Volume<double>.FromKiloliters(2), 2.Kiloliters());
 
         [Fact]
         public void NumberToKilousGallonsTest() =>
-            Assert.Equal(Volume.FromKilousGallons(2), 2.KilousGallons());
+            Assert.Equal(Volume<double>.FromKilousGallons(2), 2.KilousGallons());
 
         [Fact]
         public void NumberToLitersTest() =>
-            Assert.Equal(Volume.FromLiters(2), 2.Liters());
+            Assert.Equal(Volume<double>.FromLiters(2), 2.Liters());
 
         [Fact]
         public void NumberToMegacubicFeetTest() =>
-            Assert.Equal(Volume.FromMegacubicFeet(2), 2.MegacubicFeet());
+            Assert.Equal(Volume<double>.FromMegacubicFeet(2), 2.MegacubicFeet());
 
         [Fact]
         public void NumberToMegaimperialGallonsTest() =>
-            Assert.Equal(Volume.FromMegaimperialGallons(2), 2.MegaimperialGallons());
+            Assert.Equal(Volume<double>.FromMegaimperialGallons(2), 2.MegaimperialGallons());
 
         [Fact]
         public void NumberToMegalitersTest() =>
-            Assert.Equal(Volume.FromMegaliters(2), 2.Megaliters());
+            Assert.Equal(Volume<double>.FromMegaliters(2), 2.Megaliters());
 
         [Fact]
         public void NumberToMegausGallonsTest() =>
-            Assert.Equal(Volume.FromMegausGallons(2), 2.MegausGallons());
+            Assert.Equal(Volume<double>.FromMegausGallons(2), 2.MegausGallons());
 
         [Fact]
         public void NumberToMetricCupsTest() =>
-            Assert.Equal(Volume.FromMetricCups(2), 2.MetricCups());
+            Assert.Equal(Volume<double>.FromMetricCups(2), 2.MetricCups());
 
         [Fact]
         public void NumberToMetricTeaspoonsTest() =>
-            Assert.Equal(Volume.FromMetricTeaspoons(2), 2.MetricTeaspoons());
+            Assert.Equal(Volume<double>.FromMetricTeaspoons(2), 2.MetricTeaspoons());
 
         [Fact]
         public void NumberToMicrolitersTest() =>
-            Assert.Equal(Volume.FromMicroliters(2), 2.Microliters());
+            Assert.Equal(Volume<double>.FromMicroliters(2), 2.Microliters());
 
         [Fact]
         public void NumberToMillilitersTest() =>
-            Assert.Equal(Volume.FromMilliliters(2), 2.Milliliters());
+            Assert.Equal(Volume<double>.FromMilliliters(2), 2.Milliliters());
 
         [Fact]
         public void NumberToOilBarrelsTest() =>
-            Assert.Equal(Volume.FromOilBarrels(2), 2.OilBarrels());
+            Assert.Equal(Volume<double>.FromOilBarrels(2), 2.OilBarrels());
 
         [Fact]
         public void NumberToUkTablespoonsTest() =>
-            Assert.Equal(Volume.FromUkTablespoons(2), 2.UkTablespoons());
+            Assert.Equal(Volume<double>.FromUkTablespoons(2), 2.UkTablespoons());
 
         [Fact]
         public void NumberToUsBeerBarrelsTest() =>
-            Assert.Equal(Volume.FromUsBeerBarrels(2), 2.UsBeerBarrels());
+            Assert.Equal(Volume<double>.FromUsBeerBarrels(2), 2.UsBeerBarrels());
 
         [Fact]
         public void NumberToUsCustomaryCupsTest() =>
-            Assert.Equal(Volume.FromUsCustomaryCups(2), 2.UsCustomaryCups());
+            Assert.Equal(Volume<double>.FromUsCustomaryCups(2), 2.UsCustomaryCups());
 
         [Fact]
         public void NumberToUsGallonsTest() =>
-            Assert.Equal(Volume.FromUsGallons(2), 2.UsGallons());
+            Assert.Equal(Volume<double>.FromUsGallons(2), 2.UsGallons());
 
         [Fact]
         public void NumberToUsLegalCupsTest() =>
-            Assert.Equal(Volume.FromUsLegalCups(2), 2.UsLegalCups());
+            Assert.Equal(Volume<double>.FromUsLegalCups(2), 2.UsLegalCups());
 
         [Fact]
         public void NumberToUsOuncesTest() =>
-            Assert.Equal(Volume.FromUsOunces(2), 2.UsOunces());
+            Assert.Equal(Volume<double>.FromUsOunces(2), 2.UsOunces());
 
         [Fact]
         public void NumberToUsPintsTest() =>
-            Assert.Equal(Volume.FromUsPints(2), 2.UsPints());
+            Assert.Equal(Volume<double>.FromUsPints(2), 2.UsPints());
 
         [Fact]
         public void NumberToUsQuartsTest() =>
-            Assert.Equal(Volume.FromUsQuarts(2), 2.UsQuarts());
+            Assert.Equal(Volume<double>.FromUsQuarts(2), 2.UsQuarts());
 
         [Fact]
         public void NumberToUsTablespoonsTest() =>
-            Assert.Equal(Volume.FromUsTablespoons(2), 2.UsTablespoons());
+            Assert.Equal(Volume<double>.FromUsTablespoons(2), 2.UsTablespoons());
 
         [Fact]
         public void NumberToUsTeaspoonsTest() =>
-            Assert.Equal(Volume.FromUsTeaspoons(2), 2.UsTeaspoons());
+            Assert.Equal(Volume<double>.FromUsTeaspoons(2), 2.UsTeaspoons());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
index 2aeedf0c9a..a11f2cc276 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
@@ -21,232 +21,232 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToVolumeFlowExtensionsTests
     {
         [Fact]
         public void NumberToAcreFeetPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromAcreFeetPerDay(2), 2.AcreFeetPerDay());
+            Assert.Equal(VolumeFlow<double>.FromAcreFeetPerDay(2), 2.AcreFeetPerDay());
 
         [Fact]
         public void NumberToAcreFeetPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromAcreFeetPerHour(2), 2.AcreFeetPerHour());
+            Assert.Equal(VolumeFlow<double>.FromAcreFeetPerHour(2), 2.AcreFeetPerHour());
 
         [Fact]
         public void NumberToAcreFeetPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromAcreFeetPerMinute(2), 2.AcreFeetPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromAcreFeetPerMinute(2), 2.AcreFeetPerMinute());
 
         [Fact]
         public void NumberToAcreFeetPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromAcreFeetPerSecond(2), 2.AcreFeetPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromAcreFeetPerSecond(2), 2.AcreFeetPerSecond());
 
         [Fact]
         public void NumberToCentilitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromCentilitersPerDay(2), 2.CentilitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromCentilitersPerDay(2), 2.CentilitersPerDay());
 
         [Fact]
         public void NumberToCentilitersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromCentilitersPerMinute(2), 2.CentilitersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromCentilitersPerMinute(2), 2.CentilitersPerMinute());
 
         [Fact]
         public void NumberToCentilitersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromCentilitersPerSecond(2), 2.CentilitersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromCentilitersPerSecond(2), 2.CentilitersPerSecond());
 
         [Fact]
         public void NumberToCubicCentimetersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromCubicCentimetersPerMinute(2), 2.CubicCentimetersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromCubicCentimetersPerMinute(2), 2.CubicCentimetersPerMinute());
 
         [Fact]
         public void NumberToCubicDecimetersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromCubicDecimetersPerMinute(2), 2.CubicDecimetersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromCubicDecimetersPerMinute(2), 2.CubicDecimetersPerMinute());
 
         [Fact]
         public void NumberToCubicFeetPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromCubicFeetPerHour(2), 2.CubicFeetPerHour());
+            Assert.Equal(VolumeFlow<double>.FromCubicFeetPerHour(2), 2.CubicFeetPerHour());
 
         [Fact]
         public void NumberToCubicFeetPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromCubicFeetPerMinute(2), 2.CubicFeetPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromCubicFeetPerMinute(2), 2.CubicFeetPerMinute());
 
         [Fact]
         public void NumberToCubicFeetPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromCubicFeetPerSecond(2), 2.CubicFeetPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromCubicFeetPerSecond(2), 2.CubicFeetPerSecond());
 
         [Fact]
         public void NumberToCubicMetersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromCubicMetersPerDay(2), 2.CubicMetersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerDay(2), 2.CubicMetersPerDay());
 
         [Fact]
         public void NumberToCubicMetersPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromCubicMetersPerHour(2), 2.CubicMetersPerHour());
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerHour(2), 2.CubicMetersPerHour());
 
         [Fact]
         public void NumberToCubicMetersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromCubicMetersPerMinute(2), 2.CubicMetersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerMinute(2), 2.CubicMetersPerMinute());
 
         [Fact]
         public void NumberToCubicMetersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(2), 2.CubicMetersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerSecond(2), 2.CubicMetersPerSecond());
 
         [Fact]
         public void NumberToCubicMillimetersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromCubicMillimetersPerSecond(2), 2.CubicMillimetersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromCubicMillimetersPerSecond(2), 2.CubicMillimetersPerSecond());
 
         [Fact]
         public void NumberToCubicYardsPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromCubicYardsPerDay(2), 2.CubicYardsPerDay());
+            Assert.Equal(VolumeFlow<double>.FromCubicYardsPerDay(2), 2.CubicYardsPerDay());
 
         [Fact]
         public void NumberToCubicYardsPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromCubicYardsPerHour(2), 2.CubicYardsPerHour());
+            Assert.Equal(VolumeFlow<double>.FromCubicYardsPerHour(2), 2.CubicYardsPerHour());
 
         [Fact]
         public void NumberToCubicYardsPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromCubicYardsPerMinute(2), 2.CubicYardsPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromCubicYardsPerMinute(2), 2.CubicYardsPerMinute());
 
         [Fact]
         public void NumberToCubicYardsPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromCubicYardsPerSecond(2), 2.CubicYardsPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromCubicYardsPerSecond(2), 2.CubicYardsPerSecond());
 
         [Fact]
         public void NumberToDecilitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromDecilitersPerDay(2), 2.DecilitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromDecilitersPerDay(2), 2.DecilitersPerDay());
 
         [Fact]
         public void NumberToDecilitersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromDecilitersPerMinute(2), 2.DecilitersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromDecilitersPerMinute(2), 2.DecilitersPerMinute());
 
         [Fact]
         public void NumberToDecilitersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromDecilitersPerSecond(2), 2.DecilitersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromDecilitersPerSecond(2), 2.DecilitersPerSecond());
 
         [Fact]
         public void NumberToKilolitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromKilolitersPerDay(2), 2.KilolitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromKilolitersPerDay(2), 2.KilolitersPerDay());
 
         [Fact]
         public void NumberToKilolitersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromKilolitersPerMinute(2), 2.KilolitersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromKilolitersPerMinute(2), 2.KilolitersPerMinute());
 
         [Fact]
         public void NumberToKilolitersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromKilolitersPerSecond(2), 2.KilolitersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromKilolitersPerSecond(2), 2.KilolitersPerSecond());
 
         [Fact]
         public void NumberToKilousGallonsPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromKilousGallonsPerMinute(2), 2.KilousGallonsPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromKilousGallonsPerMinute(2), 2.KilousGallonsPerMinute());
 
         [Fact]
         public void NumberToLitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromLitersPerDay(2), 2.LitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromLitersPerDay(2), 2.LitersPerDay());
 
         [Fact]
         public void NumberToLitersPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromLitersPerHour(2), 2.LitersPerHour());
+            Assert.Equal(VolumeFlow<double>.FromLitersPerHour(2), 2.LitersPerHour());
 
         [Fact]
         public void NumberToLitersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromLitersPerMinute(2), 2.LitersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromLitersPerMinute(2), 2.LitersPerMinute());
 
         [Fact]
         public void NumberToLitersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromLitersPerSecond(2), 2.LitersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromLitersPerSecond(2), 2.LitersPerSecond());
 
         [Fact]
         public void NumberToMegalitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromMegalitersPerDay(2), 2.MegalitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromMegalitersPerDay(2), 2.MegalitersPerDay());
 
         [Fact]
         public void NumberToMegaukGallonsPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromMegaukGallonsPerSecond(2), 2.MegaukGallonsPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromMegaukGallonsPerSecond(2), 2.MegaukGallonsPerSecond());
 
         [Fact]
         public void NumberToMicrolitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromMicrolitersPerDay(2), 2.MicrolitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromMicrolitersPerDay(2), 2.MicrolitersPerDay());
 
         [Fact]
         public void NumberToMicrolitersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromMicrolitersPerMinute(2), 2.MicrolitersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromMicrolitersPerMinute(2), 2.MicrolitersPerMinute());
 
         [Fact]
         public void NumberToMicrolitersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromMicrolitersPerSecond(2), 2.MicrolitersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromMicrolitersPerSecond(2), 2.MicrolitersPerSecond());
 
         [Fact]
         public void NumberToMillilitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromMillilitersPerDay(2), 2.MillilitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromMillilitersPerDay(2), 2.MillilitersPerDay());
 
         [Fact]
         public void NumberToMillilitersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromMillilitersPerMinute(2), 2.MillilitersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromMillilitersPerMinute(2), 2.MillilitersPerMinute());
 
         [Fact]
         public void NumberToMillilitersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromMillilitersPerSecond(2), 2.MillilitersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromMillilitersPerSecond(2), 2.MillilitersPerSecond());
 
         [Fact]
         public void NumberToMillionUsGallonsPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromMillionUsGallonsPerDay(2), 2.MillionUsGallonsPerDay());
+            Assert.Equal(VolumeFlow<double>.FromMillionUsGallonsPerDay(2), 2.MillionUsGallonsPerDay());
 
         [Fact]
         public void NumberToNanolitersPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromNanolitersPerDay(2), 2.NanolitersPerDay());
+            Assert.Equal(VolumeFlow<double>.FromNanolitersPerDay(2), 2.NanolitersPerDay());
 
         [Fact]
         public void NumberToNanolitersPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromNanolitersPerMinute(2), 2.NanolitersPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromNanolitersPerMinute(2), 2.NanolitersPerMinute());
 
         [Fact]
         public void NumberToNanolitersPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromNanolitersPerSecond(2), 2.NanolitersPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromNanolitersPerSecond(2), 2.NanolitersPerSecond());
 
         [Fact]
         public void NumberToOilBarrelsPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromOilBarrelsPerDay(2), 2.OilBarrelsPerDay());
+            Assert.Equal(VolumeFlow<double>.FromOilBarrelsPerDay(2), 2.OilBarrelsPerDay());
 
         [Fact]
         public void NumberToOilBarrelsPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromOilBarrelsPerHour(2), 2.OilBarrelsPerHour());
+            Assert.Equal(VolumeFlow<double>.FromOilBarrelsPerHour(2), 2.OilBarrelsPerHour());
 
         [Fact]
         public void NumberToOilBarrelsPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromOilBarrelsPerMinute(2), 2.OilBarrelsPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromOilBarrelsPerMinute(2), 2.OilBarrelsPerMinute());
 
         [Fact]
         public void NumberToOilBarrelsPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromOilBarrelsPerSecond(2), 2.OilBarrelsPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromOilBarrelsPerSecond(2), 2.OilBarrelsPerSecond());
 
         [Fact]
         public void NumberToUkGallonsPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromUkGallonsPerDay(2), 2.UkGallonsPerDay());
+            Assert.Equal(VolumeFlow<double>.FromUkGallonsPerDay(2), 2.UkGallonsPerDay());
 
         [Fact]
         public void NumberToUkGallonsPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromUkGallonsPerHour(2), 2.UkGallonsPerHour());
+            Assert.Equal(VolumeFlow<double>.FromUkGallonsPerHour(2), 2.UkGallonsPerHour());
 
         [Fact]
         public void NumberToUkGallonsPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromUkGallonsPerMinute(2), 2.UkGallonsPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromUkGallonsPerMinute(2), 2.UkGallonsPerMinute());
 
         [Fact]
         public void NumberToUkGallonsPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromUkGallonsPerSecond(2), 2.UkGallonsPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromUkGallonsPerSecond(2), 2.UkGallonsPerSecond());
 
         [Fact]
         public void NumberToUsGallonsPerDayTest() =>
-            Assert.Equal(VolumeFlow.FromUsGallonsPerDay(2), 2.UsGallonsPerDay());
+            Assert.Equal(VolumeFlow<double>.FromUsGallonsPerDay(2), 2.UsGallonsPerDay());
 
         [Fact]
         public void NumberToUsGallonsPerHourTest() =>
-            Assert.Equal(VolumeFlow.FromUsGallonsPerHour(2), 2.UsGallonsPerHour());
+            Assert.Equal(VolumeFlow<double>.FromUsGallonsPerHour(2), 2.UsGallonsPerHour());
 
         [Fact]
         public void NumberToUsGallonsPerMinuteTest() =>
-            Assert.Equal(VolumeFlow.FromUsGallonsPerMinute(2), 2.UsGallonsPerMinute());
+            Assert.Equal(VolumeFlow<double>.FromUsGallonsPerMinute(2), 2.UsGallonsPerMinute());
 
         [Fact]
         public void NumberToUsGallonsPerSecondTest() =>
-            Assert.Equal(VolumeFlow.FromUsGallonsPerSecond(2), 2.UsGallonsPerSecond());
+            Assert.Equal(VolumeFlow<double>.FromUsGallonsPerSecond(2), 2.UsGallonsPerSecond());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs
index 7ed77c9124..b6fccfc504 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs
@@ -21,36 +21,36 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToVolumePerLengthExtensionsTests
     {
         [Fact]
         public void NumberToCubicMetersPerMeterTest() =>
-            Assert.Equal(VolumePerLength.FromCubicMetersPerMeter(2), 2.CubicMetersPerMeter());
+            Assert.Equal(VolumePerLength<double>.FromCubicMetersPerMeter(2), 2.CubicMetersPerMeter());
 
         [Fact]
         public void NumberToCubicYardsPerFootTest() =>
-            Assert.Equal(VolumePerLength.FromCubicYardsPerFoot(2), 2.CubicYardsPerFoot());
+            Assert.Equal(VolumePerLength<double>.FromCubicYardsPerFoot(2), 2.CubicYardsPerFoot());
 
         [Fact]
         public void NumberToCubicYardsPerUsSurveyFootTest() =>
-            Assert.Equal(VolumePerLength.FromCubicYardsPerUsSurveyFoot(2), 2.CubicYardsPerUsSurveyFoot());
+            Assert.Equal(VolumePerLength<double>.FromCubicYardsPerUsSurveyFoot(2), 2.CubicYardsPerUsSurveyFoot());
 
         [Fact]
         public void NumberToLitersPerKilometerTest() =>
-            Assert.Equal(VolumePerLength.FromLitersPerKilometer(2), 2.LitersPerKilometer());
+            Assert.Equal(VolumePerLength<double>.FromLitersPerKilometer(2), 2.LitersPerKilometer());
 
         [Fact]
         public void NumberToLitersPerMeterTest() =>
-            Assert.Equal(VolumePerLength.FromLitersPerMeter(2), 2.LitersPerMeter());
+            Assert.Equal(VolumePerLength<double>.FromLitersPerMeter(2), 2.LitersPerMeter());
 
         [Fact]
         public void NumberToLitersPerMillimeterTest() =>
-            Assert.Equal(VolumePerLength.FromLitersPerMillimeter(2), 2.LitersPerMillimeter());
+            Assert.Equal(VolumePerLength<double>.FromLitersPerMillimeter(2), 2.LitersPerMillimeter());
 
         [Fact]
         public void NumberToOilBarrelsPerFootTest() =>
-            Assert.Equal(VolumePerLength.FromOilBarrelsPerFoot(2), 2.OilBarrelsPerFoot());
+            Assert.Equal(VolumePerLength<double>.FromOilBarrelsPerFoot(2), 2.OilBarrelsPerFoot());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToWarpingMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToWarpingMomentOfInertiaExtensionsTest.g.cs
index c8f804a162..e8776e487a 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToWarpingMomentOfInertiaExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToWarpingMomentOfInertiaExtensionsTest.g.cs
@@ -21,32 +21,32 @@
 using Xunit;
 
 namespace UnitsNet.Tests
-{    
+{
     public class NumberToWarpingMomentOfInertiaExtensionsTests
     {
         [Fact]
         public void NumberToCentimetersToTheSixthTest() =>
-            Assert.Equal(WarpingMomentOfInertia.FromCentimetersToTheSixth(2), 2.CentimetersToTheSixth());
+            Assert.Equal(WarpingMomentOfInertia<double>.FromCentimetersToTheSixth(2), 2.CentimetersToTheSixth());
 
         [Fact]
         public void NumberToDecimetersToTheSixthTest() =>
-            Assert.Equal(WarpingMomentOfInertia.FromDecimetersToTheSixth(2), 2.DecimetersToTheSixth());
+            Assert.Equal(WarpingMomentOfInertia<double>.FromDecimetersToTheSixth(2), 2.DecimetersToTheSixth());
 
         [Fact]
         public void NumberToFeetToTheSixthTest() =>
-            Assert.Equal(WarpingMomentOfInertia.FromFeetToTheSixth(2), 2.FeetToTheSixth());
+            Assert.Equal(WarpingMomentOfInertia<double>.FromFeetToTheSixth(2), 2.FeetToTheSixth());
 
         [Fact]
         public void NumberToInchesToTheSixthTest() =>
-            Assert.Equal(WarpingMomentOfInertia.FromInchesToTheSixth(2), 2.InchesToTheSixth());
+            Assert.Equal(WarpingMomentOfInertia<double>.FromInchesToTheSixth(2), 2.InchesToTheSixth());
 
         [Fact]
         public void NumberToMetersToTheSixthTest() =>
-            Assert.Equal(WarpingMomentOfInertia.FromMetersToTheSixth(2), 2.MetersToTheSixth());
+            Assert.Equal(WarpingMomentOfInertia<double>.FromMetersToTheSixth(2), 2.MetersToTheSixth());
 
         [Fact]
         public void NumberToMillimetersToTheSixthTest() =>
-            Assert.Equal(WarpingMomentOfInertia.FromMillimetersToTheSixth(2), 2.MillimetersToTheSixth());
+            Assert.Equal(WarpingMomentOfInertia<double>.FromMillimetersToTheSixth(2), 2.MillimetersToTheSixth());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
index c0e6e96b35..e7a60e5dc8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
@@ -28,61 +28,61 @@ namespace UnitsNet.NumberExtensions.NumberToAcceleration
     /// </summary>
     public static class NumberToAccelerationExtensions
     {
-        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration CentimetersPerSecondSquared<T>(this T value) =>
-            Acceleration.FromCentimetersPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromCentimetersPerSecondSquared(T)" />
+        public static Acceleration<double> CentimetersPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromCentimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration DecimetersPerSecondSquared<T>(this T value) =>
-            Acceleration.FromDecimetersPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromDecimetersPerSecondSquared(T)" />
+        public static Acceleration<double> DecimetersPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromDecimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration FeetPerSecondSquared<T>(this T value) =>
-            Acceleration.FromFeetPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromFeetPerSecondSquared(T)" />
+        public static Acceleration<double> FeetPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromFeetPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration InchesPerSecondSquared<T>(this T value) =>
-            Acceleration.FromInchesPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromInchesPerSecondSquared(T)" />
+        public static Acceleration<double> InchesPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromInchesPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration KilometersPerSecondSquared<T>(this T value) =>
-            Acceleration.FromKilometersPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromKilometersPerSecondSquared(T)" />
+        public static Acceleration<double> KilometersPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromKilometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerHour(UnitsNet.QuantityValue)" />
-        public static Acceleration KnotsPerHour<T>(this T value) =>
-            Acceleration.FromKnotsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromKnotsPerHour(T)" />
+        public static Acceleration<double> KnotsPerHour<T>(this T value) =>
+            Acceleration<double>.FromKnotsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(UnitsNet.QuantityValue)" />
-        public static Acceleration KnotsPerMinute<T>(this T value) =>
-            Acceleration.FromKnotsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromKnotsPerMinute(T)" />
+        public static Acceleration<double> KnotsPerMinute<T>(this T value) =>
+            Acceleration<double>.FromKnotsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(UnitsNet.QuantityValue)" />
-        public static Acceleration KnotsPerSecond<T>(this T value) =>
-            Acceleration.FromKnotsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromKnotsPerSecond(T)" />
+        public static Acceleration<double> KnotsPerSecond<T>(this T value) =>
+            Acceleration<double>.FromKnotsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration MetersPerSecondSquared<T>(this T value) =>
-            Acceleration.FromMetersPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromMetersPerSecondSquared(T)" />
+        public static Acceleration<double> MetersPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromMetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration MicrometersPerSecondSquared<T>(this T value) =>
-            Acceleration.FromMicrometersPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromMicrometersPerSecondSquared(T)" />
+        public static Acceleration<double> MicrometersPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromMicrometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration MillimetersPerSecondSquared<T>(this T value) =>
-            Acceleration.FromMillimetersPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromMillimetersPerSecondSquared(T)" />
+        public static Acceleration<double> MillimetersPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromMillimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMillistandardGravity(UnitsNet.QuantityValue)" />
-        public static Acceleration MillistandardGravity<T>(this T value) =>
-            Acceleration.FromMillistandardGravity(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromMillistandardGravity(T)" />
+        public static Acceleration<double> MillistandardGravity<T>(this T value) =>
+            Acceleration<double>.FromMillistandardGravity(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static Acceleration NanometersPerSecondSquared<T>(this T value) =>
-            Acceleration.FromNanometersPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromNanometersPerSecondSquared(T)" />
+        public static Acceleration<double> NanometersPerSecondSquared<T>(this T value) =>
+            Acceleration<double>.FromNanometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromStandardGravity(UnitsNet.QuantityValue)" />
-        public static Acceleration StandardGravity<T>(this T value) =>
-            Acceleration.FromStandardGravity(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration{T}.FromStandardGravity(T)" />
+        public static Acceleration<double> StandardGravity<T>(this T value) =>
+            Acceleration<double>.FromStandardGravity(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
index bed53ac973..11bfefd679 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
@@ -28,65 +28,65 @@ namespace UnitsNet.NumberExtensions.NumberToAmountOfSubstance
     /// </summary>
     public static class NumberToAmountOfSubstanceExtensions
     {
-        /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Centimoles<T>(this T value) =>
-            AmountOfSubstance.FromCentimoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromCentimoles(T)" />
+        public static AmountOfSubstance<double> Centimoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromCentimoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance CentipoundMoles<T>(this T value) =>
-            AmountOfSubstance.FromCentipoundMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromCentipoundMoles(T)" />
+        public static AmountOfSubstance<double> CentipoundMoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromCentipoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Decimoles<T>(this T value) =>
-            AmountOfSubstance.FromDecimoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromDecimoles(T)" />
+        public static AmountOfSubstance<double> Decimoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromDecimoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance DecipoundMoles<T>(this T value) =>
-            AmountOfSubstance.FromDecipoundMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromDecipoundMoles(T)" />
+        public static AmountOfSubstance<double> DecipoundMoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromDecipoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Kilomoles<T>(this T value) =>
-            AmountOfSubstance.FromKilomoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromKilomoles(T)" />
+        public static AmountOfSubstance<double> Kilomoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromKilomoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance KilopoundMoles<T>(this T value) =>
-            AmountOfSubstance.FromKilopoundMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromKilopoundMoles(T)" />
+        public static AmountOfSubstance<double> KilopoundMoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromKilopoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Megamoles<T>(this T value) =>
-            AmountOfSubstance.FromMegamoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromMegamoles(T)" />
+        public static AmountOfSubstance<double> Megamoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromMegamoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Micromoles<T>(this T value) =>
-            AmountOfSubstance.FromMicromoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromMicromoles(T)" />
+        public static AmountOfSubstance<double> Micromoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromMicromoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance MicropoundMoles<T>(this T value) =>
-            AmountOfSubstance.FromMicropoundMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromMicropoundMoles(T)" />
+        public static AmountOfSubstance<double> MicropoundMoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromMicropoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Millimoles<T>(this T value) =>
-            AmountOfSubstance.FromMillimoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromMillimoles(T)" />
+        public static AmountOfSubstance<double> Millimoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromMillimoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance MillipoundMoles<T>(this T value) =>
-            AmountOfSubstance.FromMillipoundMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromMillipoundMoles(T)" />
+        public static AmountOfSubstance<double> MillipoundMoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromMillipoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Moles<T>(this T value) =>
-            AmountOfSubstance.FromMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromMoles(T)" />
+        public static AmountOfSubstance<double> Moles<T>(this T value) =>
+            AmountOfSubstance<double>.FromMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance Nanomoles<T>(this T value) =>
-            AmountOfSubstance.FromNanomoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromNanomoles(T)" />
+        public static AmountOfSubstance<double> Nanomoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromNanomoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance NanopoundMoles<T>(this T value) =>
-            AmountOfSubstance.FromNanopoundMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromNanopoundMoles(T)" />
+        public static AmountOfSubstance<double> NanopoundMoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromNanopoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(UnitsNet.QuantityValue)" />
-        public static AmountOfSubstance PoundMoles<T>(this T value) =>
-            AmountOfSubstance.FromPoundMoles(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmountOfSubstance{T}.FromPoundMoles(T)" />
+        public static AmountOfSubstance<double> PoundMoles<T>(this T value) =>
+            AmountOfSubstance<double>.FromPoundMoles(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
index a694f8660d..1b0b3be17f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToAmplitudeRatio
     /// </summary>
     public static class NumberToAmplitudeRatioExtensions
     {
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(UnitsNet.QuantityValue)" />
-        public static AmplitudeRatio DecibelMicrovolts<T>(this T value) =>
-            AmplitudeRatio.FromDecibelMicrovolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmplitudeRatio{T}.FromDecibelMicrovolts(T)" />
+        public static AmplitudeRatio<double> DecibelMicrovolts<T>(this T value) =>
+            AmplitudeRatio<double>.FromDecibelMicrovolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(UnitsNet.QuantityValue)" />
-        public static AmplitudeRatio DecibelMillivolts<T>(this T value) =>
-            AmplitudeRatio.FromDecibelMillivolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmplitudeRatio{T}.FromDecibelMillivolts(T)" />
+        public static AmplitudeRatio<double> DecibelMillivolts<T>(this T value) =>
+            AmplitudeRatio<double>.FromDecibelMillivolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(UnitsNet.QuantityValue)" />
-        public static AmplitudeRatio DecibelsUnloaded<T>(this T value) =>
-            AmplitudeRatio.FromDecibelsUnloaded(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmplitudeRatio{T}.FromDecibelsUnloaded(T)" />
+        public static AmplitudeRatio<double> DecibelsUnloaded<T>(this T value) =>
+            AmplitudeRatio<double>.FromDecibelsUnloaded(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(UnitsNet.QuantityValue)" />
-        public static AmplitudeRatio DecibelVolts<T>(this T value) =>
-            AmplitudeRatio.FromDecibelVolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="AmplitudeRatio{T}.FromDecibelVolts(T)" />
+        public static AmplitudeRatio<double> DecibelVolts<T>(this T value) =>
+            AmplitudeRatio<double>.FromDecibelVolts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
index 42404c0baa..2f235d28ff 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
@@ -28,61 +28,61 @@ namespace UnitsNet.NumberExtensions.NumberToAngle
     /// </summary>
     public static class NumberToAngleExtensions
     {
-        /// <inheritdoc cref="Angle.FromArcminutes(UnitsNet.QuantityValue)" />
-        public static Angle Arcminutes<T>(this T value) =>
-            Angle.FromArcminutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromArcminutes(T)" />
+        public static Angle<double> Arcminutes<T>(this T value) =>
+            Angle<double>.FromArcminutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromArcseconds(UnitsNet.QuantityValue)" />
-        public static Angle Arcseconds<T>(this T value) =>
-            Angle.FromArcseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromArcseconds(T)" />
+        public static Angle<double> Arcseconds<T>(this T value) =>
+            Angle<double>.FromArcseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromCentiradians(UnitsNet.QuantityValue)" />
-        public static Angle Centiradians<T>(this T value) =>
-            Angle.FromCentiradians(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromCentiradians(T)" />
+        public static Angle<double> Centiradians<T>(this T value) =>
+            Angle<double>.FromCentiradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromDeciradians(UnitsNet.QuantityValue)" />
-        public static Angle Deciradians<T>(this T value) =>
-            Angle.FromDeciradians(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromDeciradians(T)" />
+        public static Angle<double> Deciradians<T>(this T value) =>
+            Angle<double>.FromDeciradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromDegrees(UnitsNet.QuantityValue)" />
-        public static Angle Degrees<T>(this T value) =>
-            Angle.FromDegrees(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromDegrees(T)" />
+        public static Angle<double> Degrees<T>(this T value) =>
+            Angle<double>.FromDegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromGradians(UnitsNet.QuantityValue)" />
-        public static Angle Gradians<T>(this T value) =>
-            Angle.FromGradians(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromGradians(T)" />
+        public static Angle<double> Gradians<T>(this T value) =>
+            Angle<double>.FromGradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMicrodegrees(UnitsNet.QuantityValue)" />
-        public static Angle Microdegrees<T>(this T value) =>
-            Angle.FromMicrodegrees(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromMicrodegrees(T)" />
+        public static Angle<double> Microdegrees<T>(this T value) =>
+            Angle<double>.FromMicrodegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMicroradians(UnitsNet.QuantityValue)" />
-        public static Angle Microradians<T>(this T value) =>
-            Angle.FromMicroradians(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromMicroradians(T)" />
+        public static Angle<double> Microradians<T>(this T value) =>
+            Angle<double>.FromMicroradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMillidegrees(UnitsNet.QuantityValue)" />
-        public static Angle Millidegrees<T>(this T value) =>
-            Angle.FromMillidegrees(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromMillidegrees(T)" />
+        public static Angle<double> Millidegrees<T>(this T value) =>
+            Angle<double>.FromMillidegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMilliradians(UnitsNet.QuantityValue)" />
-        public static Angle Milliradians<T>(this T value) =>
-            Angle.FromMilliradians(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromMilliradians(T)" />
+        public static Angle<double> Milliradians<T>(this T value) =>
+            Angle<double>.FromMilliradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromNanodegrees(UnitsNet.QuantityValue)" />
-        public static Angle Nanodegrees<T>(this T value) =>
-            Angle.FromNanodegrees(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromNanodegrees(T)" />
+        public static Angle<double> Nanodegrees<T>(this T value) =>
+            Angle<double>.FromNanodegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromNanoradians(UnitsNet.QuantityValue)" />
-        public static Angle Nanoradians<T>(this T value) =>
-            Angle.FromNanoradians(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromNanoradians(T)" />
+        public static Angle<double> Nanoradians<T>(this T value) =>
+            Angle<double>.FromNanoradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromRadians(UnitsNet.QuantityValue)" />
-        public static Angle Radians<T>(this T value) =>
-            Angle.FromRadians(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromRadians(T)" />
+        public static Angle<double> Radians<T>(this T value) =>
+            Angle<double>.FromRadians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromRevolutions(UnitsNet.QuantityValue)" />
-        public static Angle Revolutions<T>(this T value) =>
-            Angle.FromRevolutions(Convert.ToDouble(value));
+        /// <inheritdoc cref="Angle{T}.FromRevolutions(T)" />
+        public static Angle<double> Revolutions<T>(this T value) =>
+            Angle<double>.FromRevolutions(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
index 4057b6edd8..ca8b799bef 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToApparentEnergy
     /// </summary>
     public static class NumberToApparentEnergyExtensions
     {
-        /// <inheritdoc cref="ApparentEnergy.FromKilovoltampereHours(UnitsNet.QuantityValue)" />
-        public static ApparentEnergy KilovoltampereHours<T>(this T value) =>
-            ApparentEnergy.FromKilovoltampereHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ApparentEnergy{T}.FromKilovoltampereHours(T)" />
+        public static ApparentEnergy<double> KilovoltampereHours<T>(this T value) =>
+            ApparentEnergy<double>.FromKilovoltampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentEnergy.FromMegavoltampereHours(UnitsNet.QuantityValue)" />
-        public static ApparentEnergy MegavoltampereHours<T>(this T value) =>
-            ApparentEnergy.FromMegavoltampereHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ApparentEnergy{T}.FromMegavoltampereHours(T)" />
+        public static ApparentEnergy<double> MegavoltampereHours<T>(this T value) =>
+            ApparentEnergy<double>.FromMegavoltampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentEnergy.FromVoltampereHours(UnitsNet.QuantityValue)" />
-        public static ApparentEnergy VoltampereHours<T>(this T value) =>
-            ApparentEnergy.FromVoltampereHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ApparentEnergy{T}.FromVoltampereHours(T)" />
+        public static ApparentEnergy<double> VoltampereHours<T>(this T value) =>
+            ApparentEnergy<double>.FromVoltampereHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
index 95751cd60d..46586aeff8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToApparentPower
     /// </summary>
     public static class NumberToApparentPowerExtensions
     {
-        /// <inheritdoc cref="ApparentPower.FromGigavoltamperes(UnitsNet.QuantityValue)" />
-        public static ApparentPower Gigavoltamperes<T>(this T value) =>
-            ApparentPower.FromGigavoltamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ApparentPower{T}.FromGigavoltamperes(T)" />
+        public static ApparentPower<double> Gigavoltamperes<T>(this T value) =>
+            ApparentPower<double>.FromGigavoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromKilovoltamperes(UnitsNet.QuantityValue)" />
-        public static ApparentPower Kilovoltamperes<T>(this T value) =>
-            ApparentPower.FromKilovoltamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ApparentPower{T}.FromKilovoltamperes(T)" />
+        public static ApparentPower<double> Kilovoltamperes<T>(this T value) =>
+            ApparentPower<double>.FromKilovoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromMegavoltamperes(UnitsNet.QuantityValue)" />
-        public static ApparentPower Megavoltamperes<T>(this T value) =>
-            ApparentPower.FromMegavoltamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ApparentPower{T}.FromMegavoltamperes(T)" />
+        public static ApparentPower<double> Megavoltamperes<T>(this T value) =>
+            ApparentPower<double>.FromMegavoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromVoltamperes(UnitsNet.QuantityValue)" />
-        public static ApparentPower Voltamperes<T>(this T value) =>
-            ApparentPower.FromVoltamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ApparentPower{T}.FromVoltamperes(T)" />
+        public static ApparentPower<double> Voltamperes<T>(this T value) =>
+            ApparentPower<double>.FromVoltamperes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
index 7a0eef6f25..68bb5e4012 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToAreaDensity
     /// </summary>
     public static class NumberToAreaDensityExtensions
     {
-        /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static AreaDensity KilogramsPerSquareMeter<T>(this T value) =>
-            AreaDensity.FromKilogramsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="AreaDensity{T}.FromKilogramsPerSquareMeter(T)" />
+        public static AreaDensity<double> KilogramsPerSquareMeter<T>(this T value) =>
+            AreaDensity<double>.FromKilogramsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
index 7cf095da34..f0d4a4ede3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
@@ -28,61 +28,61 @@ namespace UnitsNet.NumberExtensions.NumberToArea
     /// </summary>
     public static class NumberToAreaExtensions
     {
-        /// <inheritdoc cref="Area.FromAcres(UnitsNet.QuantityValue)" />
-        public static Area Acres<T>(this T value) =>
-            Area.FromAcres(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromAcres(T)" />
+        public static Area<double> Acres<T>(this T value) =>
+            Area<double>.FromAcres(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromHectares(UnitsNet.QuantityValue)" />
-        public static Area Hectares<T>(this T value) =>
-            Area.FromHectares(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromHectares(T)" />
+        public static Area<double> Hectares<T>(this T value) =>
+            Area<double>.FromHectares(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareCentimeters(UnitsNet.QuantityValue)" />
-        public static Area SquareCentimeters<T>(this T value) =>
-            Area.FromSquareCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareCentimeters(T)" />
+        public static Area<double> SquareCentimeters<T>(this T value) =>
+            Area<double>.FromSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareDecimeters(UnitsNet.QuantityValue)" />
-        public static Area SquareDecimeters<T>(this T value) =>
-            Area.FromSquareDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareDecimeters(T)" />
+        public static Area<double> SquareDecimeters<T>(this T value) =>
+            Area<double>.FromSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareFeet(UnitsNet.QuantityValue)" />
-        public static Area SquareFeet<T>(this T value) =>
-            Area.FromSquareFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareFeet(T)" />
+        public static Area<double> SquareFeet<T>(this T value) =>
+            Area<double>.FromSquareFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareInches(UnitsNet.QuantityValue)" />
-        public static Area SquareInches<T>(this T value) =>
-            Area.FromSquareInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareInches(T)" />
+        public static Area<double> SquareInches<T>(this T value) =>
+            Area<double>.FromSquareInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareKilometers(UnitsNet.QuantityValue)" />
-        public static Area SquareKilometers<T>(this T value) =>
-            Area.FromSquareKilometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareKilometers(T)" />
+        public static Area<double> SquareKilometers<T>(this T value) =>
+            Area<double>.FromSquareKilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMeters(UnitsNet.QuantityValue)" />
-        public static Area SquareMeters<T>(this T value) =>
-            Area.FromSquareMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareMeters(T)" />
+        public static Area<double> SquareMeters<T>(this T value) =>
+            Area<double>.FromSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMicrometers(UnitsNet.QuantityValue)" />
-        public static Area SquareMicrometers<T>(this T value) =>
-            Area.FromSquareMicrometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareMicrometers(T)" />
+        public static Area<double> SquareMicrometers<T>(this T value) =>
+            Area<double>.FromSquareMicrometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMiles(UnitsNet.QuantityValue)" />
-        public static Area SquareMiles<T>(this T value) =>
-            Area.FromSquareMiles(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareMiles(T)" />
+        public static Area<double> SquareMiles<T>(this T value) =>
+            Area<double>.FromSquareMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMillimeters(UnitsNet.QuantityValue)" />
-        public static Area SquareMillimeters<T>(this T value) =>
-            Area.FromSquareMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareMillimeters(T)" />
+        public static Area<double> SquareMillimeters<T>(this T value) =>
+            Area<double>.FromSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareNauticalMiles(UnitsNet.QuantityValue)" />
-        public static Area SquareNauticalMiles<T>(this T value) =>
-            Area.FromSquareNauticalMiles(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareNauticalMiles(T)" />
+        public static Area<double> SquareNauticalMiles<T>(this T value) =>
+            Area<double>.FromSquareNauticalMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareYards(UnitsNet.QuantityValue)" />
-        public static Area SquareYards<T>(this T value) =>
-            Area.FromSquareYards(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromSquareYards(T)" />
+        public static Area<double> SquareYards<T>(this T value) =>
+            Area<double>.FromSquareYards(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromUsSurveySquareFeet(UnitsNet.QuantityValue)" />
-        public static Area UsSurveySquareFeet<T>(this T value) =>
-            Area.FromUsSurveySquareFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Area{T}.FromUsSurveySquareFeet(T)" />
+        public static Area<double> UsSurveySquareFeet<T>(this T value) =>
+            Area<double>.FromUsSurveySquareFeet(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
index 8b969b6019..9ec44a693d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
@@ -28,29 +28,29 @@ namespace UnitsNet.NumberExtensions.NumberToAreaMomentOfInertia
     /// </summary>
     public static class NumberToAreaMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(UnitsNet.QuantityValue)" />
-        public static AreaMomentOfInertia CentimetersToTheFourth<T>(this T value) =>
-            AreaMomentOfInertia.FromCentimetersToTheFourth(Convert.ToDouble(value));
+        /// <inheritdoc cref="AreaMomentOfInertia{T}.FromCentimetersToTheFourth(T)" />
+        public static AreaMomentOfInertia<double> CentimetersToTheFourth<T>(this T value) =>
+            AreaMomentOfInertia<double>.FromCentimetersToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(UnitsNet.QuantityValue)" />
-        public static AreaMomentOfInertia DecimetersToTheFourth<T>(this T value) =>
-            AreaMomentOfInertia.FromDecimetersToTheFourth(Convert.ToDouble(value));
+        /// <inheritdoc cref="AreaMomentOfInertia{T}.FromDecimetersToTheFourth(T)" />
+        public static AreaMomentOfInertia<double> DecimetersToTheFourth<T>(this T value) =>
+            AreaMomentOfInertia<double>.FromDecimetersToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(UnitsNet.QuantityValue)" />
-        public static AreaMomentOfInertia FeetToTheFourth<T>(this T value) =>
-            AreaMomentOfInertia.FromFeetToTheFourth(Convert.ToDouble(value));
+        /// <inheritdoc cref="AreaMomentOfInertia{T}.FromFeetToTheFourth(T)" />
+        public static AreaMomentOfInertia<double> FeetToTheFourth<T>(this T value) =>
+            AreaMomentOfInertia<double>.FromFeetToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(UnitsNet.QuantityValue)" />
-        public static AreaMomentOfInertia InchesToTheFourth<T>(this T value) =>
-            AreaMomentOfInertia.FromInchesToTheFourth(Convert.ToDouble(value));
+        /// <inheritdoc cref="AreaMomentOfInertia{T}.FromInchesToTheFourth(T)" />
+        public static AreaMomentOfInertia<double> InchesToTheFourth<T>(this T value) =>
+            AreaMomentOfInertia<double>.FromInchesToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(UnitsNet.QuantityValue)" />
-        public static AreaMomentOfInertia MetersToTheFourth<T>(this T value) =>
-            AreaMomentOfInertia.FromMetersToTheFourth(Convert.ToDouble(value));
+        /// <inheritdoc cref="AreaMomentOfInertia{T}.FromMetersToTheFourth(T)" />
+        public static AreaMomentOfInertia<double> MetersToTheFourth<T>(this T value) =>
+            AreaMomentOfInertia<double>.FromMetersToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(UnitsNet.QuantityValue)" />
-        public static AreaMomentOfInertia MillimetersToTheFourth<T>(this T value) =>
-            AreaMomentOfInertia.FromMillimetersToTheFourth(Convert.ToDouble(value));
+        /// <inheritdoc cref="AreaMomentOfInertia{T}.FromMillimetersToTheFourth(T)" />
+        public static AreaMomentOfInertia<double> MillimetersToTheFourth<T>(this T value) =>
+            AreaMomentOfInertia<double>.FromMillimetersToTheFourth(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
index 31a893e811..f56f382182 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
@@ -28,109 +28,109 @@ namespace UnitsNet.NumberExtensions.NumberToBitRate
     /// </summary>
     public static class NumberToBitRateExtensions
     {
-        /// <inheritdoc cref="BitRate.FromBitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate BitsPerSecond<T>(this T value) =>
-            BitRate.FromBitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromBitsPerSecond(T)" />
+        public static BitRate<double> BitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromBitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromBytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate BytesPerSecond<T>(this T value) =>
-            BitRate.FromBytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromBytesPerSecond(T)" />
+        public static BitRate<double> BytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromBytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExabitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate ExabitsPerSecond<T>(this T value) =>
-            BitRate.FromExabitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromExabitsPerSecond(T)" />
+        public static BitRate<double> ExabitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromExabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExabytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate ExabytesPerSecond<T>(this T value) =>
-            BitRate.FromExabytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromExabytesPerSecond(T)" />
+        public static BitRate<double> ExabytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromExabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate ExbibitsPerSecond<T>(this T value) =>
-            BitRate.FromExbibitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromExbibitsPerSecond(T)" />
+        public static BitRate<double> ExbibitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromExbibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate ExbibytesPerSecond<T>(this T value) =>
-            BitRate.FromExbibytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromExbibytesPerSecond(T)" />
+        public static BitRate<double> ExbibytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromExbibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate GibibitsPerSecond<T>(this T value) =>
-            BitRate.FromGibibitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromGibibitsPerSecond(T)" />
+        public static BitRate<double> GibibitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromGibibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate GibibytesPerSecond<T>(this T value) =>
-            BitRate.FromGibibytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromGibibytesPerSecond(T)" />
+        public static BitRate<double> GibibytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromGibibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate GigabitsPerSecond<T>(this T value) =>
-            BitRate.FromGigabitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromGigabitsPerSecond(T)" />
+        public static BitRate<double> GigabitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromGigabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate GigabytesPerSecond<T>(this T value) =>
-            BitRate.FromGigabytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromGigabytesPerSecond(T)" />
+        public static BitRate<double> GigabytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromGigabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate KibibitsPerSecond<T>(this T value) =>
-            BitRate.FromKibibitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromKibibitsPerSecond(T)" />
+        public static BitRate<double> KibibitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromKibibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate KibibytesPerSecond<T>(this T value) =>
-            BitRate.FromKibibytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromKibibytesPerSecond(T)" />
+        public static BitRate<double> KibibytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromKibibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate KilobitsPerSecond<T>(this T value) =>
-            BitRate.FromKilobitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromKilobitsPerSecond(T)" />
+        public static BitRate<double> KilobitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromKilobitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate KilobytesPerSecond<T>(this T value) =>
-            BitRate.FromKilobytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromKilobytesPerSecond(T)" />
+        public static BitRate<double> KilobytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromKilobytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate MebibitsPerSecond<T>(this T value) =>
-            BitRate.FromMebibitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromMebibitsPerSecond(T)" />
+        public static BitRate<double> MebibitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromMebibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate MebibytesPerSecond<T>(this T value) =>
-            BitRate.FromMebibytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromMebibytesPerSecond(T)" />
+        public static BitRate<double> MebibytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromMebibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate MegabitsPerSecond<T>(this T value) =>
-            BitRate.FromMegabitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromMegabitsPerSecond(T)" />
+        public static BitRate<double> MegabitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromMegabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate MegabytesPerSecond<T>(this T value) =>
-            BitRate.FromMegabytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromMegabytesPerSecond(T)" />
+        public static BitRate<double> MegabytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromMegabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate PebibitsPerSecond<T>(this T value) =>
-            BitRate.FromPebibitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromPebibitsPerSecond(T)" />
+        public static BitRate<double> PebibitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromPebibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate PebibytesPerSecond<T>(this T value) =>
-            BitRate.FromPebibytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromPebibytesPerSecond(T)" />
+        public static BitRate<double> PebibytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromPebibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate PetabitsPerSecond<T>(this T value) =>
-            BitRate.FromPetabitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromPetabitsPerSecond(T)" />
+        public static BitRate<double> PetabitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromPetabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate PetabytesPerSecond<T>(this T value) =>
-            BitRate.FromPetabytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromPetabytesPerSecond(T)" />
+        public static BitRate<double> PetabytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromPetabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate TebibitsPerSecond<T>(this T value) =>
-            BitRate.FromTebibitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromTebibitsPerSecond(T)" />
+        public static BitRate<double> TebibitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromTebibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate TebibytesPerSecond<T>(this T value) =>
-            BitRate.FromTebibytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromTebibytesPerSecond(T)" />
+        public static BitRate<double> TebibytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromTebibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate TerabitsPerSecond<T>(this T value) =>
-            BitRate.FromTerabitsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromTerabitsPerSecond(T)" />
+        public static BitRate<double> TerabitsPerSecond<T>(this T value) =>
+            BitRate<double>.FromTerabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(UnitsNet.QuantityValue)" />
-        public static BitRate TerabytesPerSecond<T>(this T value) =>
-            BitRate.FromTerabytesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="BitRate{T}.FromTerabytesPerSecond(T)" />
+        public static BitRate<double> TerabytesPerSecond<T>(this T value) =>
+            BitRate<double>.FromTerabytesPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
index 9f5e229d54..08b25ff880 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToBrakeSpecificFuelConsumption
     /// </summary>
     public static class NumberToBrakeSpecificFuelConsumptionExtensions
     {
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(UnitsNet.QuantityValue)" />
-        public static BrakeSpecificFuelConsumption GramsPerKiloWattHour<T>(this T value) =>
-            BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption{T}.FromGramsPerKiloWattHour(T)" />
+        public static BrakeSpecificFuelConsumption<double> GramsPerKiloWattHour<T>(this T value) =>
+            BrakeSpecificFuelConsumption<double>.FromGramsPerKiloWattHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(UnitsNet.QuantityValue)" />
-        public static BrakeSpecificFuelConsumption KilogramsPerJoule<T>(this T value) =>
-            BrakeSpecificFuelConsumption.FromKilogramsPerJoule(Convert.ToDouble(value));
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption{T}.FromKilogramsPerJoule(T)" />
+        public static BrakeSpecificFuelConsumption<double> KilogramsPerJoule<T>(this T value) =>
+            BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(UnitsNet.QuantityValue)" />
-        public static BrakeSpecificFuelConsumption PoundsPerMechanicalHorsepowerHour<T>(this T value) =>
-            BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption{T}.FromPoundsPerMechanicalHorsepowerHour(T)" />
+        public static BrakeSpecificFuelConsumption<double> PoundsPerMechanicalHorsepowerHour<T>(this T value) =>
+            BrakeSpecificFuelConsumption<double>.FromPoundsPerMechanicalHorsepowerHour(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
index e9e5dd8c49..d266a4b0a1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
@@ -28,33 +28,33 @@ namespace UnitsNet.NumberExtensions.NumberToCapacitance
     /// </summary>
     public static class NumberToCapacitanceExtensions
     {
-        /// <inheritdoc cref="Capacitance.FromFarads(UnitsNet.QuantityValue)" />
-        public static Capacitance Farads<T>(this T value) =>
-            Capacitance.FromFarads(Convert.ToDouble(value));
+        /// <inheritdoc cref="Capacitance{T}.FromFarads(T)" />
+        public static Capacitance<double> Farads<T>(this T value) =>
+            Capacitance<double>.FromFarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromKilofarads(UnitsNet.QuantityValue)" />
-        public static Capacitance Kilofarads<T>(this T value) =>
-            Capacitance.FromKilofarads(Convert.ToDouble(value));
+        /// <inheritdoc cref="Capacitance{T}.FromKilofarads(T)" />
+        public static Capacitance<double> Kilofarads<T>(this T value) =>
+            Capacitance<double>.FromKilofarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromMegafarads(UnitsNet.QuantityValue)" />
-        public static Capacitance Megafarads<T>(this T value) =>
-            Capacitance.FromMegafarads(Convert.ToDouble(value));
+        /// <inheritdoc cref="Capacitance{T}.FromMegafarads(T)" />
+        public static Capacitance<double> Megafarads<T>(this T value) =>
+            Capacitance<double>.FromMegafarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromMicrofarads(UnitsNet.QuantityValue)" />
-        public static Capacitance Microfarads<T>(this T value) =>
-            Capacitance.FromMicrofarads(Convert.ToDouble(value));
+        /// <inheritdoc cref="Capacitance{T}.FromMicrofarads(T)" />
+        public static Capacitance<double> Microfarads<T>(this T value) =>
+            Capacitance<double>.FromMicrofarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromMillifarads(UnitsNet.QuantityValue)" />
-        public static Capacitance Millifarads<T>(this T value) =>
-            Capacitance.FromMillifarads(Convert.ToDouble(value));
+        /// <inheritdoc cref="Capacitance{T}.FromMillifarads(T)" />
+        public static Capacitance<double> Millifarads<T>(this T value) =>
+            Capacitance<double>.FromMillifarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromNanofarads(UnitsNet.QuantityValue)" />
-        public static Capacitance Nanofarads<T>(this T value) =>
-            Capacitance.FromNanofarads(Convert.ToDouble(value));
+        /// <inheritdoc cref="Capacitance{T}.FromNanofarads(T)" />
+        public static Capacitance<double> Nanofarads<T>(this T value) =>
+            Capacitance<double>.FromNanofarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromPicofarads(UnitsNet.QuantityValue)" />
-        public static Capacitance Picofarads<T>(this T value) =>
-            Capacitance.FromPicofarads(Convert.ToDouble(value));
+        /// <inheritdoc cref="Capacitance{T}.FromPicofarads(T)" />
+        public static Capacitance<double> Picofarads<T>(this T value) =>
+            Capacitance<double>.FromPicofarads(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
index b322c0478e..143d6b6318 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToCoefficientOfThermalExpansion
     /// </summary>
     public static class NumberToCoefficientOfThermalExpansionExtensions
     {
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeCelsius(UnitsNet.QuantityValue)" />
-        public static CoefficientOfThermalExpansion InverseDegreeCelsius<T>(this T value) =>
-            CoefficientOfThermalExpansion.FromInverseDegreeCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="CoefficientOfThermalExpansion{T}.FromInverseDegreeCelsius(T)" />
+        public static CoefficientOfThermalExpansion<double> InverseDegreeCelsius<T>(this T value) =>
+            CoefficientOfThermalExpansion<double>.FromInverseDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(UnitsNet.QuantityValue)" />
-        public static CoefficientOfThermalExpansion InverseDegreeFahrenheit<T>(this T value) =>
-            CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(Convert.ToDouble(value));
+        /// <inheritdoc cref="CoefficientOfThermalExpansion{T}.FromInverseDegreeFahrenheit(T)" />
+        public static CoefficientOfThermalExpansion<double> InverseDegreeFahrenheit<T>(this T value) =>
+            CoefficientOfThermalExpansion<double>.FromInverseDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseKelvin(UnitsNet.QuantityValue)" />
-        public static CoefficientOfThermalExpansion InverseKelvin<T>(this T value) =>
-            CoefficientOfThermalExpansion.FromInverseKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="CoefficientOfThermalExpansion{T}.FromInverseKelvin(T)" />
+        public static CoefficientOfThermalExpansion<double> InverseKelvin<T>(this T value) =>
+            CoefficientOfThermalExpansion<double>.FromInverseKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
index 6385b7f766..881b7ca800 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
@@ -28,165 +28,165 @@ namespace UnitsNet.NumberExtensions.NumberToDensity
     /// </summary>
     public static class NumberToDensityExtensions
     {
-        /// <inheritdoc cref="Density.FromCentigramsPerDeciLiter(UnitsNet.QuantityValue)" />
-        public static Density CentigramsPerDeciLiter<T>(this T value) =>
-            Density.FromCentigramsPerDeciLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromCentigramsPerDeciLiter(T)" />
+        public static Density<double> CentigramsPerDeciLiter<T>(this T value) =>
+            Density<double>.FromCentigramsPerDeciLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density CentigramsPerLiter<T>(this T value) =>
-            Density.FromCentigramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromCentigramsPerLiter(T)" />
+        public static Density<double> CentigramsPerLiter<T>(this T value) =>
+            Density<double>.FromCentigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static Density CentigramsPerMilliliter<T>(this T value) =>
-            Density.FromCentigramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromCentigramsPerMilliliter(T)" />
+        public static Density<double> CentigramsPerMilliliter<T>(this T value) =>
+            Density<double>.FromCentigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromDecigramsPerDeciLiter(UnitsNet.QuantityValue)" />
-        public static Density DecigramsPerDeciLiter<T>(this T value) =>
-            Density.FromDecigramsPerDeciLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromDecigramsPerDeciLiter(T)" />
+        public static Density<double> DecigramsPerDeciLiter<T>(this T value) =>
+            Density<double>.FromDecigramsPerDeciLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density DecigramsPerLiter<T>(this T value) =>
-            Density.FromDecigramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromDecigramsPerLiter(T)" />
+        public static Density<double> DecigramsPerLiter<T>(this T value) =>
+            Density<double>.FromDecigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static Density DecigramsPerMilliliter<T>(this T value) =>
-            Density.FromDecigramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromDecigramsPerMilliliter(T)" />
+        public static Density<double> DecigramsPerMilliliter<T>(this T value) =>
+            Density<double>.FromDecigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static Density GramsPerCubicCentimeter<T>(this T value) =>
-            Density.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromGramsPerCubicCentimeter(T)" />
+        public static Density<double> GramsPerCubicCentimeter<T>(this T value) =>
+            Density<double>.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static Density GramsPerCubicMeter<T>(this T value) =>
-            Density.FromGramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromGramsPerCubicMeter(T)" />
+        public static Density<double> GramsPerCubicMeter<T>(this T value) =>
+            Density<double>.FromGramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static Density GramsPerCubicMillimeter<T>(this T value) =>
-            Density.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromGramsPerCubicMillimeter(T)" />
+        public static Density<double> GramsPerCubicMillimeter<T>(this T value) =>
+            Density<double>.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerDeciLiter(UnitsNet.QuantityValue)" />
-        public static Density GramsPerDeciLiter<T>(this T value) =>
-            Density.FromGramsPerDeciLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromGramsPerDeciLiter(T)" />
+        public static Density<double> GramsPerDeciLiter<T>(this T value) =>
+            Density<double>.FromGramsPerDeciLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density GramsPerLiter<T>(this T value) =>
-            Density.FromGramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromGramsPerLiter(T)" />
+        public static Density<double> GramsPerLiter<T>(this T value) =>
+            Density<double>.FromGramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static Density GramsPerMilliliter<T>(this T value) =>
-            Density.FromGramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromGramsPerMilliliter(T)" />
+        public static Density<double> GramsPerMilliliter<T>(this T value) =>
+            Density<double>.FromGramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static Density KilogramsPerCubicCentimeter<T>(this T value) =>
-            Density.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromKilogramsPerCubicCentimeter(T)" />
+        public static Density<double> KilogramsPerCubicCentimeter<T>(this T value) =>
+            Density<double>.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static Density KilogramsPerCubicMeter<T>(this T value) =>
-            Density.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromKilogramsPerCubicMeter(T)" />
+        public static Density<double> KilogramsPerCubicMeter<T>(this T value) =>
+            Density<double>.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static Density KilogramsPerCubicMillimeter<T>(this T value) =>
-            Density.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromKilogramsPerCubicMillimeter(T)" />
+        public static Density<double> KilogramsPerCubicMillimeter<T>(this T value) =>
+            Density<double>.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density KilogramsPerLiter<T>(this T value) =>
-            Density.FromKilogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromKilogramsPerLiter(T)" />
+        public static Density<double> KilogramsPerLiter<T>(this T value) =>
+            Density<double>.FromKilogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static Density KilopoundsPerCubicFoot<T>(this T value) =>
-            Density.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromKilopoundsPerCubicFoot(T)" />
+        public static Density<double> KilopoundsPerCubicFoot<T>(this T value) =>
+            Density<double>.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static Density KilopoundsPerCubicInch<T>(this T value) =>
-            Density.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromKilopoundsPerCubicInch(T)" />
+        public static Density<double> KilopoundsPerCubicInch<T>(this T value) =>
+            Density<double>.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static Density MicrogramsPerCubicMeter<T>(this T value) =>
-            Density.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMicrogramsPerCubicMeter(T)" />
+        public static Density<double> MicrogramsPerCubicMeter<T>(this T value) =>
+            Density<double>.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerDeciLiter(UnitsNet.QuantityValue)" />
-        public static Density MicrogramsPerDeciLiter<T>(this T value) =>
-            Density.FromMicrogramsPerDeciLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMicrogramsPerDeciLiter(T)" />
+        public static Density<double> MicrogramsPerDeciLiter<T>(this T value) =>
+            Density<double>.FromMicrogramsPerDeciLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density MicrogramsPerLiter<T>(this T value) =>
-            Density.FromMicrogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMicrogramsPerLiter(T)" />
+        public static Density<double> MicrogramsPerLiter<T>(this T value) =>
+            Density<double>.FromMicrogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static Density MicrogramsPerMilliliter<T>(this T value) =>
-            Density.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMicrogramsPerMilliliter(T)" />
+        public static Density<double> MicrogramsPerMilliliter<T>(this T value) =>
+            Density<double>.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static Density MilligramsPerCubicMeter<T>(this T value) =>
-            Density.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMilligramsPerCubicMeter(T)" />
+        public static Density<double> MilligramsPerCubicMeter<T>(this T value) =>
+            Density<double>.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerDeciLiter(UnitsNet.QuantityValue)" />
-        public static Density MilligramsPerDeciLiter<T>(this T value) =>
-            Density.FromMilligramsPerDeciLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMilligramsPerDeciLiter(T)" />
+        public static Density<double> MilligramsPerDeciLiter<T>(this T value) =>
+            Density<double>.FromMilligramsPerDeciLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density MilligramsPerLiter<T>(this T value) =>
-            Density.FromMilligramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMilligramsPerLiter(T)" />
+        public static Density<double> MilligramsPerLiter<T>(this T value) =>
+            Density<double>.FromMilligramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static Density MilligramsPerMilliliter<T>(this T value) =>
-            Density.FromMilligramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromMilligramsPerMilliliter(T)" />
+        public static Density<double> MilligramsPerMilliliter<T>(this T value) =>
+            Density<double>.FromMilligramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromNanogramsPerDeciLiter(UnitsNet.QuantityValue)" />
-        public static Density NanogramsPerDeciLiter<T>(this T value) =>
-            Density.FromNanogramsPerDeciLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromNanogramsPerDeciLiter(T)" />
+        public static Density<double> NanogramsPerDeciLiter<T>(this T value) =>
+            Density<double>.FromNanogramsPerDeciLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density NanogramsPerLiter<T>(this T value) =>
-            Density.FromNanogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromNanogramsPerLiter(T)" />
+        public static Density<double> NanogramsPerLiter<T>(this T value) =>
+            Density<double>.FromNanogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static Density NanogramsPerMilliliter<T>(this T value) =>
-            Density.FromNanogramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromNanogramsPerMilliliter(T)" />
+        public static Density<double> NanogramsPerMilliliter<T>(this T value) =>
+            Density<double>.FromNanogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPicogramsPerDeciLiter(UnitsNet.QuantityValue)" />
-        public static Density PicogramsPerDeciLiter<T>(this T value) =>
-            Density.FromPicogramsPerDeciLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromPicogramsPerDeciLiter(T)" />
+        public static Density<double> PicogramsPerDeciLiter<T>(this T value) =>
+            Density<double>.FromPicogramsPerDeciLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static Density PicogramsPerLiter<T>(this T value) =>
-            Density.FromPicogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromPicogramsPerLiter(T)" />
+        public static Density<double> PicogramsPerLiter<T>(this T value) =>
+            Density<double>.FromPicogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static Density PicogramsPerMilliliter<T>(this T value) =>
-            Density.FromPicogramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromPicogramsPerMilliliter(T)" />
+        public static Density<double> PicogramsPerMilliliter<T>(this T value) =>
+            Density<double>.FromPicogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static Density PoundsPerCubicFoot<T>(this T value) =>
-            Density.FromPoundsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromPoundsPerCubicFoot(T)" />
+        public static Density<double> PoundsPerCubicFoot<T>(this T value) =>
+            Density<double>.FromPoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static Density PoundsPerCubicInch<T>(this T value) =>
-            Density.FromPoundsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromPoundsPerCubicInch(T)" />
+        public static Density<double> PoundsPerCubicInch<T>(this T value) =>
+            Density<double>.FromPoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
-        public static Density PoundsPerImperialGallon<T>(this T value) =>
-            Density.FromPoundsPerImperialGallon(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromPoundsPerImperialGallon(T)" />
+        public static Density<double> PoundsPerImperialGallon<T>(this T value) =>
+            Density<double>.FromPoundsPerImperialGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
-        public static Density PoundsPerUSGallon<T>(this T value) =>
-            Density.FromPoundsPerUSGallon(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromPoundsPerUSGallon(T)" />
+        public static Density<double> PoundsPerUSGallon<T>(this T value) =>
+            Density<double>.FromPoundsPerUSGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static Density SlugsPerCubicFoot<T>(this T value) =>
-            Density.FromSlugsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromSlugsPerCubicFoot(T)" />
+        public static Density<double> SlugsPerCubicFoot<T>(this T value) =>
+            Density<double>.FromSlugsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static Density TonnesPerCubicCentimeter<T>(this T value) =>
-            Density.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromTonnesPerCubicCentimeter(T)" />
+        public static Density<double> TonnesPerCubicCentimeter<T>(this T value) =>
+            Density<double>.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static Density TonnesPerCubicMeter<T>(this T value) =>
-            Density.FromTonnesPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromTonnesPerCubicMeter(T)" />
+        public static Density<double> TonnesPerCubicMeter<T>(this T value) =>
+            Density<double>.FromTonnesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static Density TonnesPerCubicMillimeter<T>(this T value) =>
-            Density.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Density{T}.FromTonnesPerCubicMillimeter(T)" />
+        public static Density<double> TonnesPerCubicMillimeter<T>(this T value) =>
+            Density<double>.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
index cac5629017..fc62dd2f01 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
@@ -28,45 +28,45 @@ namespace UnitsNet.NumberExtensions.NumberToDuration
     /// </summary>
     public static class NumberToDurationExtensions
     {
-        /// <inheritdoc cref="Duration.FromDays(UnitsNet.QuantityValue)" />
-        public static Duration Days<T>(this T value) =>
-            Duration.FromDays(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromDays(T)" />
+        public static Duration<double> Days<T>(this T value) =>
+            Duration<double>.FromDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromHours(UnitsNet.QuantityValue)" />
-        public static Duration Hours<T>(this T value) =>
-            Duration.FromHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromHours(T)" />
+        public static Duration<double> Hours<T>(this T value) =>
+            Duration<double>.FromHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMicroseconds(UnitsNet.QuantityValue)" />
-        public static Duration Microseconds<T>(this T value) =>
-            Duration.FromMicroseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromMicroseconds(T)" />
+        public static Duration<double> Microseconds<T>(this T value) =>
+            Duration<double>.FromMicroseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMilliseconds(UnitsNet.QuantityValue)" />
-        public static Duration Milliseconds<T>(this T value) =>
-            Duration.FromMilliseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromMilliseconds(T)" />
+        public static Duration<double> Milliseconds<T>(this T value) =>
+            Duration<double>.FromMilliseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMinutes(UnitsNet.QuantityValue)" />
-        public static Duration Minutes<T>(this T value) =>
-            Duration.FromMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromMinutes(T)" />
+        public static Duration<double> Minutes<T>(this T value) =>
+            Duration<double>.FromMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMonths30(UnitsNet.QuantityValue)" />
-        public static Duration Months30<T>(this T value) =>
-            Duration.FromMonths30(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromMonths30(T)" />
+        public static Duration<double> Months30<T>(this T value) =>
+            Duration<double>.FromMonths30(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromNanoseconds(UnitsNet.QuantityValue)" />
-        public static Duration Nanoseconds<T>(this T value) =>
-            Duration.FromNanoseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromNanoseconds(T)" />
+        public static Duration<double> Nanoseconds<T>(this T value) =>
+            Duration<double>.FromNanoseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromSeconds(UnitsNet.QuantityValue)" />
-        public static Duration Seconds<T>(this T value) =>
-            Duration.FromSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromSeconds(T)" />
+        public static Duration<double> Seconds<T>(this T value) =>
+            Duration<double>.FromSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromWeeks(UnitsNet.QuantityValue)" />
-        public static Duration Weeks<T>(this T value) =>
-            Duration.FromWeeks(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromWeeks(T)" />
+        public static Duration<double> Weeks<T>(this T value) =>
+            Duration<double>.FromWeeks(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromYears365(UnitsNet.QuantityValue)" />
-        public static Duration Years365<T>(this T value) =>
-            Duration.FromYears365(Convert.ToDouble(value));
+        /// <inheritdoc cref="Duration{T}.FromYears365(T)" />
+        public static Duration<double> Years365<T>(this T value) =>
+            Duration<double>.FromYears365(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
index 245167e3c2..3ef559dd1f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
@@ -28,45 +28,45 @@ namespace UnitsNet.NumberExtensions.NumberToDynamicViscosity
     /// </summary>
     public static class NumberToDynamicViscosityExtensions
     {
-        /// <inheritdoc cref="DynamicViscosity.FromCentipoise(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity Centipoise<T>(this T value) =>
-            DynamicViscosity.FromCentipoise(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromCentipoise(T)" />
+        public static DynamicViscosity<double> Centipoise<T>(this T value) =>
+            DynamicViscosity<double>.FromCentipoise(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity MicropascalSeconds<T>(this T value) =>
-            DynamicViscosity.FromMicropascalSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromMicropascalSeconds(T)" />
+        public static DynamicViscosity<double> MicropascalSeconds<T>(this T value) =>
+            DynamicViscosity<double>.FromMicropascalSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity MillipascalSeconds<T>(this T value) =>
-            DynamicViscosity.FromMillipascalSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromMillipascalSeconds(T)" />
+        public static DynamicViscosity<double> MillipascalSeconds<T>(this T value) =>
+            DynamicViscosity<double>.FromMillipascalSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity NewtonSecondsPerMeterSquared<T>(this T value) =>
-            DynamicViscosity.FromNewtonSecondsPerMeterSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromNewtonSecondsPerMeterSquared(T)" />
+        public static DynamicViscosity<double> NewtonSecondsPerMeterSquared<T>(this T value) =>
+            DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity PascalSeconds<T>(this T value) =>
-            DynamicViscosity.FromPascalSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromPascalSeconds(T)" />
+        public static DynamicViscosity<double> PascalSeconds<T>(this T value) =>
+            DynamicViscosity<double>.FromPascalSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoise(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity Poise<T>(this T value) =>
-            DynamicViscosity.FromPoise(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromPoise(T)" />
+        public static DynamicViscosity<double> Poise<T>(this T value) =>
+            DynamicViscosity<double>.FromPoise(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity PoundsForceSecondPerSquareFoot<T>(this T value) =>
-            DynamicViscosity.FromPoundsForceSecondPerSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromPoundsForceSecondPerSquareFoot(T)" />
+        public static DynamicViscosity<double> PoundsForceSecondPerSquareFoot<T>(this T value) =>
+            DynamicViscosity<double>.FromPoundsForceSecondPerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity PoundsForceSecondPerSquareInch<T>(this T value) =>
-            DynamicViscosity.FromPoundsForceSecondPerSquareInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromPoundsForceSecondPerSquareInch(T)" />
+        public static DynamicViscosity<double> PoundsForceSecondPerSquareInch<T>(this T value) =>
+            DynamicViscosity<double>.FromPoundsForceSecondPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsPerFootSecond(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity PoundsPerFootSecond<T>(this T value) =>
-            DynamicViscosity.FromPoundsPerFootSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromPoundsPerFootSecond(T)" />
+        public static DynamicViscosity<double> PoundsPerFootSecond<T>(this T value) =>
+            DynamicViscosity<double>.FromPoundsPerFootSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromReyns(UnitsNet.QuantityValue)" />
-        public static DynamicViscosity Reyns<T>(this T value) =>
-            DynamicViscosity.FromReyns(Convert.ToDouble(value));
+        /// <inheritdoc cref="DynamicViscosity{T}.FromReyns(T)" />
+        public static DynamicViscosity<double> Reyns<T>(this T value) =>
+            DynamicViscosity<double>.FromReyns(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
index a1ffe0522b..cd44f60ad3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToElectricAdmittance
     /// </summary>
     public static class NumberToElectricAdmittanceExtensions
     {
-        /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(UnitsNet.QuantityValue)" />
-        public static ElectricAdmittance Microsiemens<T>(this T value) =>
-            ElectricAdmittance.FromMicrosiemens(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricAdmittance{T}.FromMicrosiemens(T)" />
+        public static ElectricAdmittance<double> Microsiemens<T>(this T value) =>
+            ElectricAdmittance<double>.FromMicrosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(UnitsNet.QuantityValue)" />
-        public static ElectricAdmittance Millisiemens<T>(this T value) =>
-            ElectricAdmittance.FromMillisiemens(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricAdmittance{T}.FromMillisiemens(T)" />
+        public static ElectricAdmittance<double> Millisiemens<T>(this T value) =>
+            ElectricAdmittance<double>.FromMillisiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(UnitsNet.QuantityValue)" />
-        public static ElectricAdmittance Nanosiemens<T>(this T value) =>
-            ElectricAdmittance.FromNanosiemens(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricAdmittance{T}.FromNanosiemens(T)" />
+        public static ElectricAdmittance<double> Nanosiemens<T>(this T value) =>
+            ElectricAdmittance<double>.FromNanosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricAdmittance.FromSiemens(UnitsNet.QuantityValue)" />
-        public static ElectricAdmittance Siemens<T>(this T value) =>
-            ElectricAdmittance.FromSiemens(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricAdmittance{T}.FromSiemens(T)" />
+        public static ElectricAdmittance<double> Siemens<T>(this T value) =>
+            ElectricAdmittance<double>.FromSiemens(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
index c0b341cb5d..d2b00d1df8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToElectricChargeDensity
     /// </summary>
     public static class NumberToElectricChargeDensityExtensions
     {
-        /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static ElectricChargeDensity CoulombsPerCubicMeter<T>(this T value) =>
-            ElectricChargeDensity.FromCoulombsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricChargeDensity{T}.FromCoulombsPerCubicMeter(T)" />
+        public static ElectricChargeDensity<double> CoulombsPerCubicMeter<T>(this T value) =>
+            ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
index a11430480d..628a620fe0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
@@ -28,25 +28,25 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCharge
     /// </summary>
     public static class NumberToElectricChargeExtensions
     {
-        /// <inheritdoc cref="ElectricCharge.FromAmpereHours(UnitsNet.QuantityValue)" />
-        public static ElectricCharge AmpereHours<T>(this T value) =>
-            ElectricCharge.FromAmpereHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCharge{T}.FromAmpereHours(T)" />
+        public static ElectricCharge<double> AmpereHours<T>(this T value) =>
+            ElectricCharge<double>.FromAmpereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromCoulombs(UnitsNet.QuantityValue)" />
-        public static ElectricCharge Coulombs<T>(this T value) =>
-            ElectricCharge.FromCoulombs(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCharge{T}.FromCoulombs(T)" />
+        public static ElectricCharge<double> Coulombs<T>(this T value) =>
+            ElectricCharge<double>.FromCoulombs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(UnitsNet.QuantityValue)" />
-        public static ElectricCharge KiloampereHours<T>(this T value) =>
-            ElectricCharge.FromKiloampereHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCharge{T}.FromKiloampereHours(T)" />
+        public static ElectricCharge<double> KiloampereHours<T>(this T value) =>
+            ElectricCharge<double>.FromKiloampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(UnitsNet.QuantityValue)" />
-        public static ElectricCharge MegaampereHours<T>(this T value) =>
-            ElectricCharge.FromMegaampereHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCharge{T}.FromMegaampereHours(T)" />
+        public static ElectricCharge<double> MegaampereHours<T>(this T value) =>
+            ElectricCharge<double>.FromMegaampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(UnitsNet.QuantityValue)" />
-        public static ElectricCharge MilliampereHours<T>(this T value) =>
-            ElectricCharge.FromMilliampereHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCharge{T}.FromMilliampereHours(T)" />
+        public static ElectricCharge<double> MilliampereHours<T>(this T value) =>
+            ElectricCharge<double>.FromMilliampereHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
index 19e68d6a04..0e327b94e6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToElectricConductance
     /// </summary>
     public static class NumberToElectricConductanceExtensions
     {
-        /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(UnitsNet.QuantityValue)" />
-        public static ElectricConductance Microsiemens<T>(this T value) =>
-            ElectricConductance.FromMicrosiemens(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricConductance{T}.FromMicrosiemens(T)" />
+        public static ElectricConductance<double> Microsiemens<T>(this T value) =>
+            ElectricConductance<double>.FromMicrosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductance.FromMillisiemens(UnitsNet.QuantityValue)" />
-        public static ElectricConductance Millisiemens<T>(this T value) =>
-            ElectricConductance.FromMillisiemens(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricConductance{T}.FromMillisiemens(T)" />
+        public static ElectricConductance<double> Millisiemens<T>(this T value) =>
+            ElectricConductance<double>.FromMillisiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductance.FromSiemens(UnitsNet.QuantityValue)" />
-        public static ElectricConductance Siemens<T>(this T value) =>
-            ElectricConductance.FromSiemens(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricConductance{T}.FromSiemens(T)" />
+        public static ElectricConductance<double> Siemens<T>(this T value) =>
+            ElectricConductance<double>.FromSiemens(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
index 01f045f4bd..0f33def1fe 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToElectricConductivity
     /// </summary>
     public static class NumberToElectricConductivityExtensions
     {
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(UnitsNet.QuantityValue)" />
-        public static ElectricConductivity SiemensPerFoot<T>(this T value) =>
-            ElectricConductivity.FromSiemensPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricConductivity{T}.FromSiemensPerFoot(T)" />
+        public static ElectricConductivity<double> SiemensPerFoot<T>(this T value) =>
+            ElectricConductivity<double>.FromSiemensPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(UnitsNet.QuantityValue)" />
-        public static ElectricConductivity SiemensPerInch<T>(this T value) =>
-            ElectricConductivity.FromSiemensPerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricConductivity{T}.FromSiemensPerInch(T)" />
+        public static ElectricConductivity<double> SiemensPerInch<T>(this T value) =>
+            ElectricConductivity<double>.FromSiemensPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(UnitsNet.QuantityValue)" />
-        public static ElectricConductivity SiemensPerMeter<T>(this T value) =>
-            ElectricConductivity.FromSiemensPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricConductivity{T}.FromSiemensPerMeter(T)" />
+        public static ElectricConductivity<double> SiemensPerMeter<T>(this T value) =>
+            ElectricConductivity<double>.FromSiemensPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
index ac6b7ad918..8f96dc4c1d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrentDensity
     /// </summary>
     public static class NumberToElectricCurrentDensityExtensions
     {
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(UnitsNet.QuantityValue)" />
-        public static ElectricCurrentDensity AmperesPerSquareFoot<T>(this T value) =>
-            ElectricCurrentDensity.FromAmperesPerSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrentDensity{T}.FromAmperesPerSquareFoot(T)" />
+        public static ElectricCurrentDensity<double> AmperesPerSquareFoot<T>(this T value) =>
+            ElectricCurrentDensity<double>.FromAmperesPerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(UnitsNet.QuantityValue)" />
-        public static ElectricCurrentDensity AmperesPerSquareInch<T>(this T value) =>
-            ElectricCurrentDensity.FromAmperesPerSquareInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrentDensity{T}.FromAmperesPerSquareInch(T)" />
+        public static ElectricCurrentDensity<double> AmperesPerSquareInch<T>(this T value) =>
+            ElectricCurrentDensity<double>.FromAmperesPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static ElectricCurrentDensity AmperesPerSquareMeter<T>(this T value) =>
-            ElectricCurrentDensity.FromAmperesPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrentDensity{T}.FromAmperesPerSquareMeter(T)" />
+        public static ElectricCurrentDensity<double> AmperesPerSquareMeter<T>(this T value) =>
+            ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
index 0cdd105a1a..955f20d112 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
@@ -28,37 +28,37 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrent
     /// </summary>
     public static class NumberToElectricCurrentExtensions
     {
-        /// <inheritdoc cref="ElectricCurrent.FromAmperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Amperes<T>(this T value) =>
-            ElectricCurrent.FromAmperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromAmperes(T)" />
+        public static ElectricCurrent<double> Amperes<T>(this T value) =>
+            ElectricCurrent<double>.FromAmperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Centiamperes<T>(this T value) =>
-            ElectricCurrent.FromCentiamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromCentiamperes(T)" />
+        public static ElectricCurrent<double> Centiamperes<T>(this T value) =>
+            ElectricCurrent<double>.FromCentiamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Kiloamperes<T>(this T value) =>
-            ElectricCurrent.FromKiloamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromKiloamperes(T)" />
+        public static ElectricCurrent<double> Kiloamperes<T>(this T value) =>
+            ElectricCurrent<double>.FromKiloamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Megaamperes<T>(this T value) =>
-            ElectricCurrent.FromMegaamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromMegaamperes(T)" />
+        public static ElectricCurrent<double> Megaamperes<T>(this T value) =>
+            ElectricCurrent<double>.FromMegaamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Microamperes<T>(this T value) =>
-            ElectricCurrent.FromMicroamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromMicroamperes(T)" />
+        public static ElectricCurrent<double> Microamperes<T>(this T value) =>
+            ElectricCurrent<double>.FromMicroamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Milliamperes<T>(this T value) =>
-            ElectricCurrent.FromMilliamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromMilliamperes(T)" />
+        public static ElectricCurrent<double> Milliamperes<T>(this T value) =>
+            ElectricCurrent<double>.FromMilliamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Nanoamperes<T>(this T value) =>
-            ElectricCurrent.FromNanoamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromNanoamperes(T)" />
+        public static ElectricCurrent<double> Nanoamperes<T>(this T value) =>
+            ElectricCurrent<double>.FromNanoamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(UnitsNet.QuantityValue)" />
-        public static ElectricCurrent Picoamperes<T>(this T value) =>
-            ElectricCurrent.FromPicoamperes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrent{T}.FromPicoamperes(T)" />
+        public static ElectricCurrent<double> Picoamperes<T>(this T value) =>
+            ElectricCurrent<double>.FromPicoamperes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
index 3127d6707b..689ed93fb4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrentGradient
     /// </summary>
     public static class NumberToElectricCurrentGradientExtensions
     {
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMicrosecond(UnitsNet.QuantityValue)" />
-        public static ElectricCurrentGradient AmperesPerMicrosecond<T>(this T value) =>
-            ElectricCurrentGradient.FromAmperesPerMicrosecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrentGradient{T}.FromAmperesPerMicrosecond(T)" />
+        public static ElectricCurrentGradient<double> AmperesPerMicrosecond<T>(this T value) =>
+            ElectricCurrentGradient<double>.FromAmperesPerMicrosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMillisecond(UnitsNet.QuantityValue)" />
-        public static ElectricCurrentGradient AmperesPerMillisecond<T>(this T value) =>
-            ElectricCurrentGradient.FromAmperesPerMillisecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrentGradient{T}.FromAmperesPerMillisecond(T)" />
+        public static ElectricCurrentGradient<double> AmperesPerMillisecond<T>(this T value) =>
+            ElectricCurrentGradient<double>.FromAmperesPerMillisecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerNanosecond(UnitsNet.QuantityValue)" />
-        public static ElectricCurrentGradient AmperesPerNanosecond<T>(this T value) =>
-            ElectricCurrentGradient.FromAmperesPerNanosecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrentGradient{T}.FromAmperesPerNanosecond(T)" />
+        public static ElectricCurrentGradient<double> AmperesPerNanosecond<T>(this T value) =>
+            ElectricCurrentGradient<double>.FromAmperesPerNanosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(UnitsNet.QuantityValue)" />
-        public static ElectricCurrentGradient AmperesPerSecond<T>(this T value) =>
-            ElectricCurrentGradient.FromAmperesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricCurrentGradient{T}.FromAmperesPerSecond(T)" />
+        public static ElectricCurrentGradient<double> AmperesPerSecond<T>(this T value) =>
+            ElectricCurrentGradient<double>.FromAmperesPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
index 3e7ca73ec7..f9d2225018 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToElectricField
     /// </summary>
     public static class NumberToElectricFieldExtensions
     {
-        /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(UnitsNet.QuantityValue)" />
-        public static ElectricField VoltsPerMeter<T>(this T value) =>
-            ElectricField.FromVoltsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricField{T}.FromVoltsPerMeter(T)" />
+        public static ElectricField<double> VoltsPerMeter<T>(this T value) =>
+            ElectricField<double>.FromVoltsPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
index e376d6fe9b..ad6d068c63 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToElectricInductance
     /// </summary>
     public static class NumberToElectricInductanceExtensions
     {
-        /// <inheritdoc cref="ElectricInductance.FromHenries(UnitsNet.QuantityValue)" />
-        public static ElectricInductance Henries<T>(this T value) =>
-            ElectricInductance.FromHenries(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricInductance{T}.FromHenries(T)" />
+        public static ElectricInductance<double> Henries<T>(this T value) =>
+            ElectricInductance<double>.FromHenries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricInductance.FromMicrohenries(UnitsNet.QuantityValue)" />
-        public static ElectricInductance Microhenries<T>(this T value) =>
-            ElectricInductance.FromMicrohenries(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricInductance{T}.FromMicrohenries(T)" />
+        public static ElectricInductance<double> Microhenries<T>(this T value) =>
+            ElectricInductance<double>.FromMicrohenries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricInductance.FromMillihenries(UnitsNet.QuantityValue)" />
-        public static ElectricInductance Millihenries<T>(this T value) =>
-            ElectricInductance.FromMillihenries(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricInductance{T}.FromMillihenries(T)" />
+        public static ElectricInductance<double> Millihenries<T>(this T value) =>
+            ElectricInductance<double>.FromMillihenries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricInductance.FromNanohenries(UnitsNet.QuantityValue)" />
-        public static ElectricInductance Nanohenries<T>(this T value) =>
-            ElectricInductance.FromNanohenries(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricInductance{T}.FromNanohenries(T)" />
+        public static ElectricInductance<double> Nanohenries<T>(this T value) =>
+            ElectricInductance<double>.FromNanohenries(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
index a208716732..06185ad6f0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
@@ -28,25 +28,25 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialAc
     /// </summary>
     public static class NumberToElectricPotentialAcExtensions
     {
-        /// <inheritdoc cref="ElectricPotentialAc.FromKilovoltsAc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialAc KilovoltsAc<T>(this T value) =>
-            ElectricPotentialAc.FromKilovoltsAc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialAc{T}.FromKilovoltsAc(T)" />
+        public static ElectricPotentialAc<double> KilovoltsAc<T>(this T value) =>
+            ElectricPotentialAc<double>.FromKilovoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromMegavoltsAc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialAc MegavoltsAc<T>(this T value) =>
-            ElectricPotentialAc.FromMegavoltsAc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialAc{T}.FromMegavoltsAc(T)" />
+        public static ElectricPotentialAc<double> MegavoltsAc<T>(this T value) =>
+            ElectricPotentialAc<double>.FromMegavoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromMicrovoltsAc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialAc MicrovoltsAc<T>(this T value) =>
-            ElectricPotentialAc.FromMicrovoltsAc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialAc{T}.FromMicrovoltsAc(T)" />
+        public static ElectricPotentialAc<double> MicrovoltsAc<T>(this T value) =>
+            ElectricPotentialAc<double>.FromMicrovoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromMillivoltsAc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialAc MillivoltsAc<T>(this T value) =>
-            ElectricPotentialAc.FromMillivoltsAc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialAc{T}.FromMillivoltsAc(T)" />
+        public static ElectricPotentialAc<double> MillivoltsAc<T>(this T value) =>
+            ElectricPotentialAc<double>.FromMillivoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromVoltsAc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialAc VoltsAc<T>(this T value) =>
-            ElectricPotentialAc.FromVoltsAc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialAc{T}.FromVoltsAc(T)" />
+        public static ElectricPotentialAc<double> VoltsAc<T>(this T value) =>
+            ElectricPotentialAc<double>.FromVoltsAc(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
index 1490787c3d..dc4f355c21 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
@@ -28,85 +28,85 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialChangeRate
     /// </summary>
     public static class NumberToElectricPotentialChangeRateExtensions
     {
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerHours(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate KilovoltsPerHours<T>(this T value) =>
-            ElectricPotentialChangeRate.FromKilovoltsPerHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromKilovoltsPerHours(T)" />
+        public static ElectricPotentialChangeRate<double> KilovoltsPerHours<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromKilovoltsPerHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMicroseconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate KilovoltsPerMicroseconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromKilovoltsPerMicroseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromKilovoltsPerMicroseconds(T)" />
+        public static ElectricPotentialChangeRate<double> KilovoltsPerMicroseconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromKilovoltsPerMicroseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMinutes(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate KilovoltsPerMinutes<T>(this T value) =>
-            ElectricPotentialChangeRate.FromKilovoltsPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromKilovoltsPerMinutes(T)" />
+        public static ElectricPotentialChangeRate<double> KilovoltsPerMinutes<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromKilovoltsPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerSeconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate KilovoltsPerSeconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromKilovoltsPerSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromKilovoltsPerSeconds(T)" />
+        public static ElectricPotentialChangeRate<double> KilovoltsPerSeconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromKilovoltsPerSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerHours(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MegavoltsPerHours<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMegavoltsPerHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMegavoltsPerHours(T)" />
+        public static ElectricPotentialChangeRate<double> MegavoltsPerHours<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMegavoltsPerHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMicroseconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MegavoltsPerMicroseconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMegavoltsPerMicroseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMegavoltsPerMicroseconds(T)" />
+        public static ElectricPotentialChangeRate<double> MegavoltsPerMicroseconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMegavoltsPerMicroseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMinutes(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MegavoltsPerMinutes<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMegavoltsPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMegavoltsPerMinutes(T)" />
+        public static ElectricPotentialChangeRate<double> MegavoltsPerMinutes<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMegavoltsPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerSeconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MegavoltsPerSeconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMegavoltsPerSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMegavoltsPerSeconds(T)" />
+        public static ElectricPotentialChangeRate<double> MegavoltsPerSeconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMegavoltsPerSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerHours(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MicrovoltsPerHours<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMicrovoltsPerHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMicrovoltsPerHours(T)" />
+        public static ElectricPotentialChangeRate<double> MicrovoltsPerHours<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMicrovoltsPerHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMicroseconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MicrovoltsPerMicroseconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMicrovoltsPerMicroseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMicrovoltsPerMicroseconds(T)" />
+        public static ElectricPotentialChangeRate<double> MicrovoltsPerMicroseconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMicrovoltsPerMicroseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMinutes(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MicrovoltsPerMinutes<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMicrovoltsPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMicrovoltsPerMinutes(T)" />
+        public static ElectricPotentialChangeRate<double> MicrovoltsPerMinutes<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMicrovoltsPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerSeconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MicrovoltsPerSeconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMicrovoltsPerSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMicrovoltsPerSeconds(T)" />
+        public static ElectricPotentialChangeRate<double> MicrovoltsPerSeconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMicrovoltsPerSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerHours(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MillivoltsPerHours<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMillivoltsPerHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMillivoltsPerHours(T)" />
+        public static ElectricPotentialChangeRate<double> MillivoltsPerHours<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMillivoltsPerHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMicroseconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MillivoltsPerMicroseconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMillivoltsPerMicroseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMillivoltsPerMicroseconds(T)" />
+        public static ElectricPotentialChangeRate<double> MillivoltsPerMicroseconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMillivoltsPerMicroseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMinutes(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MillivoltsPerMinutes<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMillivoltsPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMillivoltsPerMinutes(T)" />
+        public static ElectricPotentialChangeRate<double> MillivoltsPerMinutes<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMillivoltsPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerSeconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate MillivoltsPerSeconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromMillivoltsPerSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromMillivoltsPerSeconds(T)" />
+        public static ElectricPotentialChangeRate<double> MillivoltsPerSeconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromMillivoltsPerSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerHours(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate VoltsPerHours<T>(this T value) =>
-            ElectricPotentialChangeRate.FromVoltsPerHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromVoltsPerHours(T)" />
+        public static ElectricPotentialChangeRate<double> VoltsPerHours<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromVoltsPerHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMicroseconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate VoltsPerMicroseconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromVoltsPerMicroseconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromVoltsPerMicroseconds(T)" />
+        public static ElectricPotentialChangeRate<double> VoltsPerMicroseconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromVoltsPerMicroseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMinutes(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate VoltsPerMinutes<T>(this T value) =>
-            ElectricPotentialChangeRate.FromVoltsPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromVoltsPerMinutes(T)" />
+        public static ElectricPotentialChangeRate<double> VoltsPerMinutes<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromVoltsPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerSeconds(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialChangeRate VoltsPerSeconds<T>(this T value) =>
-            ElectricPotentialChangeRate.FromVoltsPerSeconds(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialChangeRate{T}.FromVoltsPerSeconds(T)" />
+        public static ElectricPotentialChangeRate<double> VoltsPerSeconds<T>(this T value) =>
+            ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
index 25bb0d3375..7c3d6f0319 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
@@ -28,25 +28,25 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialDc
     /// </summary>
     public static class NumberToElectricPotentialDcExtensions
     {
-        /// <inheritdoc cref="ElectricPotentialDc.FromKilovoltsDc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialDc KilovoltsDc<T>(this T value) =>
-            ElectricPotentialDc.FromKilovoltsDc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialDc{T}.FromKilovoltsDc(T)" />
+        public static ElectricPotentialDc<double> KilovoltsDc<T>(this T value) =>
+            ElectricPotentialDc<double>.FromKilovoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromMegavoltsDc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialDc MegavoltsDc<T>(this T value) =>
-            ElectricPotentialDc.FromMegavoltsDc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialDc{T}.FromMegavoltsDc(T)" />
+        public static ElectricPotentialDc<double> MegavoltsDc<T>(this T value) =>
+            ElectricPotentialDc<double>.FromMegavoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromMicrovoltsDc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialDc MicrovoltsDc<T>(this T value) =>
-            ElectricPotentialDc.FromMicrovoltsDc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialDc{T}.FromMicrovoltsDc(T)" />
+        public static ElectricPotentialDc<double> MicrovoltsDc<T>(this T value) =>
+            ElectricPotentialDc<double>.FromMicrovoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromMillivoltsDc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialDc MillivoltsDc<T>(this T value) =>
-            ElectricPotentialDc.FromMillivoltsDc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialDc{T}.FromMillivoltsDc(T)" />
+        public static ElectricPotentialDc<double> MillivoltsDc<T>(this T value) =>
+            ElectricPotentialDc<double>.FromMillivoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromVoltsDc(UnitsNet.QuantityValue)" />
-        public static ElectricPotentialDc VoltsDc<T>(this T value) =>
-            ElectricPotentialDc.FromVoltsDc(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotentialDc{T}.FromVoltsDc(T)" />
+        public static ElectricPotentialDc<double> VoltsDc<T>(this T value) =>
+            ElectricPotentialDc<double>.FromVoltsDc(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
index 9c1e477a24..ca0f1761f6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
@@ -28,25 +28,25 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotential
     /// </summary>
     public static class NumberToElectricPotentialExtensions
     {
-        /// <inheritdoc cref="ElectricPotential.FromKilovolts(UnitsNet.QuantityValue)" />
-        public static ElectricPotential Kilovolts<T>(this T value) =>
-            ElectricPotential.FromKilovolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotential{T}.FromKilovolts(T)" />
+        public static ElectricPotential<double> Kilovolts<T>(this T value) =>
+            ElectricPotential<double>.FromKilovolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromMegavolts(UnitsNet.QuantityValue)" />
-        public static ElectricPotential Megavolts<T>(this T value) =>
-            ElectricPotential.FromMegavolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotential{T}.FromMegavolts(T)" />
+        public static ElectricPotential<double> Megavolts<T>(this T value) =>
+            ElectricPotential<double>.FromMegavolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromMicrovolts(UnitsNet.QuantityValue)" />
-        public static ElectricPotential Microvolts<T>(this T value) =>
-            ElectricPotential.FromMicrovolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotential{T}.FromMicrovolts(T)" />
+        public static ElectricPotential<double> Microvolts<T>(this T value) =>
+            ElectricPotential<double>.FromMicrovolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromMillivolts(UnitsNet.QuantityValue)" />
-        public static ElectricPotential Millivolts<T>(this T value) =>
-            ElectricPotential.FromMillivolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotential{T}.FromMillivolts(T)" />
+        public static ElectricPotential<double> Millivolts<T>(this T value) =>
+            ElectricPotential<double>.FromMillivolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromVolts(UnitsNet.QuantityValue)" />
-        public static ElectricPotential Volts<T>(this T value) =>
-            ElectricPotential.FromVolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricPotential{T}.FromVolts(T)" />
+        public static ElectricPotential<double> Volts<T>(this T value) =>
+            ElectricPotential<double>.FromVolts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
index ba32c38726..4be60818e2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
@@ -28,29 +28,29 @@ namespace UnitsNet.NumberExtensions.NumberToElectricResistance
     /// </summary>
     public static class NumberToElectricResistanceExtensions
     {
-        /// <inheritdoc cref="ElectricResistance.FromGigaohms(UnitsNet.QuantityValue)" />
-        public static ElectricResistance Gigaohms<T>(this T value) =>
-            ElectricResistance.FromGigaohms(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistance{T}.FromGigaohms(T)" />
+        public static ElectricResistance<double> Gigaohms<T>(this T value) =>
+            ElectricResistance<double>.FromGigaohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromKiloohms(UnitsNet.QuantityValue)" />
-        public static ElectricResistance Kiloohms<T>(this T value) =>
-            ElectricResistance.FromKiloohms(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistance{T}.FromKiloohms(T)" />
+        public static ElectricResistance<double> Kiloohms<T>(this T value) =>
+            ElectricResistance<double>.FromKiloohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromMegaohms(UnitsNet.QuantityValue)" />
-        public static ElectricResistance Megaohms<T>(this T value) =>
-            ElectricResistance.FromMegaohms(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistance{T}.FromMegaohms(T)" />
+        public static ElectricResistance<double> Megaohms<T>(this T value) =>
+            ElectricResistance<double>.FromMegaohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromMicroohms(UnitsNet.QuantityValue)" />
-        public static ElectricResistance Microohms<T>(this T value) =>
-            ElectricResistance.FromMicroohms(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistance{T}.FromMicroohms(T)" />
+        public static ElectricResistance<double> Microohms<T>(this T value) =>
+            ElectricResistance<double>.FromMicroohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" />
-        public static ElectricResistance Milliohms<T>(this T value) =>
-            ElectricResistance.FromMilliohms(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistance{T}.FromMilliohms(T)" />
+        public static ElectricResistance<double> Milliohms<T>(this T value) =>
+            ElectricResistance<double>.FromMilliohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromOhms(UnitsNet.QuantityValue)" />
-        public static ElectricResistance Ohms<T>(this T value) =>
-            ElectricResistance.FromOhms(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistance{T}.FromOhms(T)" />
+        public static ElectricResistance<double> Ohms<T>(this T value) =>
+            ElectricResistance<double>.FromOhms(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
index ceba3142bb..59d956b904 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
@@ -28,61 +28,61 @@ namespace UnitsNet.NumberExtensions.NumberToElectricResistivity
     /// </summary>
     public static class NumberToElectricResistivityExtensions
     {
-        /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity KiloohmsCentimeter<T>(this T value) =>
-            ElectricResistivity.FromKiloohmsCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromKiloohmsCentimeter(T)" />
+        public static ElectricResistivity<double> KiloohmsCentimeter<T>(this T value) =>
+            ElectricResistivity<double>.FromKiloohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity KiloohmMeters<T>(this T value) =>
-            ElectricResistivity.FromKiloohmMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromKiloohmMeters(T)" />
+        public static ElectricResistivity<double> KiloohmMeters<T>(this T value) =>
+            ElectricResistivity<double>.FromKiloohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity MegaohmsCentimeter<T>(this T value) =>
-            ElectricResistivity.FromMegaohmsCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromMegaohmsCentimeter(T)" />
+        public static ElectricResistivity<double> MegaohmsCentimeter<T>(this T value) =>
+            ElectricResistivity<double>.FromMegaohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity MegaohmMeters<T>(this T value) =>
-            ElectricResistivity.FromMegaohmMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromMegaohmMeters(T)" />
+        public static ElectricResistivity<double> MegaohmMeters<T>(this T value) =>
+            ElectricResistivity<double>.FromMegaohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity MicroohmsCentimeter<T>(this T value) =>
-            ElectricResistivity.FromMicroohmsCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromMicroohmsCentimeter(T)" />
+        public static ElectricResistivity<double> MicroohmsCentimeter<T>(this T value) =>
+            ElectricResistivity<double>.FromMicroohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity MicroohmMeters<T>(this T value) =>
-            ElectricResistivity.FromMicroohmMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromMicroohmMeters(T)" />
+        public static ElectricResistivity<double> MicroohmMeters<T>(this T value) =>
+            ElectricResistivity<double>.FromMicroohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity MilliohmsCentimeter<T>(this T value) =>
-            ElectricResistivity.FromMilliohmsCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromMilliohmsCentimeter(T)" />
+        public static ElectricResistivity<double> MilliohmsCentimeter<T>(this T value) =>
+            ElectricResistivity<double>.FromMilliohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity MilliohmMeters<T>(this T value) =>
-            ElectricResistivity.FromMilliohmMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromMilliohmMeters(T)" />
+        public static ElectricResistivity<double> MilliohmMeters<T>(this T value) =>
+            ElectricResistivity<double>.FromMilliohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity NanoohmsCentimeter<T>(this T value) =>
-            ElectricResistivity.FromNanoohmsCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromNanoohmsCentimeter(T)" />
+        public static ElectricResistivity<double> NanoohmsCentimeter<T>(this T value) =>
+            ElectricResistivity<double>.FromNanoohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity NanoohmMeters<T>(this T value) =>
-            ElectricResistivity.FromNanoohmMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromNanoohmMeters(T)" />
+        public static ElectricResistivity<double> NanoohmMeters<T>(this T value) =>
+            ElectricResistivity<double>.FromNanoohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity OhmsCentimeter<T>(this T value) =>
-            ElectricResistivity.FromOhmsCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromOhmsCentimeter(T)" />
+        public static ElectricResistivity<double> OhmsCentimeter<T>(this T value) =>
+            ElectricResistivity<double>.FromOhmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity OhmMeters<T>(this T value) =>
-            ElectricResistivity.FromOhmMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromOhmMeters(T)" />
+        public static ElectricResistivity<double> OhmMeters<T>(this T value) =>
+            ElectricResistivity<double>.FromOhmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity PicoohmsCentimeter<T>(this T value) =>
-            ElectricResistivity.FromPicoohmsCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromPicoohmsCentimeter(T)" />
+        public static ElectricResistivity<double> PicoohmsCentimeter<T>(this T value) =>
+            ElectricResistivity<double>.FromPicoohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(UnitsNet.QuantityValue)" />
-        public static ElectricResistivity PicoohmMeters<T>(this T value) =>
-            ElectricResistivity.FromPicoohmMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricResistivity{T}.FromPicoohmMeters(T)" />
+        public static ElectricResistivity<double> PicoohmMeters<T>(this T value) =>
+            ElectricResistivity<double>.FromPicoohmMeters(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
index 32ee1c1576..6c389f40c1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToElectricSurfaceChargeDensity
     /// </summary>
     public static class NumberToElectricSurfaceChargeDensityExtensions
     {
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter<T>(this T value) =>
-            ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity{T}.FromCoulombsPerSquareCentimeter(T)" />
+        public static ElectricSurfaceChargeDensity<double> CoulombsPerSquareCentimeter<T>(this T value) =>
+            ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(UnitsNet.QuantityValue)" />
-        public static ElectricSurfaceChargeDensity CoulombsPerSquareInch<T>(this T value) =>
-            ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity{T}.FromCoulombsPerSquareInch(T)" />
+        public static ElectricSurfaceChargeDensity<double> CoulombsPerSquareInch<T>(this T value) =>
+            ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static ElectricSurfaceChargeDensity CoulombsPerSquareMeter<T>(this T value) =>
-            ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity{T}.FromCoulombsPerSquareMeter(T)" />
+        public static ElectricSurfaceChargeDensity<double> CoulombsPerSquareMeter<T>(this T value) =>
+            ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
index 1b30087cf6..6c34314a56 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
@@ -28,149 +28,149 @@ namespace UnitsNet.NumberExtensions.NumberToEnergy
     /// </summary>
     public static class NumberToEnergyExtensions
     {
-        /// <inheritdoc cref="Energy.FromBritishThermalUnits(UnitsNet.QuantityValue)" />
-        public static Energy BritishThermalUnits<T>(this T value) =>
-            Energy.FromBritishThermalUnits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromBritishThermalUnits(T)" />
+        public static Energy<double> BritishThermalUnits<T>(this T value) =>
+            Energy<double>.FromBritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromCalories(UnitsNet.QuantityValue)" />
-        public static Energy Calories<T>(this T value) =>
-            Energy.FromCalories(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromCalories(T)" />
+        public static Energy<double> Calories<T>(this T value) =>
+            Energy<double>.FromCalories(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromDecathermsEc(UnitsNet.QuantityValue)" />
-        public static Energy DecathermsEc<T>(this T value) =>
-            Energy.FromDecathermsEc(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromDecathermsEc(T)" />
+        public static Energy<double> DecathermsEc<T>(this T value) =>
+            Energy<double>.FromDecathermsEc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromDecathermsImperial(UnitsNet.QuantityValue)" />
-        public static Energy DecathermsImperial<T>(this T value) =>
-            Energy.FromDecathermsImperial(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromDecathermsImperial(T)" />
+        public static Energy<double> DecathermsImperial<T>(this T value) =>
+            Energy<double>.FromDecathermsImperial(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromDecathermsUs(UnitsNet.QuantityValue)" />
-        public static Energy DecathermsUs<T>(this T value) =>
-            Energy.FromDecathermsUs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromDecathermsUs(T)" />
+        public static Energy<double> DecathermsUs<T>(this T value) =>
+            Energy<double>.FromDecathermsUs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromElectronVolts(UnitsNet.QuantityValue)" />
-        public static Energy ElectronVolts<T>(this T value) =>
-            Energy.FromElectronVolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromElectronVolts(T)" />
+        public static Energy<double> ElectronVolts<T>(this T value) =>
+            Energy<double>.FromElectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromErgs(UnitsNet.QuantityValue)" />
-        public static Energy Ergs<T>(this T value) =>
-            Energy.FromErgs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromErgs(T)" />
+        public static Energy<double> Ergs<T>(this T value) =>
+            Energy<double>.FromErgs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromFootPounds(UnitsNet.QuantityValue)" />
-        public static Energy FootPounds<T>(this T value) =>
-            Energy.FromFootPounds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromFootPounds(T)" />
+        public static Energy<double> FootPounds<T>(this T value) =>
+            Energy<double>.FromFootPounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(UnitsNet.QuantityValue)" />
-        public static Energy GigabritishThermalUnits<T>(this T value) =>
-            Energy.FromGigabritishThermalUnits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromGigabritishThermalUnits(T)" />
+        public static Energy<double> GigabritishThermalUnits<T>(this T value) =>
+            Energy<double>.FromGigabritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigaelectronVolts(UnitsNet.QuantityValue)" />
-        public static Energy GigaelectronVolts<T>(this T value) =>
-            Energy.FromGigaelectronVolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromGigaelectronVolts(T)" />
+        public static Energy<double> GigaelectronVolts<T>(this T value) =>
+            Energy<double>.FromGigaelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigajoules(UnitsNet.QuantityValue)" />
-        public static Energy Gigajoules<T>(this T value) =>
-            Energy.FromGigajoules(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromGigajoules(T)" />
+        public static Energy<double> Gigajoules<T>(this T value) =>
+            Energy<double>.FromGigajoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigawattDays(UnitsNet.QuantityValue)" />
-        public static Energy GigawattDays<T>(this T value) =>
-            Energy.FromGigawattDays(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromGigawattDays(T)" />
+        public static Energy<double> GigawattDays<T>(this T value) =>
+            Energy<double>.FromGigawattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigawattHours(UnitsNet.QuantityValue)" />
-        public static Energy GigawattHours<T>(this T value) =>
-            Energy.FromGigawattHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromGigawattHours(T)" />
+        public static Energy<double> GigawattHours<T>(this T value) =>
+            Energy<double>.FromGigawattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromHorsepowerHours(UnitsNet.QuantityValue)" />
-        public static Energy HorsepowerHours<T>(this T value) =>
-            Energy.FromHorsepowerHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromHorsepowerHours(T)" />
+        public static Energy<double> HorsepowerHours<T>(this T value) =>
+            Energy<double>.FromHorsepowerHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromJoules(UnitsNet.QuantityValue)" />
-        public static Energy Joules<T>(this T value) =>
-            Energy.FromJoules(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromJoules(T)" />
+        public static Energy<double> Joules<T>(this T value) =>
+            Energy<double>.FromJoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(UnitsNet.QuantityValue)" />
-        public static Energy KilobritishThermalUnits<T>(this T value) =>
-            Energy.FromKilobritishThermalUnits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromKilobritishThermalUnits(T)" />
+        public static Energy<double> KilobritishThermalUnits<T>(this T value) =>
+            Energy<double>.FromKilobritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilocalories(UnitsNet.QuantityValue)" />
-        public static Energy Kilocalories<T>(this T value) =>
-            Energy.FromKilocalories(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromKilocalories(T)" />
+        public static Energy<double> Kilocalories<T>(this T value) =>
+            Energy<double>.FromKilocalories(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKiloelectronVolts(UnitsNet.QuantityValue)" />
-        public static Energy KiloelectronVolts<T>(this T value) =>
-            Energy.FromKiloelectronVolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromKiloelectronVolts(T)" />
+        public static Energy<double> KiloelectronVolts<T>(this T value) =>
+            Energy<double>.FromKiloelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilojoules(UnitsNet.QuantityValue)" />
-        public static Energy Kilojoules<T>(this T value) =>
-            Energy.FromKilojoules(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromKilojoules(T)" />
+        public static Energy<double> Kilojoules<T>(this T value) =>
+            Energy<double>.FromKilojoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilowattDays(UnitsNet.QuantityValue)" />
-        public static Energy KilowattDays<T>(this T value) =>
-            Energy.FromKilowattDays(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromKilowattDays(T)" />
+        public static Energy<double> KilowattDays<T>(this T value) =>
+            Energy<double>.FromKilowattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilowattHours(UnitsNet.QuantityValue)" />
-        public static Energy KilowattHours<T>(this T value) =>
-            Energy.FromKilowattHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromKilowattHours(T)" />
+        public static Energy<double> KilowattHours<T>(this T value) =>
+            Energy<double>.FromKilowattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(UnitsNet.QuantityValue)" />
-        public static Energy MegabritishThermalUnits<T>(this T value) =>
-            Energy.FromMegabritishThermalUnits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromMegabritishThermalUnits(T)" />
+        public static Energy<double> MegabritishThermalUnits<T>(this T value) =>
+            Energy<double>.FromMegabritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegacalories(UnitsNet.QuantityValue)" />
-        public static Energy Megacalories<T>(this T value) =>
-            Energy.FromMegacalories(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromMegacalories(T)" />
+        public static Energy<double> Megacalories<T>(this T value) =>
+            Energy<double>.FromMegacalories(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegaelectronVolts(UnitsNet.QuantityValue)" />
-        public static Energy MegaelectronVolts<T>(this T value) =>
-            Energy.FromMegaelectronVolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromMegaelectronVolts(T)" />
+        public static Energy<double> MegaelectronVolts<T>(this T value) =>
+            Energy<double>.FromMegaelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegajoules(UnitsNet.QuantityValue)" />
-        public static Energy Megajoules<T>(this T value) =>
-            Energy.FromMegajoules(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromMegajoules(T)" />
+        public static Energy<double> Megajoules<T>(this T value) =>
+            Energy<double>.FromMegajoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegawattDays(UnitsNet.QuantityValue)" />
-        public static Energy MegawattDays<T>(this T value) =>
-            Energy.FromMegawattDays(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromMegawattDays(T)" />
+        public static Energy<double> MegawattDays<T>(this T value) =>
+            Energy<double>.FromMegawattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegawattHours(UnitsNet.QuantityValue)" />
-        public static Energy MegawattHours<T>(this T value) =>
-            Energy.FromMegawattHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromMegawattHours(T)" />
+        public static Energy<double> MegawattHours<T>(this T value) =>
+            Energy<double>.FromMegawattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMillijoules(UnitsNet.QuantityValue)" />
-        public static Energy Millijoules<T>(this T value) =>
-            Energy.FromMillijoules(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromMillijoules(T)" />
+        public static Energy<double> Millijoules<T>(this T value) =>
+            Energy<double>.FromMillijoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromTeraelectronVolts(UnitsNet.QuantityValue)" />
-        public static Energy TeraelectronVolts<T>(this T value) =>
-            Energy.FromTeraelectronVolts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromTeraelectronVolts(T)" />
+        public static Energy<double> TeraelectronVolts<T>(this T value) =>
+            Energy<double>.FromTeraelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromTerawattDays(UnitsNet.QuantityValue)" />
-        public static Energy TerawattDays<T>(this T value) =>
-            Energy.FromTerawattDays(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromTerawattDays(T)" />
+        public static Energy<double> TerawattDays<T>(this T value) =>
+            Energy<double>.FromTerawattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromTerawattHours(UnitsNet.QuantityValue)" />
-        public static Energy TerawattHours<T>(this T value) =>
-            Energy.FromTerawattHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromTerawattHours(T)" />
+        public static Energy<double> TerawattHours<T>(this T value) =>
+            Energy<double>.FromTerawattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromThermsEc(UnitsNet.QuantityValue)" />
-        public static Energy ThermsEc<T>(this T value) =>
-            Energy.FromThermsEc(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromThermsEc(T)" />
+        public static Energy<double> ThermsEc<T>(this T value) =>
+            Energy<double>.FromThermsEc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromThermsImperial(UnitsNet.QuantityValue)" />
-        public static Energy ThermsImperial<T>(this T value) =>
-            Energy.FromThermsImperial(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromThermsImperial(T)" />
+        public static Energy<double> ThermsImperial<T>(this T value) =>
+            Energy<double>.FromThermsImperial(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromThermsUs(UnitsNet.QuantityValue)" />
-        public static Energy ThermsUs<T>(this T value) =>
-            Energy.FromThermsUs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromThermsUs(T)" />
+        public static Energy<double> ThermsUs<T>(this T value) =>
+            Energy<double>.FromThermsUs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromWattDays(UnitsNet.QuantityValue)" />
-        public static Energy WattDays<T>(this T value) =>
-            Energy.FromWattDays(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromWattDays(T)" />
+        public static Energy<double> WattDays<T>(this T value) =>
+            Energy<double>.FromWattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromWattHours(UnitsNet.QuantityValue)" />
-        public static Energy WattHours<T>(this T value) =>
-            Energy.FromWattHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="Energy{T}.FromWattHours(T)" />
+        public static Energy<double> WattHours<T>(this T value) =>
+            Energy<double>.FromWattHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
index 380fc72caf..a30cbcbaf3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
@@ -28,33 +28,33 @@ namespace UnitsNet.NumberExtensions.NumberToEntropy
     /// </summary>
     public static class NumberToEntropyExtensions
     {
-        /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(UnitsNet.QuantityValue)" />
-        public static Entropy CaloriesPerKelvin<T>(this T value) =>
-            Entropy.FromCaloriesPerKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="Entropy{T}.FromCaloriesPerKelvin(T)" />
+        public static Entropy<double> CaloriesPerKelvin<T>(this T value) =>
+            Entropy<double>.FromCaloriesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
-        public static Entropy JoulesPerDegreeCelsius<T>(this T value) =>
-            Entropy.FromJoulesPerDegreeCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="Entropy{T}.FromJoulesPerDegreeCelsius(T)" />
+        public static Entropy<double> JoulesPerDegreeCelsius<T>(this T value) =>
+            Entropy<double>.FromJoulesPerDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(UnitsNet.QuantityValue)" />
-        public static Entropy JoulesPerKelvin<T>(this T value) =>
-            Entropy.FromJoulesPerKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="Entropy{T}.FromJoulesPerKelvin(T)" />
+        public static Entropy<double> JoulesPerKelvin<T>(this T value) =>
+            Entropy<double>.FromJoulesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(UnitsNet.QuantityValue)" />
-        public static Entropy KilocaloriesPerKelvin<T>(this T value) =>
-            Entropy.FromKilocaloriesPerKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="Entropy{T}.FromKilocaloriesPerKelvin(T)" />
+        public static Entropy<double> KilocaloriesPerKelvin<T>(this T value) =>
+            Entropy<double>.FromKilocaloriesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
-        public static Entropy KilojoulesPerDegreeCelsius<T>(this T value) =>
-            Entropy.FromKilojoulesPerDegreeCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="Entropy{T}.FromKilojoulesPerDegreeCelsius(T)" />
+        public static Entropy<double> KilojoulesPerDegreeCelsius<T>(this T value) =>
+            Entropy<double>.FromKilojoulesPerDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(UnitsNet.QuantityValue)" />
-        public static Entropy KilojoulesPerKelvin<T>(this T value) =>
-            Entropy.FromKilojoulesPerKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="Entropy{T}.FromKilojoulesPerKelvin(T)" />
+        public static Entropy<double> KilojoulesPerKelvin<T>(this T value) =>
+            Entropy<double>.FromKilojoulesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(UnitsNet.QuantityValue)" />
-        public static Entropy MegajoulesPerKelvin<T>(this T value) =>
-            Entropy.FromMegajoulesPerKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="Entropy{T}.FromMegajoulesPerKelvin(T)" />
+        public static Entropy<double> MegajoulesPerKelvin<T>(this T value) =>
+            Entropy<double>.FromMegajoulesPerKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
index df75da1487..1cc2f7d52c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
@@ -28,49 +28,49 @@ namespace UnitsNet.NumberExtensions.NumberToForceChangeRate
     /// </summary>
     public static class NumberToForceChangeRateExtensions
     {
-        /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate CentinewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromCentinewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromCentinewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> CentinewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromCentinewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate DecanewtonsPerMinute<T>(this T value) =>
-            ForceChangeRate.FromDecanewtonsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromDecanewtonsPerMinute(T)" />
+        public static ForceChangeRate<double> DecanewtonsPerMinute<T>(this T value) =>
+            ForceChangeRate<double>.FromDecanewtonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate DecanewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromDecanewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromDecanewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> DecanewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromDecanewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate DecinewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromDecinewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromDecinewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> DecinewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromDecinewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate KilonewtonsPerMinute<T>(this T value) =>
-            ForceChangeRate.FromKilonewtonsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromKilonewtonsPerMinute(T)" />
+        public static ForceChangeRate<double> KilonewtonsPerMinute<T>(this T value) =>
+            ForceChangeRate<double>.FromKilonewtonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate KilonewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromKilonewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromKilonewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> KilonewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromKilonewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate MicronewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromMicronewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromMicronewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> MicronewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromMicronewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate MillinewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromMillinewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromMillinewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> MillinewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromMillinewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate NanonewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromNanonewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromNanonewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> NanonewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromNanonewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate NewtonsPerMinute<T>(this T value) =>
-            ForceChangeRate.FromNewtonsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromNewtonsPerMinute(T)" />
+        public static ForceChangeRate<double> NewtonsPerMinute<T>(this T value) =>
+            ForceChangeRate<double>.FromNewtonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(UnitsNet.QuantityValue)" />
-        public static ForceChangeRate NewtonsPerSecond<T>(this T value) =>
-            ForceChangeRate.FromNewtonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForceChangeRate{T}.FromNewtonsPerSecond(T)" />
+        public static ForceChangeRate<double> NewtonsPerSecond<T>(this T value) =>
+            ForceChangeRate<double>.FromNewtonsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
index 2bb99d88f9..d424e8d81c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
@@ -28,65 +28,65 @@ namespace UnitsNet.NumberExtensions.NumberToForce
     /// </summary>
     public static class NumberToForceExtensions
     {
-        /// <inheritdoc cref="Force.FromDecanewtons(UnitsNet.QuantityValue)" />
-        public static Force Decanewtons<T>(this T value) =>
-            Force.FromDecanewtons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromDecanewtons(T)" />
+        public static Force<double> Decanewtons<T>(this T value) =>
+            Force<double>.FromDecanewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromDyne(UnitsNet.QuantityValue)" />
-        public static Force Dyne<T>(this T value) =>
-            Force.FromDyne(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromDyne(T)" />
+        public static Force<double> Dyne<T>(this T value) =>
+            Force<double>.FromDyne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKilogramsForce(UnitsNet.QuantityValue)" />
-        public static Force KilogramsForce<T>(this T value) =>
-            Force.FromKilogramsForce(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromKilogramsForce(T)" />
+        public static Force<double> KilogramsForce<T>(this T value) =>
+            Force<double>.FromKilogramsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKilonewtons(UnitsNet.QuantityValue)" />
-        public static Force Kilonewtons<T>(this T value) =>
-            Force.FromKilonewtons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromKilonewtons(T)" />
+        public static Force<double> Kilonewtons<T>(this T value) =>
+            Force<double>.FromKilonewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKiloPonds(UnitsNet.QuantityValue)" />
-        public static Force KiloPonds<T>(this T value) =>
-            Force.FromKiloPonds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromKiloPonds(T)" />
+        public static Force<double> KiloPonds<T>(this T value) =>
+            Force<double>.FromKiloPonds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKilopoundsForce(UnitsNet.QuantityValue)" />
-        public static Force KilopoundsForce<T>(this T value) =>
-            Force.FromKilopoundsForce(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromKilopoundsForce(T)" />
+        public static Force<double> KilopoundsForce<T>(this T value) =>
+            Force<double>.FromKilopoundsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromMeganewtons(UnitsNet.QuantityValue)" />
-        public static Force Meganewtons<T>(this T value) =>
-            Force.FromMeganewtons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromMeganewtons(T)" />
+        public static Force<double> Meganewtons<T>(this T value) =>
+            Force<double>.FromMeganewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromMicronewtons(UnitsNet.QuantityValue)" />
-        public static Force Micronewtons<T>(this T value) =>
-            Force.FromMicronewtons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromMicronewtons(T)" />
+        public static Force<double> Micronewtons<T>(this T value) =>
+            Force<double>.FromMicronewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromMillinewtons(UnitsNet.QuantityValue)" />
-        public static Force Millinewtons<T>(this T value) =>
-            Force.FromMillinewtons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromMillinewtons(T)" />
+        public static Force<double> Millinewtons<T>(this T value) =>
+            Force<double>.FromMillinewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromNewtons(UnitsNet.QuantityValue)" />
-        public static Force Newtons<T>(this T value) =>
-            Force.FromNewtons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromNewtons(T)" />
+        public static Force<double> Newtons<T>(this T value) =>
+            Force<double>.FromNewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromOunceForce(UnitsNet.QuantityValue)" />
-        public static Force OunceForce<T>(this T value) =>
-            Force.FromOunceForce(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromOunceForce(T)" />
+        public static Force<double> OunceForce<T>(this T value) =>
+            Force<double>.FromOunceForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromPoundals(UnitsNet.QuantityValue)" />
-        public static Force Poundals<T>(this T value) =>
-            Force.FromPoundals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromPoundals(T)" />
+        public static Force<double> Poundals<T>(this T value) =>
+            Force<double>.FromPoundals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromPoundsForce(UnitsNet.QuantityValue)" />
-        public static Force PoundsForce<T>(this T value) =>
-            Force.FromPoundsForce(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromPoundsForce(T)" />
+        public static Force<double> PoundsForce<T>(this T value) =>
+            Force<double>.FromPoundsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromShortTonsForce(UnitsNet.QuantityValue)" />
-        public static Force ShortTonsForce<T>(this T value) =>
-            Force.FromShortTonsForce(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromShortTonsForce(T)" />
+        public static Force<double> ShortTonsForce<T>(this T value) =>
+            Force<double>.FromShortTonsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromTonnesForce(UnitsNet.QuantityValue)" />
-        public static Force TonnesForce<T>(this T value) =>
-            Force.FromTonnesForce(Convert.ToDouble(value));
+        /// <inheritdoc cref="Force{T}.FromTonnesForce(T)" />
+        public static Force<double> TonnesForce<T>(this T value) =>
+            Force<double>.FromTonnesForce(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
index 7c0c66f78d..d3c8ce9175 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
@@ -28,157 +28,157 @@ namespace UnitsNet.NumberExtensions.NumberToForcePerLength
     /// </summary>
     public static class NumberToForcePerLengthExtensions
     {
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength CentinewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromCentinewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromCentinewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> CentinewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromCentinewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength CentinewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromCentinewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromCentinewtonsPerMeter(T)" />
+        public static ForcePerLength<double> CentinewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromCentinewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength CentinewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromCentinewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromCentinewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> CentinewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromCentinewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength DecanewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromDecanewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromDecanewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> DecanewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromDecanewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength DecanewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromDecanewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromDecanewtonsPerMeter(T)" />
+        public static ForcePerLength<double> DecanewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromDecanewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength DecanewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromDecanewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromDecanewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> DecanewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromDecanewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength DecinewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromDecinewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromDecinewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> DecinewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromDecinewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength DecinewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromDecinewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromDecinewtonsPerMeter(T)" />
+        public static ForcePerLength<double> DecinewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromDecinewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength DecinewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromDecinewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromDecinewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> DecinewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromDecinewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilogramsForcePerCentimeter<T>(this T value) =>
-            ForcePerLength.FromKilogramsForcePerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilogramsForcePerCentimeter(T)" />
+        public static ForcePerLength<double> KilogramsForcePerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromKilogramsForcePerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilogramsForcePerMeter<T>(this T value) =>
-            ForcePerLength.FromKilogramsForcePerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilogramsForcePerMeter(T)" />
+        public static ForcePerLength<double> KilogramsForcePerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromKilogramsForcePerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilogramsForcePerMillimeter<T>(this T value) =>
-            ForcePerLength.FromKilogramsForcePerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilogramsForcePerMillimeter(T)" />
+        public static ForcePerLength<double> KilogramsForcePerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromKilogramsForcePerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilonewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromKilonewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilonewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> KilonewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromKilonewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilonewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromKilonewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilonewtonsPerMeter(T)" />
+        public static ForcePerLength<double> KilonewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromKilonewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilonewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromKilonewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilonewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> KilonewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromKilonewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerFoot(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilopoundsForcePerFoot<T>(this T value) =>
-            ForcePerLength.FromKilopoundsForcePerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilopoundsForcePerFoot(T)" />
+        public static ForcePerLength<double> KilopoundsForcePerFoot<T>(this T value) =>
+            ForcePerLength<double>.FromKilopoundsForcePerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerInch(UnitsNet.QuantityValue)" />
-        public static ForcePerLength KilopoundsForcePerInch<T>(this T value) =>
-            ForcePerLength.FromKilopoundsForcePerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromKilopoundsForcePerInch(T)" />
+        public static ForcePerLength<double> KilopoundsForcePerInch<T>(this T value) =>
+            ForcePerLength<double>.FromKilopoundsForcePerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MeganewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromMeganewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMeganewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> MeganewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromMeganewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MeganewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromMeganewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMeganewtonsPerMeter(T)" />
+        public static ForcePerLength<double> MeganewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromMeganewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MeganewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromMeganewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMeganewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> MeganewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromMeganewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MicronewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromMicronewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMicronewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> MicronewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromMicronewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MicronewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromMicronewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMicronewtonsPerMeter(T)" />
+        public static ForcePerLength<double> MicronewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromMicronewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MicronewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromMicronewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMicronewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> MicronewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromMicronewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MillinewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromMillinewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMillinewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> MillinewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromMillinewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MillinewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromMillinewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMillinewtonsPerMeter(T)" />
+        public static ForcePerLength<double> MillinewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromMillinewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength MillinewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromMillinewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromMillinewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> MillinewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromMillinewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength NanonewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromNanonewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromNanonewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> NanonewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromNanonewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength NanonewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromNanonewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromNanonewtonsPerMeter(T)" />
+        public static ForcePerLength<double> NanonewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromNanonewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength NanonewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromNanonewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromNanonewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> NanonewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromNanonewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength NewtonsPerCentimeter<T>(this T value) =>
-            ForcePerLength.FromNewtonsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromNewtonsPerCentimeter(T)" />
+        public static ForcePerLength<double> NewtonsPerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromNewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength NewtonsPerMeter<T>(this T value) =>
-            ForcePerLength.FromNewtonsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromNewtonsPerMeter(T)" />
+        public static ForcePerLength<double> NewtonsPerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromNewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength NewtonsPerMillimeter<T>(this T value) =>
-            ForcePerLength.FromNewtonsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromNewtonsPerMillimeter(T)" />
+        public static ForcePerLength<double> NewtonsPerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromNewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(UnitsNet.QuantityValue)" />
-        public static ForcePerLength PoundsForcePerFoot<T>(this T value) =>
-            ForcePerLength.FromPoundsForcePerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromPoundsForcePerFoot(T)" />
+        public static ForcePerLength<double> PoundsForcePerFoot<T>(this T value) =>
+            ForcePerLength<double>.FromPoundsForcePerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(UnitsNet.QuantityValue)" />
-        public static ForcePerLength PoundsForcePerInch<T>(this T value) =>
-            ForcePerLength.FromPoundsForcePerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromPoundsForcePerInch(T)" />
+        public static ForcePerLength<double> PoundsForcePerInch<T>(this T value) =>
+            ForcePerLength<double>.FromPoundsForcePerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(UnitsNet.QuantityValue)" />
-        public static ForcePerLength PoundsForcePerYard<T>(this T value) =>
-            ForcePerLength.FromPoundsForcePerYard(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromPoundsForcePerYard(T)" />
+        public static ForcePerLength<double> PoundsForcePerYard<T>(this T value) =>
+            ForcePerLength<double>.FromPoundsForcePerYard(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerCentimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength TonnesForcePerCentimeter<T>(this T value) =>
-            ForcePerLength.FromTonnesForcePerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromTonnesForcePerCentimeter(T)" />
+        public static ForcePerLength<double> TonnesForcePerCentimeter<T>(this T value) =>
+            ForcePerLength<double>.FromTonnesForcePerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength TonnesForcePerMeter<T>(this T value) =>
-            ForcePerLength.FromTonnesForcePerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromTonnesForcePerMeter(T)" />
+        public static ForcePerLength<double> TonnesForcePerMeter<T>(this T value) =>
+            ForcePerLength<double>.FromTonnesForcePerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMillimeter(UnitsNet.QuantityValue)" />
-        public static ForcePerLength TonnesForcePerMillimeter<T>(this T value) =>
-            ForcePerLength.FromTonnesForcePerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="ForcePerLength{T}.FromTonnesForcePerMillimeter(T)" />
+        public static ForcePerLength<double> TonnesForcePerMillimeter<T>(this T value) =>
+            ForcePerLength<double>.FromTonnesForcePerMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
index 4d0e5b5979..d7ae42c33e 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
@@ -28,45 +28,45 @@ namespace UnitsNet.NumberExtensions.NumberToFrequency
     /// </summary>
     public static class NumberToFrequencyExtensions
     {
-        /// <inheritdoc cref="Frequency.FromBeatsPerMinute(UnitsNet.QuantityValue)" />
-        public static Frequency BeatsPerMinute<T>(this T value) =>
-            Frequency.FromBeatsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromBeatsPerMinute(T)" />
+        public static Frequency<double> BeatsPerMinute<T>(this T value) =>
+            Frequency<double>.FromBeatsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromCyclesPerHour(UnitsNet.QuantityValue)" />
-        public static Frequency CyclesPerHour<T>(this T value) =>
-            Frequency.FromCyclesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromCyclesPerHour(T)" />
+        public static Frequency<double> CyclesPerHour<T>(this T value) =>
+            Frequency<double>.FromCyclesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromCyclesPerMinute(UnitsNet.QuantityValue)" />
-        public static Frequency CyclesPerMinute<T>(this T value) =>
-            Frequency.FromCyclesPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromCyclesPerMinute(T)" />
+        public static Frequency<double> CyclesPerMinute<T>(this T value) =>
+            Frequency<double>.FromCyclesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromGigahertz(UnitsNet.QuantityValue)" />
-        public static Frequency Gigahertz<T>(this T value) =>
-            Frequency.FromGigahertz(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromGigahertz(T)" />
+        public static Frequency<double> Gigahertz<T>(this T value) =>
+            Frequency<double>.FromGigahertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromHertz(UnitsNet.QuantityValue)" />
-        public static Frequency Hertz<T>(this T value) =>
-            Frequency.FromHertz(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromHertz(T)" />
+        public static Frequency<double> Hertz<T>(this T value) =>
+            Frequency<double>.FromHertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromKilohertz(UnitsNet.QuantityValue)" />
-        public static Frequency Kilohertz<T>(this T value) =>
-            Frequency.FromKilohertz(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromKilohertz(T)" />
+        public static Frequency<double> Kilohertz<T>(this T value) =>
+            Frequency<double>.FromKilohertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromMegahertz(UnitsNet.QuantityValue)" />
-        public static Frequency Megahertz<T>(this T value) =>
-            Frequency.FromMegahertz(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromMegahertz(T)" />
+        public static Frequency<double> Megahertz<T>(this T value) =>
+            Frequency<double>.FromMegahertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromPerSecond(UnitsNet.QuantityValue)" />
-        public static Frequency PerSecond<T>(this T value) =>
-            Frequency.FromPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromPerSecond(T)" />
+        public static Frequency<double> PerSecond<T>(this T value) =>
+            Frequency<double>.FromPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
-        public static Frequency RadiansPerSecond<T>(this T value) =>
-            Frequency.FromRadiansPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromRadiansPerSecond(T)" />
+        public static Frequency<double> RadiansPerSecond<T>(this T value) =>
+            Frequency<double>.FromRadiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromTerahertz(UnitsNet.QuantityValue)" />
-        public static Frequency Terahertz<T>(this T value) =>
-            Frequency.FromTerahertz(Convert.ToDouble(value));
+        /// <inheritdoc cref="Frequency{T}.FromTerahertz(T)" />
+        public static Frequency<double> Terahertz<T>(this T value) =>
+            Frequency<double>.FromTerahertz(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
index 784bed62b5..51763f7531 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToFuelEfficiency
     /// </summary>
     public static class NumberToFuelEfficiencyExtensions
     {
-        /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiters(UnitsNet.QuantityValue)" />
-        public static FuelEfficiency KilometersPerLiters<T>(this T value) =>
-            FuelEfficiency.FromKilometersPerLiters(Convert.ToDouble(value));
+        /// <inheritdoc cref="FuelEfficiency{T}.FromKilometersPerLiters(T)" />
+        public static FuelEfficiency<double> KilometersPerLiters<T>(this T value) =>
+            FuelEfficiency<double>.FromKilometersPerLiters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(UnitsNet.QuantityValue)" />
-        public static FuelEfficiency LitersPer100Kilometers<T>(this T value) =>
-            FuelEfficiency.FromLitersPer100Kilometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="FuelEfficiency{T}.FromLitersPer100Kilometers(T)" />
+        public static FuelEfficiency<double> LitersPer100Kilometers<T>(this T value) =>
+            FuelEfficiency<double>.FromLitersPer100Kilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(UnitsNet.QuantityValue)" />
-        public static FuelEfficiency MilesPerUkGallon<T>(this T value) =>
-            FuelEfficiency.FromMilesPerUkGallon(Convert.ToDouble(value));
+        /// <inheritdoc cref="FuelEfficiency{T}.FromMilesPerUkGallon(T)" />
+        public static FuelEfficiency<double> MilesPerUkGallon<T>(this T value) =>
+            FuelEfficiency<double>.FromMilesPerUkGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(UnitsNet.QuantityValue)" />
-        public static FuelEfficiency MilesPerUsGallon<T>(this T value) =>
-            FuelEfficiency.FromMilesPerUsGallon(Convert.ToDouble(value));
+        /// <inheritdoc cref="FuelEfficiency{T}.FromMilesPerUsGallon(T)" />
+        public static FuelEfficiency<double> MilesPerUsGallon<T>(this T value) =>
+            FuelEfficiency<double>.FromMilesPerUsGallon(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
index 883c9e3a6f..cf35b9ecc3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
@@ -28,77 +28,77 @@ namespace UnitsNet.NumberExtensions.NumberToHeatFlux
     /// </summary>
     public static class NumberToHeatFluxExtensions
     {
-        /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(UnitsNet.QuantityValue)" />
-        public static HeatFlux BtusPerHourSquareFoot<T>(this T value) =>
-            HeatFlux.FromBtusPerHourSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromBtusPerHourSquareFoot(T)" />
+        public static HeatFlux<double> BtusPerHourSquareFoot<T>(this T value) =>
+            HeatFlux<double>.FromBtusPerHourSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(UnitsNet.QuantityValue)" />
-        public static HeatFlux BtusPerMinuteSquareFoot<T>(this T value) =>
-            HeatFlux.FromBtusPerMinuteSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromBtusPerMinuteSquareFoot(T)" />
+        public static HeatFlux<double> BtusPerMinuteSquareFoot<T>(this T value) =>
+            HeatFlux<double>.FromBtusPerMinuteSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(UnitsNet.QuantityValue)" />
-        public static HeatFlux BtusPerSecondSquareFoot<T>(this T value) =>
-            HeatFlux.FromBtusPerSecondSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromBtusPerSecondSquareFoot(T)" />
+        public static HeatFlux<double> BtusPerSecondSquareFoot<T>(this T value) =>
+            HeatFlux<double>.FromBtusPerSecondSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(UnitsNet.QuantityValue)" />
-        public static HeatFlux BtusPerSecondSquareInch<T>(this T value) =>
-            HeatFlux.FromBtusPerSecondSquareInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromBtusPerSecondSquareInch(T)" />
+        public static HeatFlux<double> BtusPerSecondSquareInch<T>(this T value) =>
+            HeatFlux<double>.FromBtusPerSecondSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux CaloriesPerSecondSquareCentimeter<T>(this T value) =>
-            HeatFlux.FromCaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromCaloriesPerSecondSquareCentimeter(T)" />
+        public static HeatFlux<double> CaloriesPerSecondSquareCentimeter<T>(this T value) =>
+            HeatFlux<double>.FromCaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux CentiwattsPerSquareMeter<T>(this T value) =>
-            HeatFlux.FromCentiwattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromCentiwattsPerSquareMeter(T)" />
+        public static HeatFlux<double> CentiwattsPerSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromCentiwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux DeciwattsPerSquareMeter<T>(this T value) =>
-            HeatFlux.FromDeciwattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromDeciwattsPerSquareMeter(T)" />
+        public static HeatFlux<double> DeciwattsPerSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromDeciwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux KilocaloriesPerHourSquareMeter<T>(this T value) =>
-            HeatFlux.FromKilocaloriesPerHourSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromKilocaloriesPerHourSquareMeter(T)" />
+        public static HeatFlux<double> KilocaloriesPerHourSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromKilocaloriesPerHourSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux KilocaloriesPerSecondSquareCentimeter<T>(this T value) =>
-            HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromKilocaloriesPerSecondSquareCentimeter(T)" />
+        public static HeatFlux<double> KilocaloriesPerSecondSquareCentimeter<T>(this T value) =>
+            HeatFlux<double>.FromKilocaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux KilowattsPerSquareMeter<T>(this T value) =>
-            HeatFlux.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromKilowattsPerSquareMeter(T)" />
+        public static HeatFlux<double> KilowattsPerSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux MicrowattsPerSquareMeter<T>(this T value) =>
-            HeatFlux.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromMicrowattsPerSquareMeter(T)" />
+        public static HeatFlux<double> MicrowattsPerSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux MilliwattsPerSquareMeter<T>(this T value) =>
-            HeatFlux.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromMilliwattsPerSquareMeter(T)" />
+        public static HeatFlux<double> MilliwattsPerSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux NanowattsPerSquareMeter<T>(this T value) =>
-            HeatFlux.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromNanowattsPerSquareMeter(T)" />
+        public static HeatFlux<double> NanowattsPerSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(UnitsNet.QuantityValue)" />
-        public static HeatFlux PoundsForcePerFootSecond<T>(this T value) =>
-            HeatFlux.FromPoundsForcePerFootSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromPoundsForcePerFootSecond(T)" />
+        public static HeatFlux<double> PoundsForcePerFootSecond<T>(this T value) =>
+            HeatFlux<double>.FromPoundsForcePerFootSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(UnitsNet.QuantityValue)" />
-        public static HeatFlux PoundsPerSecondCubed<T>(this T value) =>
-            HeatFlux.FromPoundsPerSecondCubed(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromPoundsPerSecondCubed(T)" />
+        public static HeatFlux<double> PoundsPerSecondCubed<T>(this T value) =>
+            HeatFlux<double>.FromPoundsPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(UnitsNet.QuantityValue)" />
-        public static HeatFlux WattsPerSquareFoot<T>(this T value) =>
-            HeatFlux.FromWattsPerSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromWattsPerSquareFoot(T)" />
+        public static HeatFlux<double> WattsPerSquareFoot<T>(this T value) =>
+            HeatFlux<double>.FromWattsPerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(UnitsNet.QuantityValue)" />
-        public static HeatFlux WattsPerSquareInch<T>(this T value) =>
-            HeatFlux.FromWattsPerSquareInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromWattsPerSquareInch(T)" />
+        public static HeatFlux<double> WattsPerSquareInch<T>(this T value) =>
+            HeatFlux<double>.FromWattsPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static HeatFlux WattsPerSquareMeter<T>(this T value) =>
-            HeatFlux.FromWattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatFlux{T}.FromWattsPerSquareMeter(T)" />
+        public static HeatFlux<double> WattsPerSquareMeter<T>(this T value) =>
+            HeatFlux<double>.FromWattsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
index b003ea6162..4bdc7a5ccb 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToHeatTransferCoefficient
     /// </summary>
     public static class NumberToHeatTransferCoefficientExtensions
     {
-        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(UnitsNet.QuantityValue)" />
-        public static HeatTransferCoefficient BtusPerSquareFootDegreeFahrenheit<T>(this T value) =>
-            HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatTransferCoefficient{T}.FromBtusPerSquareFootDegreeFahrenheit(T)" />
+        public static HeatTransferCoefficient<double> BtusPerSquareFootDegreeFahrenheit<T>(this T value) =>
+            HeatTransferCoefficient<double>.FromBtusPerSquareFootDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(UnitsNet.QuantityValue)" />
-        public static HeatTransferCoefficient WattsPerSquareMeterCelsius<T>(this T value) =>
-            HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatTransferCoefficient{T}.FromWattsPerSquareMeterCelsius(T)" />
+        public static HeatTransferCoefficient<double> WattsPerSquareMeterCelsius<T>(this T value) =>
+            HeatTransferCoefficient<double>.FromWattsPerSquareMeterCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(UnitsNet.QuantityValue)" />
-        public static HeatTransferCoefficient WattsPerSquareMeterKelvin<T>(this T value) =>
-            HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="HeatTransferCoefficient{T}.FromWattsPerSquareMeterKelvin(T)" />
+        public static HeatTransferCoefficient<double> WattsPerSquareMeterKelvin<T>(this T value) =>
+            HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
index b6249c0ee0..a2a827acc1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToIlluminance
     /// </summary>
     public static class NumberToIlluminanceExtensions
     {
-        /// <inheritdoc cref="Illuminance.FromKilolux(UnitsNet.QuantityValue)" />
-        public static Illuminance Kilolux<T>(this T value) =>
-            Illuminance.FromKilolux(Convert.ToDouble(value));
+        /// <inheritdoc cref="Illuminance{T}.FromKilolux(T)" />
+        public static Illuminance<double> Kilolux<T>(this T value) =>
+            Illuminance<double>.FromKilolux(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Illuminance.FromLux(UnitsNet.QuantityValue)" />
-        public static Illuminance Lux<T>(this T value) =>
-            Illuminance.FromLux(Convert.ToDouble(value));
+        /// <inheritdoc cref="Illuminance{T}.FromLux(T)" />
+        public static Illuminance<double> Lux<T>(this T value) =>
+            Illuminance<double>.FromLux(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Illuminance.FromMegalux(UnitsNet.QuantityValue)" />
-        public static Illuminance Megalux<T>(this T value) =>
-            Illuminance.FromMegalux(Convert.ToDouble(value));
+        /// <inheritdoc cref="Illuminance{T}.FromMegalux(T)" />
+        public static Illuminance<double> Megalux<T>(this T value) =>
+            Illuminance<double>.FromMegalux(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Illuminance.FromMillilux(UnitsNet.QuantityValue)" />
-        public static Illuminance Millilux<T>(this T value) =>
-            Illuminance.FromMillilux(Convert.ToDouble(value));
+        /// <inheritdoc cref="Illuminance{T}.FromMillilux(T)" />
+        public static Illuminance<double> Millilux<T>(this T value) =>
+            Illuminance<double>.FromMillilux(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
index 120e3dda4a..428e5f1dd8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
@@ -28,109 +28,109 @@ namespace UnitsNet.NumberExtensions.NumberToInformation
     /// </summary>
     public static class NumberToInformationExtensions
     {
-        /// <inheritdoc cref="Information.FromBits(UnitsNet.QuantityValue)" />
-        public static Information Bits<T>(this T value) =>
-            Information.FromBits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromBits(T)" />
+        public static Information<double> Bits<T>(this T value) =>
+            Information<double>.FromBits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromBytes(UnitsNet.QuantityValue)" />
-        public static Information Bytes<T>(this T value) =>
-            Information.FromBytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromBytes(T)" />
+        public static Information<double> Bytes<T>(this T value) =>
+            Information<double>.FromBytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExabits(UnitsNet.QuantityValue)" />
-        public static Information Exabits<T>(this T value) =>
-            Information.FromExabits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromExabits(T)" />
+        public static Information<double> Exabits<T>(this T value) =>
+            Information<double>.FromExabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExabytes(UnitsNet.QuantityValue)" />
-        public static Information Exabytes<T>(this T value) =>
-            Information.FromExabytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromExabytes(T)" />
+        public static Information<double> Exabytes<T>(this T value) =>
+            Information<double>.FromExabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExbibits(UnitsNet.QuantityValue)" />
-        public static Information Exbibits<T>(this T value) =>
-            Information.FromExbibits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromExbibits(T)" />
+        public static Information<double> Exbibits<T>(this T value) =>
+            Information<double>.FromExbibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExbibytes(UnitsNet.QuantityValue)" />
-        public static Information Exbibytes<T>(this T value) =>
-            Information.FromExbibytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromExbibytes(T)" />
+        public static Information<double> Exbibytes<T>(this T value) =>
+            Information<double>.FromExbibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGibibits(UnitsNet.QuantityValue)" />
-        public static Information Gibibits<T>(this T value) =>
-            Information.FromGibibits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromGibibits(T)" />
+        public static Information<double> Gibibits<T>(this T value) =>
+            Information<double>.FromGibibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGibibytes(UnitsNet.QuantityValue)" />
-        public static Information Gibibytes<T>(this T value) =>
-            Information.FromGibibytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromGibibytes(T)" />
+        public static Information<double> Gibibytes<T>(this T value) =>
+            Information<double>.FromGibibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGigabits(UnitsNet.QuantityValue)" />
-        public static Information Gigabits<T>(this T value) =>
-            Information.FromGigabits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromGigabits(T)" />
+        public static Information<double> Gigabits<T>(this T value) =>
+            Information<double>.FromGigabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGigabytes(UnitsNet.QuantityValue)" />
-        public static Information Gigabytes<T>(this T value) =>
-            Information.FromGigabytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromGigabytes(T)" />
+        public static Information<double> Gigabytes<T>(this T value) =>
+            Information<double>.FromGigabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKibibits(UnitsNet.QuantityValue)" />
-        public static Information Kibibits<T>(this T value) =>
-            Information.FromKibibits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromKibibits(T)" />
+        public static Information<double> Kibibits<T>(this T value) =>
+            Information<double>.FromKibibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKibibytes(UnitsNet.QuantityValue)" />
-        public static Information Kibibytes<T>(this T value) =>
-            Information.FromKibibytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromKibibytes(T)" />
+        public static Information<double> Kibibytes<T>(this T value) =>
+            Information<double>.FromKibibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKilobits(UnitsNet.QuantityValue)" />
-        public static Information Kilobits<T>(this T value) =>
-            Information.FromKilobits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromKilobits(T)" />
+        public static Information<double> Kilobits<T>(this T value) =>
+            Information<double>.FromKilobits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKilobytes(UnitsNet.QuantityValue)" />
-        public static Information Kilobytes<T>(this T value) =>
-            Information.FromKilobytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromKilobytes(T)" />
+        public static Information<double> Kilobytes<T>(this T value) =>
+            Information<double>.FromKilobytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMebibits(UnitsNet.QuantityValue)" />
-        public static Information Mebibits<T>(this T value) =>
-            Information.FromMebibits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromMebibits(T)" />
+        public static Information<double> Mebibits<T>(this T value) =>
+            Information<double>.FromMebibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMebibytes(UnitsNet.QuantityValue)" />
-        public static Information Mebibytes<T>(this T value) =>
-            Information.FromMebibytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromMebibytes(T)" />
+        public static Information<double> Mebibytes<T>(this T value) =>
+            Information<double>.FromMebibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMegabits(UnitsNet.QuantityValue)" />
-        public static Information Megabits<T>(this T value) =>
-            Information.FromMegabits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromMegabits(T)" />
+        public static Information<double> Megabits<T>(this T value) =>
+            Information<double>.FromMegabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMegabytes(UnitsNet.QuantityValue)" />
-        public static Information Megabytes<T>(this T value) =>
-            Information.FromMegabytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromMegabytes(T)" />
+        public static Information<double> Megabytes<T>(this T value) =>
+            Information<double>.FromMegabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPebibits(UnitsNet.QuantityValue)" />
-        public static Information Pebibits<T>(this T value) =>
-            Information.FromPebibits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromPebibits(T)" />
+        public static Information<double> Pebibits<T>(this T value) =>
+            Information<double>.FromPebibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPebibytes(UnitsNet.QuantityValue)" />
-        public static Information Pebibytes<T>(this T value) =>
-            Information.FromPebibytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromPebibytes(T)" />
+        public static Information<double> Pebibytes<T>(this T value) =>
+            Information<double>.FromPebibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPetabits(UnitsNet.QuantityValue)" />
-        public static Information Petabits<T>(this T value) =>
-            Information.FromPetabits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromPetabits(T)" />
+        public static Information<double> Petabits<T>(this T value) =>
+            Information<double>.FromPetabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPetabytes(UnitsNet.QuantityValue)" />
-        public static Information Petabytes<T>(this T value) =>
-            Information.FromPetabytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromPetabytes(T)" />
+        public static Information<double> Petabytes<T>(this T value) =>
+            Information<double>.FromPetabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTebibits(UnitsNet.QuantityValue)" />
-        public static Information Tebibits<T>(this T value) =>
-            Information.FromTebibits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromTebibits(T)" />
+        public static Information<double> Tebibits<T>(this T value) =>
+            Information<double>.FromTebibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTebibytes(UnitsNet.QuantityValue)" />
-        public static Information Tebibytes<T>(this T value) =>
-            Information.FromTebibytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromTebibytes(T)" />
+        public static Information<double> Tebibytes<T>(this T value) =>
+            Information<double>.FromTebibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTerabits(UnitsNet.QuantityValue)" />
-        public static Information Terabits<T>(this T value) =>
-            Information.FromTerabits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromTerabits(T)" />
+        public static Information<double> Terabits<T>(this T value) =>
+            Information<double>.FromTerabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTerabytes(UnitsNet.QuantityValue)" />
-        public static Information Terabytes<T>(this T value) =>
-            Information.FromTerabytes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Information{T}.FromTerabytes(T)" />
+        public static Information<double> Terabytes<T>(this T value) =>
+            Information<double>.FromTerabytes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
index 734ffc433c..671283838b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
@@ -28,61 +28,61 @@ namespace UnitsNet.NumberExtensions.NumberToIrradiance
     /// </summary>
     public static class NumberToIrradianceExtensions
     {
-        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiance KilowattsPerSquareCentimeter<T>(this T value) =>
-            Irradiance.FromKilowattsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromKilowattsPerSquareCentimeter(T)" />
+        public static Irradiance<double> KilowattsPerSquareCentimeter<T>(this T value) =>
+            Irradiance<double>.FromKilowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiance KilowattsPerSquareMeter<T>(this T value) =>
-            Irradiance.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromKilowattsPerSquareMeter(T)" />
+        public static Irradiance<double> KilowattsPerSquareMeter<T>(this T value) =>
+            Irradiance<double>.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiance MegawattsPerSquareCentimeter<T>(this T value) =>
-            Irradiance.FromMegawattsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromMegawattsPerSquareCentimeter(T)" />
+        public static Irradiance<double> MegawattsPerSquareCentimeter<T>(this T value) =>
+            Irradiance<double>.FromMegawattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiance MegawattsPerSquareMeter<T>(this T value) =>
-            Irradiance.FromMegawattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromMegawattsPerSquareMeter(T)" />
+        public static Irradiance<double> MegawattsPerSquareMeter<T>(this T value) =>
+            Irradiance<double>.FromMegawattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiance MicrowattsPerSquareCentimeter<T>(this T value) =>
-            Irradiance.FromMicrowattsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromMicrowattsPerSquareCentimeter(T)" />
+        public static Irradiance<double> MicrowattsPerSquareCentimeter<T>(this T value) =>
+            Irradiance<double>.FromMicrowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiance MicrowattsPerSquareMeter<T>(this T value) =>
-            Irradiance.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromMicrowattsPerSquareMeter(T)" />
+        public static Irradiance<double> MicrowattsPerSquareMeter<T>(this T value) =>
+            Irradiance<double>.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiance MilliwattsPerSquareCentimeter<T>(this T value) =>
-            Irradiance.FromMilliwattsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromMilliwattsPerSquareCentimeter(T)" />
+        public static Irradiance<double> MilliwattsPerSquareCentimeter<T>(this T value) =>
+            Irradiance<double>.FromMilliwattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiance MilliwattsPerSquareMeter<T>(this T value) =>
-            Irradiance.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromMilliwattsPerSquareMeter(T)" />
+        public static Irradiance<double> MilliwattsPerSquareMeter<T>(this T value) =>
+            Irradiance<double>.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiance NanowattsPerSquareCentimeter<T>(this T value) =>
-            Irradiance.FromNanowattsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromNanowattsPerSquareCentimeter(T)" />
+        public static Irradiance<double> NanowattsPerSquareCentimeter<T>(this T value) =>
+            Irradiance<double>.FromNanowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiance NanowattsPerSquareMeter<T>(this T value) =>
-            Irradiance.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromNanowattsPerSquareMeter(T)" />
+        public static Irradiance<double> NanowattsPerSquareMeter<T>(this T value) =>
+            Irradiance<double>.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiance PicowattsPerSquareCentimeter<T>(this T value) =>
-            Irradiance.FromPicowattsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromPicowattsPerSquareCentimeter(T)" />
+        public static Irradiance<double> PicowattsPerSquareCentimeter<T>(this T value) =>
+            Irradiance<double>.FromPicowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiance PicowattsPerSquareMeter<T>(this T value) =>
-            Irradiance.FromPicowattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromPicowattsPerSquareMeter(T)" />
+        public static Irradiance<double> PicowattsPerSquareMeter<T>(this T value) =>
+            Irradiance<double>.FromPicowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiance WattsPerSquareCentimeter<T>(this T value) =>
-            Irradiance.FromWattsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromWattsPerSquareCentimeter(T)" />
+        public static Irradiance<double> WattsPerSquareCentimeter<T>(this T value) =>
+            Irradiance<double>.FromWattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiance WattsPerSquareMeter<T>(this T value) =>
-            Irradiance.FromWattsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiance{T}.FromWattsPerSquareMeter(T)" />
+        public static Irradiance<double> WattsPerSquareMeter<T>(this T value) =>
+            Irradiance<double>.FromWattsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
index 9e088ab29f..239e887b9d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
@@ -28,33 +28,33 @@ namespace UnitsNet.NumberExtensions.NumberToIrradiation
     /// </summary>
     public static class NumberToIrradiationExtensions
     {
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiation JoulesPerSquareCentimeter<T>(this T value) =>
-            Irradiation.FromJoulesPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiation{T}.FromJoulesPerSquareCentimeter(T)" />
+        public static Irradiation<double> JoulesPerSquareCentimeter<T>(this T value) =>
+            Irradiation<double>.FromJoulesPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiation JoulesPerSquareMeter<T>(this T value) =>
-            Irradiation.FromJoulesPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiation{T}.FromJoulesPerSquareMeter(T)" />
+        public static Irradiation<double> JoulesPerSquareMeter<T>(this T value) =>
+            Irradiation<double>.FromJoulesPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static Irradiation JoulesPerSquareMillimeter<T>(this T value) =>
-            Irradiation.FromJoulesPerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiation{T}.FromJoulesPerSquareMillimeter(T)" />
+        public static Irradiation<double> JoulesPerSquareMillimeter<T>(this T value) =>
+            Irradiation<double>.FromJoulesPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiation KilojoulesPerSquareMeter<T>(this T value) =>
-            Irradiation.FromKilojoulesPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiation{T}.FromKilojoulesPerSquareMeter(T)" />
+        public static Irradiation<double> KilojoulesPerSquareMeter<T>(this T value) =>
+            Irradiation<double>.FromKilojoulesPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiation KilowattHoursPerSquareMeter<T>(this T value) =>
-            Irradiation.FromKilowattHoursPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiation{T}.FromKilowattHoursPerSquareMeter(T)" />
+        public static Irradiation<double> KilowattHoursPerSquareMeter<T>(this T value) =>
+            Irradiation<double>.FromKilowattHoursPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Irradiation MillijoulesPerSquareCentimeter<T>(this T value) =>
-            Irradiation.FromMillijoulesPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiation{T}.FromMillijoulesPerSquareCentimeter(T)" />
+        public static Irradiation<double> MillijoulesPerSquareCentimeter<T>(this T value) =>
+            Irradiation<double>.FromMillijoulesPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Irradiation WattHoursPerSquareMeter<T>(this T value) =>
-            Irradiation.FromWattHoursPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Irradiation{T}.FromWattHoursPerSquareMeter(T)" />
+        public static Irradiation<double> WattHoursPerSquareMeter<T>(this T value) =>
+            Irradiation<double>.FromWattHoursPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
index f60882e932..e3f77067ef 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
@@ -28,37 +28,37 @@ namespace UnitsNet.NumberExtensions.NumberToKinematicViscosity
     /// </summary>
     public static class NumberToKinematicViscosityExtensions
     {
-        /// <inheritdoc cref="KinematicViscosity.FromCentistokes(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity Centistokes<T>(this T value) =>
-            KinematicViscosity.FromCentistokes(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromCentistokes(T)" />
+        public static KinematicViscosity<double> Centistokes<T>(this T value) =>
+            KinematicViscosity<double>.FromCentistokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromDecistokes(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity Decistokes<T>(this T value) =>
-            KinematicViscosity.FromDecistokes(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromDecistokes(T)" />
+        public static KinematicViscosity<double> Decistokes<T>(this T value) =>
+            KinematicViscosity<double>.FromDecistokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromKilostokes(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity Kilostokes<T>(this T value) =>
-            KinematicViscosity.FromKilostokes(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromKilostokes(T)" />
+        public static KinematicViscosity<double> Kilostokes<T>(this T value) =>
+            KinematicViscosity<double>.FromKilostokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity Microstokes<T>(this T value) =>
-            KinematicViscosity.FromMicrostokes(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromMicrostokes(T)" />
+        public static KinematicViscosity<double> Microstokes<T>(this T value) =>
+            KinematicViscosity<double>.FromMicrostokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromMillistokes(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity Millistokes<T>(this T value) =>
-            KinematicViscosity.FromMillistokes(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromMillistokes(T)" />
+        public static KinematicViscosity<double> Millistokes<T>(this T value) =>
+            KinematicViscosity<double>.FromMillistokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromNanostokes(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity Nanostokes<T>(this T value) =>
-            KinematicViscosity.FromNanostokes(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromNanostokes(T)" />
+        public static KinematicViscosity<double> Nanostokes<T>(this T value) =>
+            KinematicViscosity<double>.FromNanostokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity SquareMetersPerSecond<T>(this T value) =>
-            KinematicViscosity.FromSquareMetersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromSquareMetersPerSecond(T)" />
+        public static KinematicViscosity<double> SquareMetersPerSecond<T>(this T value) =>
+            KinematicViscosity<double>.FromSquareMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromStokes(UnitsNet.QuantityValue)" />
-        public static KinematicViscosity Stokes<T>(this T value) =>
-            KinematicViscosity.FromStokes(Convert.ToDouble(value));
+        /// <inheritdoc cref="KinematicViscosity{T}.FromStokes(T)" />
+        public static KinematicViscosity<double> Stokes<T>(this T value) =>
+            KinematicViscosity<double>.FromStokes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLapseRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLapseRateExtensions.g.cs
index e80f4d7a13..1594dd1ad1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLapseRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLapseRateExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToLapseRate
     /// </summary>
     public static class NumberToLapseRateExtensions
     {
-        /// <inheritdoc cref="LapseRate.FromDegreesCelciusPerKilometer(UnitsNet.QuantityValue)" />
-        public static LapseRate DegreesCelciusPerKilometer<T>(this T value) =>
-            LapseRate.FromDegreesCelciusPerKilometer(Convert.ToDouble(value));
+        /// <inheritdoc cref="LapseRate{T}.FromDegreesCelciusPerKilometer(T)" />
+        public static LapseRate<double> DegreesCelciusPerKilometer<T>(this T value) =>
+            LapseRate<double>.FromDegreesCelciusPerKilometer(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
index f1f5e9245d..5f6b4577e0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
@@ -28,137 +28,137 @@ namespace UnitsNet.NumberExtensions.NumberToLength
     /// </summary>
     public static class NumberToLengthExtensions
     {
-        /// <inheritdoc cref="Length.FromAstronomicalUnits(UnitsNet.QuantityValue)" />
-        public static Length AstronomicalUnits<T>(this T value) =>
-            Length.FromAstronomicalUnits(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromAstronomicalUnits(T)" />
+        public static Length<double> AstronomicalUnits<T>(this T value) =>
+            Length<double>.FromAstronomicalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromCentimeters(UnitsNet.QuantityValue)" />
-        public static Length Centimeters<T>(this T value) =>
-            Length.FromCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromCentimeters(T)" />
+        public static Length<double> Centimeters<T>(this T value) =>
+            Length<double>.FromCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromChains(UnitsNet.QuantityValue)" />
-        public static Length Chains<T>(this T value) =>
-            Length.FromChains(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromChains(T)" />
+        public static Length<double> Chains<T>(this T value) =>
+            Length<double>.FromChains(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDecimeters(UnitsNet.QuantityValue)" />
-        public static Length Decimeters<T>(this T value) =>
-            Length.FromDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromDecimeters(T)" />
+        public static Length<double> Decimeters<T>(this T value) =>
+            Length<double>.FromDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDtpPicas(UnitsNet.QuantityValue)" />
-        public static Length DtpPicas<T>(this T value) =>
-            Length.FromDtpPicas(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromDtpPicas(T)" />
+        public static Length<double> DtpPicas<T>(this T value) =>
+            Length<double>.FromDtpPicas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDtpPoints(UnitsNet.QuantityValue)" />
-        public static Length DtpPoints<T>(this T value) =>
-            Length.FromDtpPoints(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromDtpPoints(T)" />
+        public static Length<double> DtpPoints<T>(this T value) =>
+            Length<double>.FromDtpPoints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromFathoms(UnitsNet.QuantityValue)" />
-        public static Length Fathoms<T>(this T value) =>
-            Length.FromFathoms(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromFathoms(T)" />
+        public static Length<double> Fathoms<T>(this T value) =>
+            Length<double>.FromFathoms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromFeet(UnitsNet.QuantityValue)" />
-        public static Length Feet<T>(this T value) =>
-            Length.FromFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromFeet(T)" />
+        public static Length<double> Feet<T>(this T value) =>
+            Length<double>.FromFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromHands(UnitsNet.QuantityValue)" />
-        public static Length Hands<T>(this T value) =>
-            Length.FromHands(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromHands(T)" />
+        public static Length<double> Hands<T>(this T value) =>
+            Length<double>.FromHands(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromHectometers(UnitsNet.QuantityValue)" />
-        public static Length Hectometers<T>(this T value) =>
-            Length.FromHectometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromHectometers(T)" />
+        public static Length<double> Hectometers<T>(this T value) =>
+            Length<double>.FromHectometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromInches(UnitsNet.QuantityValue)" />
-        public static Length Inches<T>(this T value) =>
-            Length.FromInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromInches(T)" />
+        public static Length<double> Inches<T>(this T value) =>
+            Length<double>.FromInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKilolightYears(UnitsNet.QuantityValue)" />
-        public static Length KilolightYears<T>(this T value) =>
-            Length.FromKilolightYears(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromKilolightYears(T)" />
+        public static Length<double> KilolightYears<T>(this T value) =>
+            Length<double>.FromKilolightYears(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKilometers(UnitsNet.QuantityValue)" />
-        public static Length Kilometers<T>(this T value) =>
-            Length.FromKilometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromKilometers(T)" />
+        public static Length<double> Kilometers<T>(this T value) =>
+            Length<double>.FromKilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKiloparsecs(UnitsNet.QuantityValue)" />
-        public static Length Kiloparsecs<T>(this T value) =>
-            Length.FromKiloparsecs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromKiloparsecs(T)" />
+        public static Length<double> Kiloparsecs<T>(this T value) =>
+            Length<double>.FromKiloparsecs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromLightYears(UnitsNet.QuantityValue)" />
-        public static Length LightYears<T>(this T value) =>
-            Length.FromLightYears(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromLightYears(T)" />
+        public static Length<double> LightYears<T>(this T value) =>
+            Length<double>.FromLightYears(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMegalightYears(UnitsNet.QuantityValue)" />
-        public static Length MegalightYears<T>(this T value) =>
-            Length.FromMegalightYears(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMegalightYears(T)" />
+        public static Length<double> MegalightYears<T>(this T value) =>
+            Length<double>.FromMegalightYears(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMegaparsecs(UnitsNet.QuantityValue)" />
-        public static Length Megaparsecs<T>(this T value) =>
-            Length.FromMegaparsecs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMegaparsecs(T)" />
+        public static Length<double> Megaparsecs<T>(this T value) =>
+            Length<double>.FromMegaparsecs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMeters(UnitsNet.QuantityValue)" />
-        public static Length Meters<T>(this T value) =>
-            Length.FromMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMeters(T)" />
+        public static Length<double> Meters<T>(this T value) =>
+            Length<double>.FromMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMicroinches(UnitsNet.QuantityValue)" />
-        public static Length Microinches<T>(this T value) =>
-            Length.FromMicroinches(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMicroinches(T)" />
+        public static Length<double> Microinches<T>(this T value) =>
+            Length<double>.FromMicroinches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMicrometers(UnitsNet.QuantityValue)" />
-        public static Length Micrometers<T>(this T value) =>
-            Length.FromMicrometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMicrometers(T)" />
+        public static Length<double> Micrometers<T>(this T value) =>
+            Length<double>.FromMicrometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMils(UnitsNet.QuantityValue)" />
-        public static Length Mils<T>(this T value) =>
-            Length.FromMils(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMils(T)" />
+        public static Length<double> Mils<T>(this T value) =>
+            Length<double>.FromMils(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMiles(UnitsNet.QuantityValue)" />
-        public static Length Miles<T>(this T value) =>
-            Length.FromMiles(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMiles(T)" />
+        public static Length<double> Miles<T>(this T value) =>
+            Length<double>.FromMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMillimeters(UnitsNet.QuantityValue)" />
-        public static Length Millimeters<T>(this T value) =>
-            Length.FromMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromMillimeters(T)" />
+        public static Length<double> Millimeters<T>(this T value) =>
+            Length<double>.FromMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromNanometers(UnitsNet.QuantityValue)" />
-        public static Length Nanometers<T>(this T value) =>
-            Length.FromNanometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromNanometers(T)" />
+        public static Length<double> Nanometers<T>(this T value) =>
+            Length<double>.FromNanometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromNauticalMiles(UnitsNet.QuantityValue)" />
-        public static Length NauticalMiles<T>(this T value) =>
-            Length.FromNauticalMiles(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromNauticalMiles(T)" />
+        public static Length<double> NauticalMiles<T>(this T value) =>
+            Length<double>.FromNauticalMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromParsecs(UnitsNet.QuantityValue)" />
-        public static Length Parsecs<T>(this T value) =>
-            Length.FromParsecs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromParsecs(T)" />
+        public static Length<double> Parsecs<T>(this T value) =>
+            Length<double>.FromParsecs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromPrinterPicas(UnitsNet.QuantityValue)" />
-        public static Length PrinterPicas<T>(this T value) =>
-            Length.FromPrinterPicas(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromPrinterPicas(T)" />
+        public static Length<double> PrinterPicas<T>(this T value) =>
+            Length<double>.FromPrinterPicas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromPrinterPoints(UnitsNet.QuantityValue)" />
-        public static Length PrinterPoints<T>(this T value) =>
-            Length.FromPrinterPoints(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromPrinterPoints(T)" />
+        public static Length<double> PrinterPoints<T>(this T value) =>
+            Length<double>.FromPrinterPoints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromShackles(UnitsNet.QuantityValue)" />
-        public static Length Shackles<T>(this T value) =>
-            Length.FromShackles(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromShackles(T)" />
+        public static Length<double> Shackles<T>(this T value) =>
+            Length<double>.FromShackles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromSolarRadiuses(UnitsNet.QuantityValue)" />
-        public static Length SolarRadiuses<T>(this T value) =>
-            Length.FromSolarRadiuses(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromSolarRadiuses(T)" />
+        public static Length<double> SolarRadiuses<T>(this T value) =>
+            Length<double>.FromSolarRadiuses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromTwips(UnitsNet.QuantityValue)" />
-        public static Length Twips<T>(this T value) =>
-            Length.FromTwips(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromTwips(T)" />
+        public static Length<double> Twips<T>(this T value) =>
+            Length<double>.FromTwips(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromUsSurveyFeet(UnitsNet.QuantityValue)" />
-        public static Length UsSurveyFeet<T>(this T value) =>
-            Length.FromUsSurveyFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromUsSurveyFeet(T)" />
+        public static Length<double> UsSurveyFeet<T>(this T value) =>
+            Length<double>.FromUsSurveyFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromYards(UnitsNet.QuantityValue)" />
-        public static Length Yards<T>(this T value) =>
-            Length.FromYards(Convert.ToDouble(value));
+        /// <inheritdoc cref="Length{T}.FromYards(T)" />
+        public static Length<double> Yards<T>(this T value) =>
+            Length<double>.FromYards(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
index 80242ee0a7..c71c4e26e2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
@@ -28,13 +28,13 @@ namespace UnitsNet.NumberExtensions.NumberToLevel
     /// </summary>
     public static class NumberToLevelExtensions
     {
-        /// <inheritdoc cref="Level.FromDecibels(UnitsNet.QuantityValue)" />
-        public static Level Decibels<T>(this T value) =>
-            Level.FromDecibels(Convert.ToDouble(value));
+        /// <inheritdoc cref="Level{T}.FromDecibels(T)" />
+        public static Level<double> Decibels<T>(this T value) =>
+            Level<double>.FromDecibels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Level.FromNepers(UnitsNet.QuantityValue)" />
-        public static Level Nepers<T>(this T value) =>
-            Level.FromNepers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Level{T}.FromNepers(T)" />
+        public static Level<double> Nepers<T>(this T value) =>
+            Level<double>.FromNepers(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
index 36eebf3c54..61b83e0c8a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
@@ -28,61 +28,61 @@ namespace UnitsNet.NumberExtensions.NumberToLinearDensity
     /// </summary>
     public static class NumberToLinearDensityExtensions
     {
-        /// <inheritdoc cref="LinearDensity.FromGramsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity GramsPerCentimeter<T>(this T value) =>
-            LinearDensity.FromGramsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromGramsPerCentimeter(T)" />
+        public static LinearDensity<double> GramsPerCentimeter<T>(this T value) =>
+            LinearDensity<double>.FromGramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity GramsPerMeter<T>(this T value) =>
-            LinearDensity.FromGramsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromGramsPerMeter(T)" />
+        public static LinearDensity<double> GramsPerMeter<T>(this T value) =>
+            LinearDensity<double>.FromGramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromGramsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity GramsPerMillimeter<T>(this T value) =>
-            LinearDensity.FromGramsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromGramsPerMillimeter(T)" />
+        public static LinearDensity<double> GramsPerMillimeter<T>(this T value) =>
+            LinearDensity<double>.FromGramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity KilogramsPerCentimeter<T>(this T value) =>
-            LinearDensity.FromKilogramsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromKilogramsPerCentimeter(T)" />
+        public static LinearDensity<double> KilogramsPerCentimeter<T>(this T value) =>
+            LinearDensity<double>.FromKilogramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity KilogramsPerMeter<T>(this T value) =>
-            LinearDensity.FromKilogramsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromKilogramsPerMeter(T)" />
+        public static LinearDensity<double> KilogramsPerMeter<T>(this T value) =>
+            LinearDensity<double>.FromKilogramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity KilogramsPerMillimeter<T>(this T value) =>
-            LinearDensity.FromKilogramsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromKilogramsPerMillimeter(T)" />
+        public static LinearDensity<double> KilogramsPerMillimeter<T>(this T value) =>
+            LinearDensity<double>.FromKilogramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity MicrogramsPerCentimeter<T>(this T value) =>
-            LinearDensity.FromMicrogramsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromMicrogramsPerCentimeter(T)" />
+        public static LinearDensity<double> MicrogramsPerCentimeter<T>(this T value) =>
+            LinearDensity<double>.FromMicrogramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity MicrogramsPerMeter<T>(this T value) =>
-            LinearDensity.FromMicrogramsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromMicrogramsPerMeter(T)" />
+        public static LinearDensity<double> MicrogramsPerMeter<T>(this T value) =>
+            LinearDensity<double>.FromMicrogramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity MicrogramsPerMillimeter<T>(this T value) =>
-            LinearDensity.FromMicrogramsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromMicrogramsPerMillimeter(T)" />
+        public static LinearDensity<double> MicrogramsPerMillimeter<T>(this T value) =>
+            LinearDensity<double>.FromMicrogramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity MilligramsPerCentimeter<T>(this T value) =>
-            LinearDensity.FromMilligramsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromMilligramsPerCentimeter(T)" />
+        public static LinearDensity<double> MilligramsPerCentimeter<T>(this T value) =>
+            LinearDensity<double>.FromMilligramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity MilligramsPerMeter<T>(this T value) =>
-            LinearDensity.FromMilligramsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromMilligramsPerMeter(T)" />
+        public static LinearDensity<double> MilligramsPerMeter<T>(this T value) =>
+            LinearDensity<double>.FromMilligramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearDensity MilligramsPerMillimeter<T>(this T value) =>
-            LinearDensity.FromMilligramsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromMilligramsPerMillimeter(T)" />
+        public static LinearDensity<double> MilligramsPerMillimeter<T>(this T value) =>
+            LinearDensity<double>.FromMilligramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(UnitsNet.QuantityValue)" />
-        public static LinearDensity PoundsPerFoot<T>(this T value) =>
-            LinearDensity.FromPoundsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromPoundsPerFoot(T)" />
+        public static LinearDensity<double> PoundsPerFoot<T>(this T value) =>
+            LinearDensity<double>.FromPoundsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromPoundsPerInch(UnitsNet.QuantityValue)" />
-        public static LinearDensity PoundsPerInch<T>(this T value) =>
-            LinearDensity.FromPoundsPerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearDensity{T}.FromPoundsPerInch(T)" />
+        public static LinearDensity<double> PoundsPerInch<T>(this T value) =>
+            LinearDensity<double>.FromPoundsPerInch(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
index 0e7a859fa0..ce985b81a4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
@@ -28,105 +28,105 @@ namespace UnitsNet.NumberExtensions.NumberToLinearPowerDensity
     /// </summary>
     public static class NumberToLinearPowerDensityExtensions
     {
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity GigawattsPerCentimeter<T>(this T value) =>
-            LinearPowerDensity.FromGigawattsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromGigawattsPerCentimeter(T)" />
+        public static LinearPowerDensity<double> GigawattsPerCentimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromGigawattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerFoot(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity GigawattsPerFoot<T>(this T value) =>
-            LinearPowerDensity.FromGigawattsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromGigawattsPerFoot(T)" />
+        public static LinearPowerDensity<double> GigawattsPerFoot<T>(this T value) =>
+            LinearPowerDensity<double>.FromGigawattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerInch(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity GigawattsPerInch<T>(this T value) =>
-            LinearPowerDensity.FromGigawattsPerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromGigawattsPerInch(T)" />
+        public static LinearPowerDensity<double> GigawattsPerInch<T>(this T value) =>
+            LinearPowerDensity<double>.FromGigawattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity GigawattsPerMeter<T>(this T value) =>
-            LinearPowerDensity.FromGigawattsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromGigawattsPerMeter(T)" />
+        public static LinearPowerDensity<double> GigawattsPerMeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromGigawattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity GigawattsPerMillimeter<T>(this T value) =>
-            LinearPowerDensity.FromGigawattsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromGigawattsPerMillimeter(T)" />
+        public static LinearPowerDensity<double> GigawattsPerMillimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromGigawattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity KilowattsPerCentimeter<T>(this T value) =>
-            LinearPowerDensity.FromKilowattsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromKilowattsPerCentimeter(T)" />
+        public static LinearPowerDensity<double> KilowattsPerCentimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromKilowattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerFoot(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity KilowattsPerFoot<T>(this T value) =>
-            LinearPowerDensity.FromKilowattsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromKilowattsPerFoot(T)" />
+        public static LinearPowerDensity<double> KilowattsPerFoot<T>(this T value) =>
+            LinearPowerDensity<double>.FromKilowattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerInch(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity KilowattsPerInch<T>(this T value) =>
-            LinearPowerDensity.FromKilowattsPerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromKilowattsPerInch(T)" />
+        public static LinearPowerDensity<double> KilowattsPerInch<T>(this T value) =>
+            LinearPowerDensity<double>.FromKilowattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity KilowattsPerMeter<T>(this T value) =>
-            LinearPowerDensity.FromKilowattsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromKilowattsPerMeter(T)" />
+        public static LinearPowerDensity<double> KilowattsPerMeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromKilowattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity KilowattsPerMillimeter<T>(this T value) =>
-            LinearPowerDensity.FromKilowattsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromKilowattsPerMillimeter(T)" />
+        public static LinearPowerDensity<double> KilowattsPerMillimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromKilowattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MegawattsPerCentimeter<T>(this T value) =>
-            LinearPowerDensity.FromMegawattsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMegawattsPerCentimeter(T)" />
+        public static LinearPowerDensity<double> MegawattsPerCentimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromMegawattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerFoot(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MegawattsPerFoot<T>(this T value) =>
-            LinearPowerDensity.FromMegawattsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMegawattsPerFoot(T)" />
+        public static LinearPowerDensity<double> MegawattsPerFoot<T>(this T value) =>
+            LinearPowerDensity<double>.FromMegawattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerInch(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MegawattsPerInch<T>(this T value) =>
-            LinearPowerDensity.FromMegawattsPerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMegawattsPerInch(T)" />
+        public static LinearPowerDensity<double> MegawattsPerInch<T>(this T value) =>
+            LinearPowerDensity<double>.FromMegawattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MegawattsPerMeter<T>(this T value) =>
-            LinearPowerDensity.FromMegawattsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMegawattsPerMeter(T)" />
+        public static LinearPowerDensity<double> MegawattsPerMeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromMegawattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MegawattsPerMillimeter<T>(this T value) =>
-            LinearPowerDensity.FromMegawattsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMegawattsPerMillimeter(T)" />
+        public static LinearPowerDensity<double> MegawattsPerMillimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromMegawattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MilliwattsPerCentimeter<T>(this T value) =>
-            LinearPowerDensity.FromMilliwattsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMilliwattsPerCentimeter(T)" />
+        public static LinearPowerDensity<double> MilliwattsPerCentimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromMilliwattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerFoot(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MilliwattsPerFoot<T>(this T value) =>
-            LinearPowerDensity.FromMilliwattsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMilliwattsPerFoot(T)" />
+        public static LinearPowerDensity<double> MilliwattsPerFoot<T>(this T value) =>
+            LinearPowerDensity<double>.FromMilliwattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerInch(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MilliwattsPerInch<T>(this T value) =>
-            LinearPowerDensity.FromMilliwattsPerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMilliwattsPerInch(T)" />
+        public static LinearPowerDensity<double> MilliwattsPerInch<T>(this T value) =>
+            LinearPowerDensity<double>.FromMilliwattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MilliwattsPerMeter<T>(this T value) =>
-            LinearPowerDensity.FromMilliwattsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMilliwattsPerMeter(T)" />
+        public static LinearPowerDensity<double> MilliwattsPerMeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromMilliwattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity MilliwattsPerMillimeter<T>(this T value) =>
-            LinearPowerDensity.FromMilliwattsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromMilliwattsPerMillimeter(T)" />
+        public static LinearPowerDensity<double> MilliwattsPerMillimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromMilliwattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerCentimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity WattsPerCentimeter<T>(this T value) =>
-            LinearPowerDensity.FromWattsPerCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromWattsPerCentimeter(T)" />
+        public static LinearPowerDensity<double> WattsPerCentimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromWattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerFoot(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity WattsPerFoot<T>(this T value) =>
-            LinearPowerDensity.FromWattsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromWattsPerFoot(T)" />
+        public static LinearPowerDensity<double> WattsPerFoot<T>(this T value) =>
+            LinearPowerDensity<double>.FromWattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerInch(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity WattsPerInch<T>(this T value) =>
-            LinearPowerDensity.FromWattsPerInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromWattsPerInch(T)" />
+        public static LinearPowerDensity<double> WattsPerInch<T>(this T value) =>
+            LinearPowerDensity<double>.FromWattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity WattsPerMeter<T>(this T value) =>
-            LinearPowerDensity.FromWattsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromWattsPerMeter(T)" />
+        public static LinearPowerDensity<double> WattsPerMeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromWattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMillimeter(UnitsNet.QuantityValue)" />
-        public static LinearPowerDensity WattsPerMillimeter<T>(this T value) =>
-            LinearPowerDensity.FromWattsPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="LinearPowerDensity{T}.FromWattsPerMillimeter(T)" />
+        public static LinearPowerDensity<double> WattsPerMillimeter<T>(this T value) =>
+            LinearPowerDensity<double>.FromWattsPerMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
index 878ac9b958..bac9c8cf9d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
@@ -28,61 +28,61 @@ namespace UnitsNet.NumberExtensions.NumberToLuminosity
     /// </summary>
     public static class NumberToLuminosityExtensions
     {
-        /// <inheritdoc cref="Luminosity.FromDecawatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Decawatts<T>(this T value) =>
-            Luminosity.FromDecawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromDecawatts(T)" />
+        public static Luminosity<double> Decawatts<T>(this T value) =>
+            Luminosity<double>.FromDecawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromDeciwatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Deciwatts<T>(this T value) =>
-            Luminosity.FromDeciwatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromDeciwatts(T)" />
+        public static Luminosity<double> Deciwatts<T>(this T value) =>
+            Luminosity<double>.FromDeciwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromFemtowatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Femtowatts<T>(this T value) =>
-            Luminosity.FromFemtowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromFemtowatts(T)" />
+        public static Luminosity<double> Femtowatts<T>(this T value) =>
+            Luminosity<double>.FromFemtowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromGigawatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Gigawatts<T>(this T value) =>
-            Luminosity.FromGigawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromGigawatts(T)" />
+        public static Luminosity<double> Gigawatts<T>(this T value) =>
+            Luminosity<double>.FromGigawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromKilowatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Kilowatts<T>(this T value) =>
-            Luminosity.FromKilowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromKilowatts(T)" />
+        public static Luminosity<double> Kilowatts<T>(this T value) =>
+            Luminosity<double>.FromKilowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromMegawatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Megawatts<T>(this T value) =>
-            Luminosity.FromMegawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromMegawatts(T)" />
+        public static Luminosity<double> Megawatts<T>(this T value) =>
+            Luminosity<double>.FromMegawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromMicrowatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Microwatts<T>(this T value) =>
-            Luminosity.FromMicrowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromMicrowatts(T)" />
+        public static Luminosity<double> Microwatts<T>(this T value) =>
+            Luminosity<double>.FromMicrowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromMilliwatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Milliwatts<T>(this T value) =>
-            Luminosity.FromMilliwatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromMilliwatts(T)" />
+        public static Luminosity<double> Milliwatts<T>(this T value) =>
+            Luminosity<double>.FromMilliwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromNanowatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Nanowatts<T>(this T value) =>
-            Luminosity.FromNanowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromNanowatts(T)" />
+        public static Luminosity<double> Nanowatts<T>(this T value) =>
+            Luminosity<double>.FromNanowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromPetawatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Petawatts<T>(this T value) =>
-            Luminosity.FromPetawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromPetawatts(T)" />
+        public static Luminosity<double> Petawatts<T>(this T value) =>
+            Luminosity<double>.FromPetawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromPicowatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Picowatts<T>(this T value) =>
-            Luminosity.FromPicowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromPicowatts(T)" />
+        public static Luminosity<double> Picowatts<T>(this T value) =>
+            Luminosity<double>.FromPicowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromSolarLuminosities(UnitsNet.QuantityValue)" />
-        public static Luminosity SolarLuminosities<T>(this T value) =>
-            Luminosity.FromSolarLuminosities(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromSolarLuminosities(T)" />
+        public static Luminosity<double> SolarLuminosities<T>(this T value) =>
+            Luminosity<double>.FromSolarLuminosities(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromTerawatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Terawatts<T>(this T value) =>
-            Luminosity.FromTerawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromTerawatts(T)" />
+        public static Luminosity<double> Terawatts<T>(this T value) =>
+            Luminosity<double>.FromTerawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromWatts(UnitsNet.QuantityValue)" />
-        public static Luminosity Watts<T>(this T value) =>
-            Luminosity.FromWatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Luminosity{T}.FromWatts(T)" />
+        public static Luminosity<double> Watts<T>(this T value) =>
+            Luminosity<double>.FromWatts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
index d23550d5a5..b4fdc3b2e9 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToLuminousFlux
     /// </summary>
     public static class NumberToLuminousFluxExtensions
     {
-        /// <inheritdoc cref="LuminousFlux.FromLumens(UnitsNet.QuantityValue)" />
-        public static LuminousFlux Lumens<T>(this T value) =>
-            LuminousFlux.FromLumens(Convert.ToDouble(value));
+        /// <inheritdoc cref="LuminousFlux{T}.FromLumens(T)" />
+        public static LuminousFlux<double> Lumens<T>(this T value) =>
+            LuminousFlux<double>.FromLumens(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
index ce02177e7f..c8db5fe806 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToLuminousIntensity
     /// </summary>
     public static class NumberToLuminousIntensityExtensions
     {
-        /// <inheritdoc cref="LuminousIntensity.FromCandela(UnitsNet.QuantityValue)" />
-        public static LuminousIntensity Candela<T>(this T value) =>
-            LuminousIntensity.FromCandela(Convert.ToDouble(value));
+        /// <inheritdoc cref="LuminousIntensity{T}.FromCandela(T)" />
+        public static LuminousIntensity<double> Candela<T>(this T value) =>
+            LuminousIntensity<double>.FromCandela(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
index 722a1c5b1f..5a598cd490 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
@@ -28,25 +28,25 @@ namespace UnitsNet.NumberExtensions.NumberToMagneticField
     /// </summary>
     public static class NumberToMagneticFieldExtensions
     {
-        /// <inheritdoc cref="MagneticField.FromGausses(UnitsNet.QuantityValue)" />
-        public static MagneticField Gausses<T>(this T value) =>
-            MagneticField.FromGausses(Convert.ToDouble(value));
+        /// <inheritdoc cref="MagneticField{T}.FromGausses(T)" />
+        public static MagneticField<double> Gausses<T>(this T value) =>
+            MagneticField<double>.FromGausses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromMicroteslas(UnitsNet.QuantityValue)" />
-        public static MagneticField Microteslas<T>(this T value) =>
-            MagneticField.FromMicroteslas(Convert.ToDouble(value));
+        /// <inheritdoc cref="MagneticField{T}.FromMicroteslas(T)" />
+        public static MagneticField<double> Microteslas<T>(this T value) =>
+            MagneticField<double>.FromMicroteslas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromMilliteslas(UnitsNet.QuantityValue)" />
-        public static MagneticField Milliteslas<T>(this T value) =>
-            MagneticField.FromMilliteslas(Convert.ToDouble(value));
+        /// <inheritdoc cref="MagneticField{T}.FromMilliteslas(T)" />
+        public static MagneticField<double> Milliteslas<T>(this T value) =>
+            MagneticField<double>.FromMilliteslas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromNanoteslas(UnitsNet.QuantityValue)" />
-        public static MagneticField Nanoteslas<T>(this T value) =>
-            MagneticField.FromNanoteslas(Convert.ToDouble(value));
+        /// <inheritdoc cref="MagneticField{T}.FromNanoteslas(T)" />
+        public static MagneticField<double> Nanoteslas<T>(this T value) =>
+            MagneticField<double>.FromNanoteslas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromTeslas(UnitsNet.QuantityValue)" />
-        public static MagneticField Teslas<T>(this T value) =>
-            MagneticField.FromTeslas(Convert.ToDouble(value));
+        /// <inheritdoc cref="MagneticField{T}.FromTeslas(T)" />
+        public static MagneticField<double> Teslas<T>(this T value) =>
+            MagneticField<double>.FromTeslas(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
index 4c598f62ea..8e20cd9fcf 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToMagneticFlux
     /// </summary>
     public static class NumberToMagneticFluxExtensions
     {
-        /// <inheritdoc cref="MagneticFlux.FromWebers(UnitsNet.QuantityValue)" />
-        public static MagneticFlux Webers<T>(this T value) =>
-            MagneticFlux.FromWebers(Convert.ToDouble(value));
+        /// <inheritdoc cref="MagneticFlux{T}.FromWebers(T)" />
+        public static MagneticFlux<double> Webers<T>(this T value) =>
+            MagneticFlux<double>.FromWebers(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
index 28704e19dd..c5431f5ae6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToMagnetization
     /// </summary>
     public static class NumberToMagnetizationExtensions
     {
-        /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(UnitsNet.QuantityValue)" />
-        public static Magnetization AmperesPerMeter<T>(this T value) =>
-            Magnetization.FromAmperesPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Magnetization{T}.FromAmperesPerMeter(T)" />
+        public static Magnetization<double> AmperesPerMeter<T>(this T value) =>
+            Magnetization<double>.FromAmperesPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
index 0979ffa03b..fe99f89054 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
@@ -28,193 +28,193 @@ namespace UnitsNet.NumberExtensions.NumberToMassConcentration
     /// </summary>
     public static class NumberToMassConcentrationExtensions
     {
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration CentigramsPerDeciliter<T>(this T value) =>
-            MassConcentration.FromCentigramsPerDeciliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromCentigramsPerDeciliter(T)" />
+        public static MassConcentration<double> CentigramsPerDeciliter<T>(this T value) =>
+            MassConcentration<double>.FromCentigramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration CentigramsPerLiter<T>(this T value) =>
-            MassConcentration.FromCentigramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromCentigramsPerLiter(T)" />
+        public static MassConcentration<double> CentigramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromCentigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMicroliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration CentigramsPerMicroliter<T>(this T value) =>
-            MassConcentration.FromCentigramsPerMicroliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromCentigramsPerMicroliter(T)" />
+        public static MassConcentration<double> CentigramsPerMicroliter<T>(this T value) =>
+            MassConcentration<double>.FromCentigramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration CentigramsPerMilliliter<T>(this T value) =>
-            MassConcentration.FromCentigramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromCentigramsPerMilliliter(T)" />
+        public static MassConcentration<double> CentigramsPerMilliliter<T>(this T value) =>
+            MassConcentration<double>.FromCentigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration DecigramsPerDeciliter<T>(this T value) =>
-            MassConcentration.FromDecigramsPerDeciliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromDecigramsPerDeciliter(T)" />
+        public static MassConcentration<double> DecigramsPerDeciliter<T>(this T value) =>
+            MassConcentration<double>.FromDecigramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration DecigramsPerLiter<T>(this T value) =>
-            MassConcentration.FromDecigramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromDecigramsPerLiter(T)" />
+        public static MassConcentration<double> DecigramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromDecigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMicroliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration DecigramsPerMicroliter<T>(this T value) =>
-            MassConcentration.FromDecigramsPerMicroliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromDecigramsPerMicroliter(T)" />
+        public static MassConcentration<double> DecigramsPerMicroliter<T>(this T value) =>
+            MassConcentration<double>.FromDecigramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration DecigramsPerMilliliter<T>(this T value) =>
-            MassConcentration.FromDecigramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromDecigramsPerMilliliter(T)" />
+        public static MassConcentration<double> DecigramsPerMilliliter<T>(this T value) =>
+            MassConcentration<double>.FromDecigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration GramsPerCubicCentimeter<T>(this T value) =>
-            MassConcentration.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromGramsPerCubicCentimeter(T)" />
+        public static MassConcentration<double> GramsPerCubicCentimeter<T>(this T value) =>
+            MassConcentration<double>.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration GramsPerCubicMeter<T>(this T value) =>
-            MassConcentration.FromGramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromGramsPerCubicMeter(T)" />
+        public static MassConcentration<double> GramsPerCubicMeter<T>(this T value) =>
+            MassConcentration<double>.FromGramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration GramsPerCubicMillimeter<T>(this T value) =>
-            MassConcentration.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromGramsPerCubicMillimeter(T)" />
+        public static MassConcentration<double> GramsPerCubicMillimeter<T>(this T value) =>
+            MassConcentration<double>.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration GramsPerDeciliter<T>(this T value) =>
-            MassConcentration.FromGramsPerDeciliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromGramsPerDeciliter(T)" />
+        public static MassConcentration<double> GramsPerDeciliter<T>(this T value) =>
+            MassConcentration<double>.FromGramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration GramsPerLiter<T>(this T value) =>
-            MassConcentration.FromGramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromGramsPerLiter(T)" />
+        public static MassConcentration<double> GramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromGramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerMicroliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration GramsPerMicroliter<T>(this T value) =>
-            MassConcentration.FromGramsPerMicroliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromGramsPerMicroliter(T)" />
+        public static MassConcentration<double> GramsPerMicroliter<T>(this T value) =>
+            MassConcentration<double>.FromGramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration GramsPerMilliliter<T>(this T value) =>
-            MassConcentration.FromGramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromGramsPerMilliliter(T)" />
+        public static MassConcentration<double> GramsPerMilliliter<T>(this T value) =>
+            MassConcentration<double>.FromGramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration KilogramsPerCubicCentimeter<T>(this T value) =>
-            MassConcentration.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromKilogramsPerCubicCentimeter(T)" />
+        public static MassConcentration<double> KilogramsPerCubicCentimeter<T>(this T value) =>
+            MassConcentration<double>.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration KilogramsPerCubicMeter<T>(this T value) =>
-            MassConcentration.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromKilogramsPerCubicMeter(T)" />
+        public static MassConcentration<double> KilogramsPerCubicMeter<T>(this T value) =>
+            MassConcentration<double>.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration KilogramsPerCubicMillimeter<T>(this T value) =>
-            MassConcentration.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromKilogramsPerCubicMillimeter(T)" />
+        public static MassConcentration<double> KilogramsPerCubicMillimeter<T>(this T value) =>
+            MassConcentration<double>.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration KilogramsPerLiter<T>(this T value) =>
-            MassConcentration.FromKilogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromKilogramsPerLiter(T)" />
+        public static MassConcentration<double> KilogramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromKilogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static MassConcentration KilopoundsPerCubicFoot<T>(this T value) =>
-            MassConcentration.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromKilopoundsPerCubicFoot(T)" />
+        public static MassConcentration<double> KilopoundsPerCubicFoot<T>(this T value) =>
+            MassConcentration<double>.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static MassConcentration KilopoundsPerCubicInch<T>(this T value) =>
-            MassConcentration.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromKilopoundsPerCubicInch(T)" />
+        public static MassConcentration<double> KilopoundsPerCubicInch<T>(this T value) =>
+            MassConcentration<double>.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MicrogramsPerCubicMeter<T>(this T value) =>
-            MassConcentration.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMicrogramsPerCubicMeter(T)" />
+        public static MassConcentration<double> MicrogramsPerCubicMeter<T>(this T value) =>
+            MassConcentration<double>.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MicrogramsPerDeciliter<T>(this T value) =>
-            MassConcentration.FromMicrogramsPerDeciliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMicrogramsPerDeciliter(T)" />
+        public static MassConcentration<double> MicrogramsPerDeciliter<T>(this T value) =>
+            MassConcentration<double>.FromMicrogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MicrogramsPerLiter<T>(this T value) =>
-            MassConcentration.FromMicrogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMicrogramsPerLiter(T)" />
+        public static MassConcentration<double> MicrogramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromMicrogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMicroliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MicrogramsPerMicroliter<T>(this T value) =>
-            MassConcentration.FromMicrogramsPerMicroliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMicrogramsPerMicroliter(T)" />
+        public static MassConcentration<double> MicrogramsPerMicroliter<T>(this T value) =>
+            MassConcentration<double>.FromMicrogramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MicrogramsPerMilliliter<T>(this T value) =>
-            MassConcentration.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMicrogramsPerMilliliter(T)" />
+        public static MassConcentration<double> MicrogramsPerMilliliter<T>(this T value) =>
+            MassConcentration<double>.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MilligramsPerCubicMeter<T>(this T value) =>
-            MassConcentration.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMilligramsPerCubicMeter(T)" />
+        public static MassConcentration<double> MilligramsPerCubicMeter<T>(this T value) =>
+            MassConcentration<double>.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MilligramsPerDeciliter<T>(this T value) =>
-            MassConcentration.FromMilligramsPerDeciliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMilligramsPerDeciliter(T)" />
+        public static MassConcentration<double> MilligramsPerDeciliter<T>(this T value) =>
+            MassConcentration<double>.FromMilligramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MilligramsPerLiter<T>(this T value) =>
-            MassConcentration.FromMilligramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMilligramsPerLiter(T)" />
+        public static MassConcentration<double> MilligramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromMilligramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMicroliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MilligramsPerMicroliter<T>(this T value) =>
-            MassConcentration.FromMilligramsPerMicroliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMilligramsPerMicroliter(T)" />
+        public static MassConcentration<double> MilligramsPerMicroliter<T>(this T value) =>
+            MassConcentration<double>.FromMilligramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration MilligramsPerMilliliter<T>(this T value) =>
-            MassConcentration.FromMilligramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromMilligramsPerMilliliter(T)" />
+        public static MassConcentration<double> MilligramsPerMilliliter<T>(this T value) =>
+            MassConcentration<double>.FromMilligramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration NanogramsPerDeciliter<T>(this T value) =>
-            MassConcentration.FromNanogramsPerDeciliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromNanogramsPerDeciliter(T)" />
+        public static MassConcentration<double> NanogramsPerDeciliter<T>(this T value) =>
+            MassConcentration<double>.FromNanogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration NanogramsPerLiter<T>(this T value) =>
-            MassConcentration.FromNanogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromNanogramsPerLiter(T)" />
+        public static MassConcentration<double> NanogramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromNanogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMicroliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration NanogramsPerMicroliter<T>(this T value) =>
-            MassConcentration.FromNanogramsPerMicroliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromNanogramsPerMicroliter(T)" />
+        public static MassConcentration<double> NanogramsPerMicroliter<T>(this T value) =>
+            MassConcentration<double>.FromNanogramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration NanogramsPerMilliliter<T>(this T value) =>
-            MassConcentration.FromNanogramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromNanogramsPerMilliliter(T)" />
+        public static MassConcentration<double> NanogramsPerMilliliter<T>(this T value) =>
+            MassConcentration<double>.FromNanogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration PicogramsPerDeciliter<T>(this T value) =>
-            MassConcentration.FromPicogramsPerDeciliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPicogramsPerDeciliter(T)" />
+        public static MassConcentration<double> PicogramsPerDeciliter<T>(this T value) =>
+            MassConcentration<double>.FromPicogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
-        public static MassConcentration PicogramsPerLiter<T>(this T value) =>
-            MassConcentration.FromPicogramsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPicogramsPerLiter(T)" />
+        public static MassConcentration<double> PicogramsPerLiter<T>(this T value) =>
+            MassConcentration<double>.FromPicogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMicroliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration PicogramsPerMicroliter<T>(this T value) =>
-            MassConcentration.FromPicogramsPerMicroliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPicogramsPerMicroliter(T)" />
+        public static MassConcentration<double> PicogramsPerMicroliter<T>(this T value) =>
+            MassConcentration<double>.FromPicogramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
-        public static MassConcentration PicogramsPerMilliliter<T>(this T value) =>
-            MassConcentration.FromPicogramsPerMilliliter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPicogramsPerMilliliter(T)" />
+        public static MassConcentration<double> PicogramsPerMilliliter<T>(this T value) =>
+            MassConcentration<double>.FromPicogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static MassConcentration PoundsPerCubicFoot<T>(this T value) =>
-            MassConcentration.FromPoundsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPoundsPerCubicFoot(T)" />
+        public static MassConcentration<double> PoundsPerCubicFoot<T>(this T value) =>
+            MassConcentration<double>.FromPoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static MassConcentration PoundsPerCubicInch<T>(this T value) =>
-            MassConcentration.FromPoundsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPoundsPerCubicInch(T)" />
+        public static MassConcentration<double> PoundsPerCubicInch<T>(this T value) =>
+            MassConcentration<double>.FromPoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
-        public static MassConcentration PoundsPerImperialGallon<T>(this T value) =>
-            MassConcentration.FromPoundsPerImperialGallon(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPoundsPerImperialGallon(T)" />
+        public static MassConcentration<double> PoundsPerImperialGallon<T>(this T value) =>
+            MassConcentration<double>.FromPoundsPerImperialGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
-        public static MassConcentration PoundsPerUSGallon<T>(this T value) =>
-            MassConcentration.FromPoundsPerUSGallon(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromPoundsPerUSGallon(T)" />
+        public static MassConcentration<double> PoundsPerUSGallon<T>(this T value) =>
+            MassConcentration<double>.FromPoundsPerUSGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static MassConcentration SlugsPerCubicFoot<T>(this T value) =>
-            MassConcentration.FromSlugsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromSlugsPerCubicFoot(T)" />
+        public static MassConcentration<double> SlugsPerCubicFoot<T>(this T value) =>
+            MassConcentration<double>.FromSlugsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration TonnesPerCubicCentimeter<T>(this T value) =>
-            MassConcentration.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromTonnesPerCubicCentimeter(T)" />
+        public static MassConcentration<double> TonnesPerCubicCentimeter<T>(this T value) =>
+            MassConcentration<double>.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration TonnesPerCubicMeter<T>(this T value) =>
-            MassConcentration.FromTonnesPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromTonnesPerCubicMeter(T)" />
+        public static MassConcentration<double> TonnesPerCubicMeter<T>(this T value) =>
+            MassConcentration<double>.FromTonnesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static MassConcentration TonnesPerCubicMillimeter<T>(this T value) =>
-            MassConcentration.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassConcentration{T}.FromTonnesPerCubicMillimeter(T)" />
+        public static MassConcentration<double> TonnesPerCubicMillimeter<T>(this T value) =>
+            MassConcentration<double>.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
index 907e00bc31..b18423d07a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
@@ -28,105 +28,105 @@ namespace UnitsNet.NumberExtensions.NumberToMass
     /// </summary>
     public static class NumberToMassExtensions
     {
-        /// <inheritdoc cref="Mass.FromCentigrams(UnitsNet.QuantityValue)" />
-        public static Mass Centigrams<T>(this T value) =>
-            Mass.FromCentigrams(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromCentigrams(T)" />
+        public static Mass<double> Centigrams<T>(this T value) =>
+            Mass<double>.FromCentigrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromDecagrams(UnitsNet.QuantityValue)" />
-        public static Mass Decagrams<T>(this T value) =>
-            Mass.FromDecagrams(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromDecagrams(T)" />
+        public static Mass<double> Decagrams<T>(this T value) =>
+            Mass<double>.FromDecagrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromDecigrams(UnitsNet.QuantityValue)" />
-        public static Mass Decigrams<T>(this T value) =>
-            Mass.FromDecigrams(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromDecigrams(T)" />
+        public static Mass<double> Decigrams<T>(this T value) =>
+            Mass<double>.FromDecigrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromEarthMasses(UnitsNet.QuantityValue)" />
-        public static Mass EarthMasses<T>(this T value) =>
-            Mass.FromEarthMasses(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromEarthMasses(T)" />
+        public static Mass<double> EarthMasses<T>(this T value) =>
+            Mass<double>.FromEarthMasses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromGrains(UnitsNet.QuantityValue)" />
-        public static Mass Grains<T>(this T value) =>
-            Mass.FromGrains(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromGrains(T)" />
+        public static Mass<double> Grains<T>(this T value) =>
+            Mass<double>.FromGrains(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromGrams(UnitsNet.QuantityValue)" />
-        public static Mass Grams<T>(this T value) =>
-            Mass.FromGrams(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromGrams(T)" />
+        public static Mass<double> Grams<T>(this T value) =>
+            Mass<double>.FromGrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromHectograms(UnitsNet.QuantityValue)" />
-        public static Mass Hectograms<T>(this T value) =>
-            Mass.FromHectograms(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromHectograms(T)" />
+        public static Mass<double> Hectograms<T>(this T value) =>
+            Mass<double>.FromHectograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromKilograms(UnitsNet.QuantityValue)" />
-        public static Mass Kilograms<T>(this T value) =>
-            Mass.FromKilograms(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromKilograms(T)" />
+        public static Mass<double> Kilograms<T>(this T value) =>
+            Mass<double>.FromKilograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromKilopounds(UnitsNet.QuantityValue)" />
-        public static Mass Kilopounds<T>(this T value) =>
-            Mass.FromKilopounds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromKilopounds(T)" />
+        public static Mass<double> Kilopounds<T>(this T value) =>
+            Mass<double>.FromKilopounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromKilotonnes(UnitsNet.QuantityValue)" />
-        public static Mass Kilotonnes<T>(this T value) =>
-            Mass.FromKilotonnes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromKilotonnes(T)" />
+        public static Mass<double> Kilotonnes<T>(this T value) =>
+            Mass<double>.FromKilotonnes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromLongHundredweight(UnitsNet.QuantityValue)" />
-        public static Mass LongHundredweight<T>(this T value) =>
-            Mass.FromLongHundredweight(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromLongHundredweight(T)" />
+        public static Mass<double> LongHundredweight<T>(this T value) =>
+            Mass<double>.FromLongHundredweight(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromLongTons(UnitsNet.QuantityValue)" />
-        public static Mass LongTons<T>(this T value) =>
-            Mass.FromLongTons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromLongTons(T)" />
+        public static Mass<double> LongTons<T>(this T value) =>
+            Mass<double>.FromLongTons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMegapounds(UnitsNet.QuantityValue)" />
-        public static Mass Megapounds<T>(this T value) =>
-            Mass.FromMegapounds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromMegapounds(T)" />
+        public static Mass<double> Megapounds<T>(this T value) =>
+            Mass<double>.FromMegapounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMegatonnes(UnitsNet.QuantityValue)" />
-        public static Mass Megatonnes<T>(this T value) =>
-            Mass.FromMegatonnes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromMegatonnes(T)" />
+        public static Mass<double> Megatonnes<T>(this T value) =>
+            Mass<double>.FromMegatonnes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMicrograms(UnitsNet.QuantityValue)" />
-        public static Mass Micrograms<T>(this T value) =>
-            Mass.FromMicrograms(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromMicrograms(T)" />
+        public static Mass<double> Micrograms<T>(this T value) =>
+            Mass<double>.FromMicrograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMilligrams(UnitsNet.QuantityValue)" />
-        public static Mass Milligrams<T>(this T value) =>
-            Mass.FromMilligrams(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromMilligrams(T)" />
+        public static Mass<double> Milligrams<T>(this T value) =>
+            Mass<double>.FromMilligrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromNanograms(UnitsNet.QuantityValue)" />
-        public static Mass Nanograms<T>(this T value) =>
-            Mass.FromNanograms(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromNanograms(T)" />
+        public static Mass<double> Nanograms<T>(this T value) =>
+            Mass<double>.FromNanograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromOunces(UnitsNet.QuantityValue)" />
-        public static Mass Ounces<T>(this T value) =>
-            Mass.FromOunces(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromOunces(T)" />
+        public static Mass<double> Ounces<T>(this T value) =>
+            Mass<double>.FromOunces(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromPounds(UnitsNet.QuantityValue)" />
-        public static Mass Pounds<T>(this T value) =>
-            Mass.FromPounds(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromPounds(T)" />
+        public static Mass<double> Pounds<T>(this T value) =>
+            Mass<double>.FromPounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromShortHundredweight(UnitsNet.QuantityValue)" />
-        public static Mass ShortHundredweight<T>(this T value) =>
-            Mass.FromShortHundredweight(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromShortHundredweight(T)" />
+        public static Mass<double> ShortHundredweight<T>(this T value) =>
+            Mass<double>.FromShortHundredweight(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromShortTons(UnitsNet.QuantityValue)" />
-        public static Mass ShortTons<T>(this T value) =>
-            Mass.FromShortTons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromShortTons(T)" />
+        public static Mass<double> ShortTons<T>(this T value) =>
+            Mass<double>.FromShortTons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromSlugs(UnitsNet.QuantityValue)" />
-        public static Mass Slugs<T>(this T value) =>
-            Mass.FromSlugs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromSlugs(T)" />
+        public static Mass<double> Slugs<T>(this T value) =>
+            Mass<double>.FromSlugs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromSolarMasses(UnitsNet.QuantityValue)" />
-        public static Mass SolarMasses<T>(this T value) =>
-            Mass.FromSolarMasses(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromSolarMasses(T)" />
+        public static Mass<double> SolarMasses<T>(this T value) =>
+            Mass<double>.FromSolarMasses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromStone(UnitsNet.QuantityValue)" />
-        public static Mass Stone<T>(this T value) =>
-            Mass.FromStone(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromStone(T)" />
+        public static Mass<double> Stone<T>(this T value) =>
+            Mass<double>.FromStone(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromTonnes(UnitsNet.QuantityValue)" />
-        public static Mass Tonnes<T>(this T value) =>
-            Mass.FromTonnes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Mass{T}.FromTonnes(T)" />
+        public static Mass<double> Tonnes<T>(this T value) =>
+            Mass<double>.FromTonnes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
index 9217485672..249aaeccfe 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
@@ -28,137 +28,137 @@ namespace UnitsNet.NumberExtensions.NumberToMassFlow
     /// </summary>
     public static class NumberToMassFlowExtensions
     {
-        /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow CentigramsPerDay<T>(this T value) =>
-            MassFlow.FromCentigramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromCentigramsPerDay(T)" />
+        public static MassFlow<double> CentigramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromCentigramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow CentigramsPerSecond<T>(this T value) =>
-            MassFlow.FromCentigramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromCentigramsPerSecond(T)" />
+        public static MassFlow<double> CentigramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromCentigramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow DecagramsPerDay<T>(this T value) =>
-            MassFlow.FromDecagramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromDecagramsPerDay(T)" />
+        public static MassFlow<double> DecagramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromDecagramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow DecagramsPerSecond<T>(this T value) =>
-            MassFlow.FromDecagramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromDecagramsPerSecond(T)" />
+        public static MassFlow<double> DecagramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromDecagramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow DecigramsPerDay<T>(this T value) =>
-            MassFlow.FromDecigramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromDecigramsPerDay(T)" />
+        public static MassFlow<double> DecigramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromDecigramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow DecigramsPerSecond<T>(this T value) =>
-            MassFlow.FromDecigramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromDecigramsPerSecond(T)" />
+        public static MassFlow<double> DecigramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromDecigramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow GramsPerDay<T>(this T value) =>
-            MassFlow.FromGramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromGramsPerDay(T)" />
+        public static MassFlow<double> GramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromGramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerHour(UnitsNet.QuantityValue)" />
-        public static MassFlow GramsPerHour<T>(this T value) =>
-            MassFlow.FromGramsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromGramsPerHour(T)" />
+        public static MassFlow<double> GramsPerHour<T>(this T value) =>
+            MassFlow<double>.FromGramsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow GramsPerSecond<T>(this T value) =>
-            MassFlow.FromGramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromGramsPerSecond(T)" />
+        public static MassFlow<double> GramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromGramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow HectogramsPerDay<T>(this T value) =>
-            MassFlow.FromHectogramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromHectogramsPerDay(T)" />
+        public static MassFlow<double> HectogramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromHectogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow HectogramsPerSecond<T>(this T value) =>
-            MassFlow.FromHectogramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromHectogramsPerSecond(T)" />
+        public static MassFlow<double> HectogramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromHectogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow KilogramsPerDay<T>(this T value) =>
-            MassFlow.FromKilogramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromKilogramsPerDay(T)" />
+        public static MassFlow<double> KilogramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromKilogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(UnitsNet.QuantityValue)" />
-        public static MassFlow KilogramsPerHour<T>(this T value) =>
-            MassFlow.FromKilogramsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromKilogramsPerHour(T)" />
+        public static MassFlow<double> KilogramsPerHour<T>(this T value) =>
+            MassFlow<double>.FromKilogramsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(UnitsNet.QuantityValue)" />
-        public static MassFlow KilogramsPerMinute<T>(this T value) =>
-            MassFlow.FromKilogramsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromKilogramsPerMinute(T)" />
+        public static MassFlow<double> KilogramsPerMinute<T>(this T value) =>
+            MassFlow<double>.FromKilogramsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow KilogramsPerSecond<T>(this T value) =>
-            MassFlow.FromKilogramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromKilogramsPerSecond(T)" />
+        public static MassFlow<double> KilogramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromKilogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow MegagramsPerDay<T>(this T value) =>
-            MassFlow.FromMegagramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMegagramsPerDay(T)" />
+        public static MassFlow<double> MegagramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromMegagramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow MegapoundsPerDay<T>(this T value) =>
-            MassFlow.FromMegapoundsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMegapoundsPerDay(T)" />
+        public static MassFlow<double> MegapoundsPerDay<T>(this T value) =>
+            MassFlow<double>.FromMegapoundsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(UnitsNet.QuantityValue)" />
-        public static MassFlow MegapoundsPerHour<T>(this T value) =>
-            MassFlow.FromMegapoundsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMegapoundsPerHour(T)" />
+        public static MassFlow<double> MegapoundsPerHour<T>(this T value) =>
+            MassFlow<double>.FromMegapoundsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(UnitsNet.QuantityValue)" />
-        public static MassFlow MegapoundsPerMinute<T>(this T value) =>
-            MassFlow.FromMegapoundsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMegapoundsPerMinute(T)" />
+        public static MassFlow<double> MegapoundsPerMinute<T>(this T value) =>
+            MassFlow<double>.FromMegapoundsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow MegapoundsPerSecond<T>(this T value) =>
-            MassFlow.FromMegapoundsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMegapoundsPerSecond(T)" />
+        public static MassFlow<double> MegapoundsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromMegapoundsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow MicrogramsPerDay<T>(this T value) =>
-            MassFlow.FromMicrogramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMicrogramsPerDay(T)" />
+        public static MassFlow<double> MicrogramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromMicrogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow MicrogramsPerSecond<T>(this T value) =>
-            MassFlow.FromMicrogramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMicrogramsPerSecond(T)" />
+        public static MassFlow<double> MicrogramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromMicrogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow MilligramsPerDay<T>(this T value) =>
-            MassFlow.FromMilligramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMilligramsPerDay(T)" />
+        public static MassFlow<double> MilligramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromMilligramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow MilligramsPerSecond<T>(this T value) =>
-            MassFlow.FromMilligramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromMilligramsPerSecond(T)" />
+        public static MassFlow<double> MilligramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromMilligramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow NanogramsPerDay<T>(this T value) =>
-            MassFlow.FromNanogramsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromNanogramsPerDay(T)" />
+        public static MassFlow<double> NanogramsPerDay<T>(this T value) =>
+            MassFlow<double>.FromNanogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow NanogramsPerSecond<T>(this T value) =>
-            MassFlow.FromNanogramsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromNanogramsPerSecond(T)" />
+        public static MassFlow<double> NanogramsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromNanogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow PoundsPerDay<T>(this T value) =>
-            MassFlow.FromPoundsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromPoundsPerDay(T)" />
+        public static MassFlow<double> PoundsPerDay<T>(this T value) =>
+            MassFlow<double>.FromPoundsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerHour(UnitsNet.QuantityValue)" />
-        public static MassFlow PoundsPerHour<T>(this T value) =>
-            MassFlow.FromPoundsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromPoundsPerHour(T)" />
+        public static MassFlow<double> PoundsPerHour<T>(this T value) =>
+            MassFlow<double>.FromPoundsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(UnitsNet.QuantityValue)" />
-        public static MassFlow PoundsPerMinute<T>(this T value) =>
-            MassFlow.FromPoundsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromPoundsPerMinute(T)" />
+        public static MassFlow<double> PoundsPerMinute<T>(this T value) =>
+            MassFlow<double>.FromPoundsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(UnitsNet.QuantityValue)" />
-        public static MassFlow PoundsPerSecond<T>(this T value) =>
-            MassFlow.FromPoundsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromPoundsPerSecond(T)" />
+        public static MassFlow<double> PoundsPerSecond<T>(this T value) =>
+            MassFlow<double>.FromPoundsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(UnitsNet.QuantityValue)" />
-        public static MassFlow ShortTonsPerHour<T>(this T value) =>
-            MassFlow.FromShortTonsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromShortTonsPerHour(T)" />
+        public static MassFlow<double> ShortTonsPerHour<T>(this T value) =>
+            MassFlow<double>.FromShortTonsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromTonnesPerDay(UnitsNet.QuantityValue)" />
-        public static MassFlow TonnesPerDay<T>(this T value) =>
-            MassFlow.FromTonnesPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromTonnesPerDay(T)" />
+        public static MassFlow<double> TonnesPerDay<T>(this T value) =>
+            MassFlow<double>.FromTonnesPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromTonnesPerHour(UnitsNet.QuantityValue)" />
-        public static MassFlow TonnesPerHour<T>(this T value) =>
-            MassFlow.FromTonnesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlow{T}.FromTonnesPerHour(T)" />
+        public static MassFlow<double> TonnesPerHour<T>(this T value) =>
+            MassFlow<double>.FromTonnesPerHour(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
index a91acf9031..c87fddb181 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
@@ -28,53 +28,53 @@ namespace UnitsNet.NumberExtensions.NumberToMassFlux
     /// </summary>
     public static class NumberToMassFluxExtensions
     {
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux GramsPerHourPerSquareCentimeter<T>(this T value) =>
-            MassFlux.FromGramsPerHourPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromGramsPerHourPerSquareCentimeter(T)" />
+        public static MassFlux<double> GramsPerHourPerSquareCentimeter<T>(this T value) =>
+            MassFlux<double>.FromGramsPerHourPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static MassFlux GramsPerHourPerSquareMeter<T>(this T value) =>
-            MassFlux.FromGramsPerHourPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromGramsPerHourPerSquareMeter(T)" />
+        public static MassFlux<double> GramsPerHourPerSquareMeter<T>(this T value) =>
+            MassFlux<double>.FromGramsPerHourPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux GramsPerHourPerSquareMillimeter<T>(this T value) =>
-            MassFlux.FromGramsPerHourPerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromGramsPerHourPerSquareMillimeter(T)" />
+        public static MassFlux<double> GramsPerHourPerSquareMillimeter<T>(this T value) =>
+            MassFlux<double>.FromGramsPerHourPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux GramsPerSecondPerSquareCentimeter<T>(this T value) =>
-            MassFlux.FromGramsPerSecondPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromGramsPerSecondPerSquareCentimeter(T)" />
+        public static MassFlux<double> GramsPerSecondPerSquareCentimeter<T>(this T value) =>
+            MassFlux<double>.FromGramsPerSecondPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static MassFlux GramsPerSecondPerSquareMeter<T>(this T value) =>
-            MassFlux.FromGramsPerSecondPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromGramsPerSecondPerSquareMeter(T)" />
+        public static MassFlux<double> GramsPerSecondPerSquareMeter<T>(this T value) =>
+            MassFlux<double>.FromGramsPerSecondPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux GramsPerSecondPerSquareMillimeter<T>(this T value) =>
-            MassFlux.FromGramsPerSecondPerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromGramsPerSecondPerSquareMillimeter(T)" />
+        public static MassFlux<double> GramsPerSecondPerSquareMillimeter<T>(this T value) =>
+            MassFlux<double>.FromGramsPerSecondPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux KilogramsPerHourPerSquareCentimeter<T>(this T value) =>
-            MassFlux.FromKilogramsPerHourPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromKilogramsPerHourPerSquareCentimeter(T)" />
+        public static MassFlux<double> KilogramsPerHourPerSquareCentimeter<T>(this T value) =>
+            MassFlux<double>.FromKilogramsPerHourPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static MassFlux KilogramsPerHourPerSquareMeter<T>(this T value) =>
-            MassFlux.FromKilogramsPerHourPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromKilogramsPerHourPerSquareMeter(T)" />
+        public static MassFlux<double> KilogramsPerHourPerSquareMeter<T>(this T value) =>
+            MassFlux<double>.FromKilogramsPerHourPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux KilogramsPerHourPerSquareMillimeter<T>(this T value) =>
-            MassFlux.FromKilogramsPerHourPerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromKilogramsPerHourPerSquareMillimeter(T)" />
+        public static MassFlux<double> KilogramsPerHourPerSquareMillimeter<T>(this T value) =>
+            MassFlux<double>.FromKilogramsPerHourPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux KilogramsPerSecondPerSquareCentimeter<T>(this T value) =>
-            MassFlux.FromKilogramsPerSecondPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromKilogramsPerSecondPerSquareCentimeter(T)" />
+        public static MassFlux<double> KilogramsPerSecondPerSquareCentimeter<T>(this T value) =>
+            MassFlux<double>.FromKilogramsPerSecondPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static MassFlux KilogramsPerSecondPerSquareMeter<T>(this T value) =>
-            MassFlux.FromKilogramsPerSecondPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromKilogramsPerSecondPerSquareMeter(T)" />
+        public static MassFlux<double> KilogramsPerSecondPerSquareMeter<T>(this T value) =>
+            MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static MassFlux KilogramsPerSecondPerSquareMillimeter<T>(this T value) =>
-            MassFlux.FromKilogramsPerSecondPerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFlux{T}.FromKilogramsPerSecondPerSquareMillimeter(T)" />
+        public static MassFlux<double> KilogramsPerSecondPerSquareMillimeter<T>(this T value) =>
+            MassFlux<double>.FromKilogramsPerSecondPerSquareMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
index 95385c3373..a64e942369 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
@@ -28,101 +28,101 @@ namespace UnitsNet.NumberExtensions.NumberToMassFraction
     /// </summary>
     public static class NumberToMassFractionExtensions
     {
-        /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction CentigramsPerGram<T>(this T value) =>
-            MassFraction.FromCentigramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromCentigramsPerGram(T)" />
+        public static MassFraction<double> CentigramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromCentigramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction CentigramsPerKilogram<T>(this T value) =>
-            MassFraction.FromCentigramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromCentigramsPerKilogram(T)" />
+        public static MassFraction<double> CentigramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromCentigramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction DecagramsPerGram<T>(this T value) =>
-            MassFraction.FromDecagramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromDecagramsPerGram(T)" />
+        public static MassFraction<double> DecagramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromDecagramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction DecagramsPerKilogram<T>(this T value) =>
-            MassFraction.FromDecagramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromDecagramsPerKilogram(T)" />
+        public static MassFraction<double> DecagramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromDecagramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction DecigramsPerGram<T>(this T value) =>
-            MassFraction.FromDecigramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromDecigramsPerGram(T)" />
+        public static MassFraction<double> DecigramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromDecigramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction DecigramsPerKilogram<T>(this T value) =>
-            MassFraction.FromDecigramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromDecigramsPerKilogram(T)" />
+        public static MassFraction<double> DecigramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromDecigramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecimalFractions(UnitsNet.QuantityValue)" />
-        public static MassFraction DecimalFractions<T>(this T value) =>
-            MassFraction.FromDecimalFractions(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromDecimalFractions(T)" />
+        public static MassFraction<double> DecimalFractions<T>(this T value) =>
+            MassFraction<double>.FromDecimalFractions(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromGramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction GramsPerGram<T>(this T value) =>
-            MassFraction.FromGramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromGramsPerGram(T)" />
+        public static MassFraction<double> GramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromGramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction GramsPerKilogram<T>(this T value) =>
-            MassFraction.FromGramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromGramsPerKilogram(T)" />
+        public static MassFraction<double> GramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromGramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction HectogramsPerGram<T>(this T value) =>
-            MassFraction.FromHectogramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromHectogramsPerGram(T)" />
+        public static MassFraction<double> HectogramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromHectogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction HectogramsPerKilogram<T>(this T value) =>
-            MassFraction.FromHectogramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromHectogramsPerKilogram(T)" />
+        public static MassFraction<double> HectogramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromHectogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction KilogramsPerGram<T>(this T value) =>
-            MassFraction.FromKilogramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromKilogramsPerGram(T)" />
+        public static MassFraction<double> KilogramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromKilogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction KilogramsPerKilogram<T>(this T value) =>
-            MassFraction.FromKilogramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromKilogramsPerKilogram(T)" />
+        public static MassFraction<double> KilogramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromKilogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction MicrogramsPerGram<T>(this T value) =>
-            MassFraction.FromMicrogramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromMicrogramsPerGram(T)" />
+        public static MassFraction<double> MicrogramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromMicrogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction MicrogramsPerKilogram<T>(this T value) =>
-            MassFraction.FromMicrogramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromMicrogramsPerKilogram(T)" />
+        public static MassFraction<double> MicrogramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromMicrogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction MilligramsPerGram<T>(this T value) =>
-            MassFraction.FromMilligramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromMilligramsPerGram(T)" />
+        public static MassFraction<double> MilligramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromMilligramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction MilligramsPerKilogram<T>(this T value) =>
-            MassFraction.FromMilligramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromMilligramsPerKilogram(T)" />
+        public static MassFraction<double> MilligramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromMilligramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(UnitsNet.QuantityValue)" />
-        public static MassFraction NanogramsPerGram<T>(this T value) =>
-            MassFraction.FromNanogramsPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromNanogramsPerGram(T)" />
+        public static MassFraction<double> NanogramsPerGram<T>(this T value) =>
+            MassFraction<double>.FromNanogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(UnitsNet.QuantityValue)" />
-        public static MassFraction NanogramsPerKilogram<T>(this T value) =>
-            MassFraction.FromNanogramsPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromNanogramsPerKilogram(T)" />
+        public static MassFraction<double> NanogramsPerKilogram<T>(this T value) =>
+            MassFraction<double>.FromNanogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerBillion(UnitsNet.QuantityValue)" />
-        public static MassFraction PartsPerBillion<T>(this T value) =>
-            MassFraction.FromPartsPerBillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromPartsPerBillion(T)" />
+        public static MassFraction<double> PartsPerBillion<T>(this T value) =>
+            MassFraction<double>.FromPartsPerBillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerMillion(UnitsNet.QuantityValue)" />
-        public static MassFraction PartsPerMillion<T>(this T value) =>
-            MassFraction.FromPartsPerMillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromPartsPerMillion(T)" />
+        public static MassFraction<double> PartsPerMillion<T>(this T value) =>
+            MassFraction<double>.FromPartsPerMillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerThousand(UnitsNet.QuantityValue)" />
-        public static MassFraction PartsPerThousand<T>(this T value) =>
-            MassFraction.FromPartsPerThousand(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromPartsPerThousand(T)" />
+        public static MassFraction<double> PartsPerThousand<T>(this T value) =>
+            MassFraction<double>.FromPartsPerThousand(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
-        public static MassFraction PartsPerTrillion<T>(this T value) =>
-            MassFraction.FromPartsPerTrillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromPartsPerTrillion(T)" />
+        public static MassFraction<double> PartsPerTrillion<T>(this T value) =>
+            MassFraction<double>.FromPartsPerTrillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPercent(UnitsNet.QuantityValue)" />
-        public static MassFraction Percent<T>(this T value) =>
-            MassFraction.FromPercent(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassFraction{T}.FromPercent(T)" />
+        public static MassFraction<double> Percent<T>(this T value) =>
+            MassFraction<double>.FromPercent(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
index c66173ceb9..cf1df3d336 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
@@ -28,117 +28,117 @@ namespace UnitsNet.NumberExtensions.NumberToMassMomentOfInertia
     /// </summary>
     public static class NumberToMassMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia GramSquareCentimeters<T>(this T value) =>
-            MassMomentOfInertia.FromGramSquareCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromGramSquareCentimeters(T)" />
+        public static MassMomentOfInertia<double> GramSquareCentimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromGramSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia GramSquareDecimeters<T>(this T value) =>
-            MassMomentOfInertia.FromGramSquareDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromGramSquareDecimeters(T)" />
+        public static MassMomentOfInertia<double> GramSquareDecimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromGramSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia GramSquareMeters<T>(this T value) =>
-            MassMomentOfInertia.FromGramSquareMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromGramSquareMeters(T)" />
+        public static MassMomentOfInertia<double> GramSquareMeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromGramSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia GramSquareMillimeters<T>(this T value) =>
-            MassMomentOfInertia.FromGramSquareMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromGramSquareMillimeters(T)" />
+        public static MassMomentOfInertia<double> GramSquareMillimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromGramSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilogramSquareCentimeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilogramSquareCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilogramSquareCentimeters(T)" />
+        public static MassMomentOfInertia<double> KilogramSquareCentimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilogramSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilogramSquareDecimeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilogramSquareDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilogramSquareDecimeters(T)" />
+        public static MassMomentOfInertia<double> KilogramSquareDecimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilogramSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilogramSquareMeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilogramSquareMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilogramSquareMeters(T)" />
+        public static MassMomentOfInertia<double> KilogramSquareMeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilogramSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilogramSquareMillimeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilogramSquareMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilogramSquareMillimeters(T)" />
+        public static MassMomentOfInertia<double> KilogramSquareMillimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilogramSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilotonneSquareCentimeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilotonneSquareCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilotonneSquareCentimeters(T)" />
+        public static MassMomentOfInertia<double> KilotonneSquareCentimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilotonneSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilotonneSquareDecimeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilotonneSquareDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilotonneSquareDecimeters(T)" />
+        public static MassMomentOfInertia<double> KilotonneSquareDecimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilotonneSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilotonneSquareMeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilotonneSquareMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilotonneSquareMeters(T)" />
+        public static MassMomentOfInertia<double> KilotonneSquareMeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilotonneSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMilimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia KilotonneSquareMilimeters<T>(this T value) =>
-            MassMomentOfInertia.FromKilotonneSquareMilimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromKilotonneSquareMilimeters(T)" />
+        public static MassMomentOfInertia<double> KilotonneSquareMilimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromKilotonneSquareMilimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MegatonneSquareCentimeters<T>(this T value) =>
-            MassMomentOfInertia.FromMegatonneSquareCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMegatonneSquareCentimeters(T)" />
+        public static MassMomentOfInertia<double> MegatonneSquareCentimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMegatonneSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MegatonneSquareDecimeters<T>(this T value) =>
-            MassMomentOfInertia.FromMegatonneSquareDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMegatonneSquareDecimeters(T)" />
+        public static MassMomentOfInertia<double> MegatonneSquareDecimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMegatonneSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MegatonneSquareMeters<T>(this T value) =>
-            MassMomentOfInertia.FromMegatonneSquareMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMegatonneSquareMeters(T)" />
+        public static MassMomentOfInertia<double> MegatonneSquareMeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMegatonneSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMilimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MegatonneSquareMilimeters<T>(this T value) =>
-            MassMomentOfInertia.FromMegatonneSquareMilimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMegatonneSquareMilimeters(T)" />
+        public static MassMomentOfInertia<double> MegatonneSquareMilimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMegatonneSquareMilimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MilligramSquareCentimeters<T>(this T value) =>
-            MassMomentOfInertia.FromMilligramSquareCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMilligramSquareCentimeters(T)" />
+        public static MassMomentOfInertia<double> MilligramSquareCentimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMilligramSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MilligramSquareDecimeters<T>(this T value) =>
-            MassMomentOfInertia.FromMilligramSquareDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMilligramSquareDecimeters(T)" />
+        public static MassMomentOfInertia<double> MilligramSquareDecimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMilligramSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MilligramSquareMeters<T>(this T value) =>
-            MassMomentOfInertia.FromMilligramSquareMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMilligramSquareMeters(T)" />
+        public static MassMomentOfInertia<double> MilligramSquareMeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMilligramSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia MilligramSquareMillimeters<T>(this T value) =>
-            MassMomentOfInertia.FromMilligramSquareMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromMilligramSquareMillimeters(T)" />
+        public static MassMomentOfInertia<double> MilligramSquareMillimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromMilligramSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia PoundSquareFeet<T>(this T value) =>
-            MassMomentOfInertia.FromPoundSquareFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromPoundSquareFeet(T)" />
+        public static MassMomentOfInertia<double> PoundSquareFeet<T>(this T value) =>
+            MassMomentOfInertia<double>.FromPoundSquareFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia PoundSquareInches<T>(this T value) =>
-            MassMomentOfInertia.FromPoundSquareInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromPoundSquareInches(T)" />
+        public static MassMomentOfInertia<double> PoundSquareInches<T>(this T value) =>
+            MassMomentOfInertia<double>.FromPoundSquareInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia SlugSquareFeet<T>(this T value) =>
-            MassMomentOfInertia.FromSlugSquareFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromSlugSquareFeet(T)" />
+        public static MassMomentOfInertia<double> SlugSquareFeet<T>(this T value) =>
+            MassMomentOfInertia<double>.FromSlugSquareFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia SlugSquareInches<T>(this T value) =>
-            MassMomentOfInertia.FromSlugSquareInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromSlugSquareInches(T)" />
+        public static MassMomentOfInertia<double> SlugSquareInches<T>(this T value) =>
+            MassMomentOfInertia<double>.FromSlugSquareInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia TonneSquareCentimeters<T>(this T value) =>
-            MassMomentOfInertia.FromTonneSquareCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromTonneSquareCentimeters(T)" />
+        public static MassMomentOfInertia<double> TonneSquareCentimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromTonneSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia TonneSquareDecimeters<T>(this T value) =>
-            MassMomentOfInertia.FromTonneSquareDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromTonneSquareDecimeters(T)" />
+        public static MassMomentOfInertia<double> TonneSquareDecimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromTonneSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia TonneSquareMeters<T>(this T value) =>
-            MassMomentOfInertia.FromTonneSquareMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromTonneSquareMeters(T)" />
+        public static MassMomentOfInertia<double> TonneSquareMeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromTonneSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMilimeters(UnitsNet.QuantityValue)" />
-        public static MassMomentOfInertia TonneSquareMilimeters<T>(this T value) =>
-            MassMomentOfInertia.FromTonneSquareMilimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="MassMomentOfInertia{T}.FromTonneSquareMilimeters(T)" />
+        public static MassMomentOfInertia<double> TonneSquareMilimeters<T>(this T value) =>
+            MassMomentOfInertia<double>.FromTonneSquareMilimeters(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
index c3d9f40848..769bcdbcf5 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToMolarEnergy
     /// </summary>
     public static class NumberToMolarEnergyExtensions
     {
-        /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(UnitsNet.QuantityValue)" />
-        public static MolarEnergy JoulesPerMole<T>(this T value) =>
-            MolarEnergy.FromJoulesPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarEnergy{T}.FromJoulesPerMole(T)" />
+        public static MolarEnergy<double> JoulesPerMole<T>(this T value) =>
+            MolarEnergy<double>.FromJoulesPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(UnitsNet.QuantityValue)" />
-        public static MolarEnergy KilojoulesPerMole<T>(this T value) =>
-            MolarEnergy.FromKilojoulesPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarEnergy{T}.FromKilojoulesPerMole(T)" />
+        public static MolarEnergy<double> KilojoulesPerMole<T>(this T value) =>
+            MolarEnergy<double>.FromKilojoulesPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(UnitsNet.QuantityValue)" />
-        public static MolarEnergy MegajoulesPerMole<T>(this T value) =>
-            MolarEnergy.FromMegajoulesPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarEnergy{T}.FromMegajoulesPerMole(T)" />
+        public static MolarEnergy<double> MegajoulesPerMole<T>(this T value) =>
+            MolarEnergy<double>.FromMegajoulesPerMole(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
index bdf9b9f62a..f5b372268a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToMolarEntropy
     /// </summary>
     public static class NumberToMolarEntropyExtensions
     {
-        /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
-        public static MolarEntropy JoulesPerMoleKelvin<T>(this T value) =>
-            MolarEntropy.FromJoulesPerMoleKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarEntropy{T}.FromJoulesPerMoleKelvin(T)" />
+        public static MolarEntropy<double> JoulesPerMoleKelvin<T>(this T value) =>
+            MolarEntropy<double>.FromJoulesPerMoleKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
-        public static MolarEntropy KilojoulesPerMoleKelvin<T>(this T value) =>
-            MolarEntropy.FromKilojoulesPerMoleKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarEntropy{T}.FromKilojoulesPerMoleKelvin(T)" />
+        public static MolarEntropy<double> KilojoulesPerMoleKelvin<T>(this T value) =>
+            MolarEntropy<double>.FromKilojoulesPerMoleKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
-        public static MolarEntropy MegajoulesPerMoleKelvin<T>(this T value) =>
-            MolarEntropy.FromMegajoulesPerMoleKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarEntropy{T}.FromMegajoulesPerMoleKelvin(T)" />
+        public static MolarEntropy<double> MegajoulesPerMoleKelvin<T>(this T value) =>
+            MolarEntropy<double>.FromMegajoulesPerMoleKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
index 0770fe5a8f..b7242bfd16 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
@@ -28,53 +28,53 @@ namespace UnitsNet.NumberExtensions.NumberToMolarMass
     /// </summary>
     public static class NumberToMolarMassExtensions
     {
-        /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass CentigramsPerMole<T>(this T value) =>
-            MolarMass.FromCentigramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromCentigramsPerMole(T)" />
+        public static MolarMass<double> CentigramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromCentigramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass DecagramsPerMole<T>(this T value) =>
-            MolarMass.FromDecagramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromDecagramsPerMole(T)" />
+        public static MolarMass<double> DecagramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromDecagramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass DecigramsPerMole<T>(this T value) =>
-            MolarMass.FromDecigramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromDecigramsPerMole(T)" />
+        public static MolarMass<double> DecigramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromDecigramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromGramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass GramsPerMole<T>(this T value) =>
-            MolarMass.FromGramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromGramsPerMole(T)" />
+        public static MolarMass<double> GramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromGramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass HectogramsPerMole<T>(this T value) =>
-            MolarMass.FromHectogramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromHectogramsPerMole(T)" />
+        public static MolarMass<double> HectogramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromHectogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass KilogramsPerMole<T>(this T value) =>
-            MolarMass.FromKilogramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromKilogramsPerMole(T)" />
+        public static MolarMass<double> KilogramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromKilogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass KilopoundsPerMole<T>(this T value) =>
-            MolarMass.FromKilopoundsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromKilopoundsPerMole(T)" />
+        public static MolarMass<double> KilopoundsPerMole<T>(this T value) =>
+            MolarMass<double>.FromKilopoundsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass MegapoundsPerMole<T>(this T value) =>
-            MolarMass.FromMegapoundsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromMegapoundsPerMole(T)" />
+        public static MolarMass<double> MegapoundsPerMole<T>(this T value) =>
+            MolarMass<double>.FromMegapoundsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass MicrogramsPerMole<T>(this T value) =>
-            MolarMass.FromMicrogramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromMicrogramsPerMole(T)" />
+        public static MolarMass<double> MicrogramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromMicrogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass MilligramsPerMole<T>(this T value) =>
-            MolarMass.FromMilligramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromMilligramsPerMole(T)" />
+        public static MolarMass<double> MilligramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromMilligramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass NanogramsPerMole<T>(this T value) =>
-            MolarMass.FromNanogramsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromNanogramsPerMole(T)" />
+        public static MolarMass<double> NanogramsPerMole<T>(this T value) =>
+            MolarMass<double>.FromNanogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromPoundsPerMole(UnitsNet.QuantityValue)" />
-        public static MolarMass PoundsPerMole<T>(this T value) =>
-            MolarMass.FromPoundsPerMole(Convert.ToDouble(value));
+        /// <inheritdoc cref="MolarMass{T}.FromPoundsPerMole(T)" />
+        public static MolarMass<double> PoundsPerMole<T>(this T value) =>
+            MolarMass<double>.FromPoundsPerMole(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
index 1a950102be..7ef886a20e 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
@@ -28,37 +28,37 @@ namespace UnitsNet.NumberExtensions.NumberToMolarity
     /// </summary>
     public static class NumberToMolarityExtensions
     {
-        /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(UnitsNet.QuantityValue)" />
-        public static Molarity CentimolesPerLiter<T>(this T value) =>
-            Molarity.FromCentimolesPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromCentimolesPerLiter(T)" />
+        public static Molarity<double> CentimolesPerLiter<T>(this T value) =>
+            Molarity<double>.FromCentimolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(UnitsNet.QuantityValue)" />
-        public static Molarity DecimolesPerLiter<T>(this T value) =>
-            Molarity.FromDecimolesPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromDecimolesPerLiter(T)" />
+        public static Molarity<double> DecimolesPerLiter<T>(this T value) =>
+            Molarity<double>.FromDecimolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(UnitsNet.QuantityValue)" />
-        public static Molarity MicromolesPerLiter<T>(this T value) =>
-            Molarity.FromMicromolesPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromMicromolesPerLiter(T)" />
+        public static Molarity<double> MicromolesPerLiter<T>(this T value) =>
+            Molarity<double>.FromMicromolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(UnitsNet.QuantityValue)" />
-        public static Molarity MillimolesPerLiter<T>(this T value) =>
-            Molarity.FromMillimolesPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromMillimolesPerLiter(T)" />
+        public static Molarity<double> MillimolesPerLiter<T>(this T value) =>
+            Molarity<double>.FromMillimolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static Molarity MolesPerCubicMeter<T>(this T value) =>
-            Molarity.FromMolesPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromMolesPerCubicMeter(T)" />
+        public static Molarity<double> MolesPerCubicMeter<T>(this T value) =>
+            Molarity<double>.FromMolesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMolesPerLiter(UnitsNet.QuantityValue)" />
-        public static Molarity MolesPerLiter<T>(this T value) =>
-            Molarity.FromMolesPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromMolesPerLiter(T)" />
+        public static Molarity<double> MolesPerLiter<T>(this T value) =>
+            Molarity<double>.FromMolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(UnitsNet.QuantityValue)" />
-        public static Molarity NanomolesPerLiter<T>(this T value) =>
-            Molarity.FromNanomolesPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromNanomolesPerLiter(T)" />
+        public static Molarity<double> NanomolesPerLiter<T>(this T value) =>
+            Molarity<double>.FromNanomolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(UnitsNet.QuantityValue)" />
-        public static Molarity PicomolesPerLiter<T>(this T value) =>
-            Molarity.FromPicomolesPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Molarity{T}.FromPicomolesPerLiter(T)" />
+        public static Molarity<double> PicomolesPerLiter<T>(this T value) =>
+            Molarity<double>.FromPicomolesPerLiter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
index 799e265fa9..d4463b218c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToPermeability
     /// </summary>
     public static class NumberToPermeabilityExtensions
     {
-        /// <inheritdoc cref="Permeability.FromHenriesPerMeter(UnitsNet.QuantityValue)" />
-        public static Permeability HenriesPerMeter<T>(this T value) =>
-            Permeability.FromHenriesPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Permeability{T}.FromHenriesPerMeter(T)" />
+        public static Permeability<double> HenriesPerMeter<T>(this T value) =>
+            Permeability<double>.FromHenriesPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
index d663acc786..263b5d35b7 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToPermittivity
     /// </summary>
     public static class NumberToPermittivityExtensions
     {
-        /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(UnitsNet.QuantityValue)" />
-        public static Permittivity FaradsPerMeter<T>(this T value) =>
-            Permittivity.FromFaradsPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Permittivity{T}.FromFaradsPerMeter(T)" />
+        public static Permittivity<double> FaradsPerMeter<T>(this T value) =>
+            Permittivity<double>.FromFaradsPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
index db29982fa6..27d592580c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
@@ -28,181 +28,181 @@ namespace UnitsNet.NumberExtensions.NumberToPowerDensity
     /// </summary>
     public static class NumberToPowerDensityExtensions
     {
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity DecawattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromDecawattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDecawattsPerCubicFoot(T)" />
+        public static PowerDensity<double> DecawattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromDecawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity DecawattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromDecawattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDecawattsPerCubicInch(T)" />
+        public static PowerDensity<double> DecawattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromDecawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity DecawattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromDecawattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDecawattsPerCubicMeter(T)" />
+        public static PowerDensity<double> DecawattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromDecawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity DecawattsPerLiter<T>(this T value) =>
-            PowerDensity.FromDecawattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDecawattsPerLiter(T)" />
+        public static PowerDensity<double> DecawattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromDecawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity DeciwattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromDeciwattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDeciwattsPerCubicFoot(T)" />
+        public static PowerDensity<double> DeciwattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromDeciwattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity DeciwattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromDeciwattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDeciwattsPerCubicInch(T)" />
+        public static PowerDensity<double> DeciwattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromDeciwattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity DeciwattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromDeciwattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDeciwattsPerCubicMeter(T)" />
+        public static PowerDensity<double> DeciwattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromDeciwattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity DeciwattsPerLiter<T>(this T value) =>
-            PowerDensity.FromDeciwattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromDeciwattsPerLiter(T)" />
+        public static PowerDensity<double> DeciwattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromDeciwattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity GigawattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromGigawattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromGigawattsPerCubicFoot(T)" />
+        public static PowerDensity<double> GigawattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromGigawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity GigawattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromGigawattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromGigawattsPerCubicInch(T)" />
+        public static PowerDensity<double> GigawattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromGigawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity GigawattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromGigawattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromGigawattsPerCubicMeter(T)" />
+        public static PowerDensity<double> GigawattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromGigawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity GigawattsPerLiter<T>(this T value) =>
-            PowerDensity.FromGigawattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromGigawattsPerLiter(T)" />
+        public static PowerDensity<double> GigawattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromGigawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity KilowattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromKilowattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromKilowattsPerCubicFoot(T)" />
+        public static PowerDensity<double> KilowattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromKilowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity KilowattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromKilowattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromKilowattsPerCubicInch(T)" />
+        public static PowerDensity<double> KilowattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromKilowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity KilowattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromKilowattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromKilowattsPerCubicMeter(T)" />
+        public static PowerDensity<double> KilowattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromKilowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity KilowattsPerLiter<T>(this T value) =>
-            PowerDensity.FromKilowattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromKilowattsPerLiter(T)" />
+        public static PowerDensity<double> KilowattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromKilowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity MegawattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromMegawattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMegawattsPerCubicFoot(T)" />
+        public static PowerDensity<double> MegawattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromMegawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity MegawattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromMegawattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMegawattsPerCubicInch(T)" />
+        public static PowerDensity<double> MegawattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromMegawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity MegawattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromMegawattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMegawattsPerCubicMeter(T)" />
+        public static PowerDensity<double> MegawattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromMegawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity MegawattsPerLiter<T>(this T value) =>
-            PowerDensity.FromMegawattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMegawattsPerLiter(T)" />
+        public static PowerDensity<double> MegawattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromMegawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity MicrowattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromMicrowattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMicrowattsPerCubicFoot(T)" />
+        public static PowerDensity<double> MicrowattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromMicrowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity MicrowattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromMicrowattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMicrowattsPerCubicInch(T)" />
+        public static PowerDensity<double> MicrowattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromMicrowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity MicrowattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromMicrowattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMicrowattsPerCubicMeter(T)" />
+        public static PowerDensity<double> MicrowattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromMicrowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity MicrowattsPerLiter<T>(this T value) =>
-            PowerDensity.FromMicrowattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMicrowattsPerLiter(T)" />
+        public static PowerDensity<double> MicrowattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromMicrowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity MilliwattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromMilliwattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMilliwattsPerCubicFoot(T)" />
+        public static PowerDensity<double> MilliwattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromMilliwattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity MilliwattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromMilliwattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMilliwattsPerCubicInch(T)" />
+        public static PowerDensity<double> MilliwattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromMilliwattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity MilliwattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromMilliwattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMilliwattsPerCubicMeter(T)" />
+        public static PowerDensity<double> MilliwattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromMilliwattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity MilliwattsPerLiter<T>(this T value) =>
-            PowerDensity.FromMilliwattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromMilliwattsPerLiter(T)" />
+        public static PowerDensity<double> MilliwattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromMilliwattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity NanowattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromNanowattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromNanowattsPerCubicFoot(T)" />
+        public static PowerDensity<double> NanowattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromNanowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity NanowattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromNanowattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromNanowattsPerCubicInch(T)" />
+        public static PowerDensity<double> NanowattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromNanowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity NanowattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromNanowattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromNanowattsPerCubicMeter(T)" />
+        public static PowerDensity<double> NanowattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromNanowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity NanowattsPerLiter<T>(this T value) =>
-            PowerDensity.FromNanowattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromNanowattsPerLiter(T)" />
+        public static PowerDensity<double> NanowattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromNanowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity PicowattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromPicowattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromPicowattsPerCubicFoot(T)" />
+        public static PowerDensity<double> PicowattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromPicowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity PicowattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromPicowattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromPicowattsPerCubicInch(T)" />
+        public static PowerDensity<double> PicowattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromPicowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity PicowattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromPicowattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromPicowattsPerCubicMeter(T)" />
+        public static PowerDensity<double> PicowattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromPicowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity PicowattsPerLiter<T>(this T value) =>
-            PowerDensity.FromPicowattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromPicowattsPerLiter(T)" />
+        public static PowerDensity<double> PicowattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromPicowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity TerawattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromTerawattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromTerawattsPerCubicFoot(T)" />
+        public static PowerDensity<double> TerawattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromTerawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity TerawattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromTerawattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromTerawattsPerCubicInch(T)" />
+        public static PowerDensity<double> TerawattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromTerawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity TerawattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromTerawattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromTerawattsPerCubicMeter(T)" />
+        public static PowerDensity<double> TerawattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromTerawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity TerawattsPerLiter<T>(this T value) =>
-            PowerDensity.FromTerawattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromTerawattsPerLiter(T)" />
+        public static PowerDensity<double> TerawattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromTerawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(UnitsNet.QuantityValue)" />
-        public static PowerDensity WattsPerCubicFoot<T>(this T value) =>
-            PowerDensity.FromWattsPerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromWattsPerCubicFoot(T)" />
+        public static PowerDensity<double> WattsPerCubicFoot<T>(this T value) =>
+            PowerDensity<double>.FromWattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(UnitsNet.QuantityValue)" />
-        public static PowerDensity WattsPerCubicInch<T>(this T value) =>
-            PowerDensity.FromWattsPerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromWattsPerCubicInch(T)" />
+        public static PowerDensity<double> WattsPerCubicInch<T>(this T value) =>
+            PowerDensity<double>.FromWattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static PowerDensity WattsPerCubicMeter<T>(this T value) =>
-            PowerDensity.FromWattsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromWattsPerCubicMeter(T)" />
+        public static PowerDensity<double> WattsPerCubicMeter<T>(this T value) =>
+            PowerDensity<double>.FromWattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(UnitsNet.QuantityValue)" />
-        public static PowerDensity WattsPerLiter<T>(this T value) =>
-            PowerDensity.FromWattsPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerDensity{T}.FromWattsPerLiter(T)" />
+        public static PowerDensity<double> WattsPerLiter<T>(this T value) =>
+            PowerDensity<double>.FromWattsPerLiter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
index 1ec415d506..db3ac700ae 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
@@ -28,105 +28,105 @@ namespace UnitsNet.NumberExtensions.NumberToPower
     /// </summary>
     public static class NumberToPowerExtensions
     {
-        /// <inheritdoc cref="Power.FromBoilerHorsepower(UnitsNet.QuantityValue)" />
-        public static Power BoilerHorsepower<T>(this T value) =>
-            Power.FromBoilerHorsepower(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromBoilerHorsepower(T)" />
+        public static Power<double> BoilerHorsepower<T>(this T value) =>
+            Power<double>.FromBoilerHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
-        public static Power BritishThermalUnitsPerHour<T>(this T value) =>
-            Power.FromBritishThermalUnitsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromBritishThermalUnitsPerHour(T)" />
+        public static Power<double> BritishThermalUnitsPerHour<T>(this T value) =>
+            Power<double>.FromBritishThermalUnitsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromDecawatts(UnitsNet.QuantityValue)" />
-        public static Power Decawatts<T>(this T value) =>
-            Power.FromDecawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromDecawatts(T)" />
+        public static Power<double> Decawatts<T>(this T value) =>
+            Power<double>.FromDecawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromDeciwatts(UnitsNet.QuantityValue)" />
-        public static Power Deciwatts<T>(this T value) =>
-            Power.FromDeciwatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromDeciwatts(T)" />
+        public static Power<double> Deciwatts<T>(this T value) =>
+            Power<double>.FromDeciwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromElectricalHorsepower(UnitsNet.QuantityValue)" />
-        public static Power ElectricalHorsepower<T>(this T value) =>
-            Power.FromElectricalHorsepower(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromElectricalHorsepower(T)" />
+        public static Power<double> ElectricalHorsepower<T>(this T value) =>
+            Power<double>.FromElectricalHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromFemtowatts(UnitsNet.QuantityValue)" />
-        public static Power Femtowatts<T>(this T value) =>
-            Power.FromFemtowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromFemtowatts(T)" />
+        public static Power<double> Femtowatts<T>(this T value) =>
+            Power<double>.FromFemtowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromGigajoulesPerHour(UnitsNet.QuantityValue)" />
-        public static Power GigajoulesPerHour<T>(this T value) =>
-            Power.FromGigajoulesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromGigajoulesPerHour(T)" />
+        public static Power<double> GigajoulesPerHour<T>(this T value) =>
+            Power<double>.FromGigajoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromGigawatts(UnitsNet.QuantityValue)" />
-        public static Power Gigawatts<T>(this T value) =>
-            Power.FromGigawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromGigawatts(T)" />
+        public static Power<double> Gigawatts<T>(this T value) =>
+            Power<double>.FromGigawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromHydraulicHorsepower(UnitsNet.QuantityValue)" />
-        public static Power HydraulicHorsepower<T>(this T value) =>
-            Power.FromHydraulicHorsepower(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromHydraulicHorsepower(T)" />
+        public static Power<double> HydraulicHorsepower<T>(this T value) =>
+            Power<double>.FromHydraulicHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromJoulesPerHour(UnitsNet.QuantityValue)" />
-        public static Power JoulesPerHour<T>(this T value) =>
-            Power.FromJoulesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromJoulesPerHour(T)" />
+        public static Power<double> JoulesPerHour<T>(this T value) =>
+            Power<double>.FromJoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
-        public static Power KilobritishThermalUnitsPerHour<T>(this T value) =>
-            Power.FromKilobritishThermalUnitsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromKilobritishThermalUnitsPerHour(T)" />
+        public static Power<double> KilobritishThermalUnitsPerHour<T>(this T value) =>
+            Power<double>.FromKilobritishThermalUnitsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromKilojoulesPerHour(UnitsNet.QuantityValue)" />
-        public static Power KilojoulesPerHour<T>(this T value) =>
-            Power.FromKilojoulesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromKilojoulesPerHour(T)" />
+        public static Power<double> KilojoulesPerHour<T>(this T value) =>
+            Power<double>.FromKilojoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromKilowatts(UnitsNet.QuantityValue)" />
-        public static Power Kilowatts<T>(this T value) =>
-            Power.FromKilowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromKilowatts(T)" />
+        public static Power<double> Kilowatts<T>(this T value) =>
+            Power<double>.FromKilowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMechanicalHorsepower(UnitsNet.QuantityValue)" />
-        public static Power MechanicalHorsepower<T>(this T value) =>
-            Power.FromMechanicalHorsepower(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromMechanicalHorsepower(T)" />
+        public static Power<double> MechanicalHorsepower<T>(this T value) =>
+            Power<double>.FromMechanicalHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMegajoulesPerHour(UnitsNet.QuantityValue)" />
-        public static Power MegajoulesPerHour<T>(this T value) =>
-            Power.FromMegajoulesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromMegajoulesPerHour(T)" />
+        public static Power<double> MegajoulesPerHour<T>(this T value) =>
+            Power<double>.FromMegajoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMegawatts(UnitsNet.QuantityValue)" />
-        public static Power Megawatts<T>(this T value) =>
-            Power.FromMegawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromMegawatts(T)" />
+        public static Power<double> Megawatts<T>(this T value) =>
+            Power<double>.FromMegawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMetricHorsepower(UnitsNet.QuantityValue)" />
-        public static Power MetricHorsepower<T>(this T value) =>
-            Power.FromMetricHorsepower(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromMetricHorsepower(T)" />
+        public static Power<double> MetricHorsepower<T>(this T value) =>
+            Power<double>.FromMetricHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMicrowatts(UnitsNet.QuantityValue)" />
-        public static Power Microwatts<T>(this T value) =>
-            Power.FromMicrowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromMicrowatts(T)" />
+        public static Power<double> Microwatts<T>(this T value) =>
+            Power<double>.FromMicrowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMillijoulesPerHour(UnitsNet.QuantityValue)" />
-        public static Power MillijoulesPerHour<T>(this T value) =>
-            Power.FromMillijoulesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromMillijoulesPerHour(T)" />
+        public static Power<double> MillijoulesPerHour<T>(this T value) =>
+            Power<double>.FromMillijoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMilliwatts(UnitsNet.QuantityValue)" />
-        public static Power Milliwatts<T>(this T value) =>
-            Power.FromMilliwatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromMilliwatts(T)" />
+        public static Power<double> Milliwatts<T>(this T value) =>
+            Power<double>.FromMilliwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromNanowatts(UnitsNet.QuantityValue)" />
-        public static Power Nanowatts<T>(this T value) =>
-            Power.FromNanowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromNanowatts(T)" />
+        public static Power<double> Nanowatts<T>(this T value) =>
+            Power<double>.FromNanowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromPetawatts(UnitsNet.QuantityValue)" />
-        public static Power Petawatts<T>(this T value) =>
-            Power.FromPetawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromPetawatts(T)" />
+        public static Power<double> Petawatts<T>(this T value) =>
+            Power<double>.FromPetawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromPicowatts(UnitsNet.QuantityValue)" />
-        public static Power Picowatts<T>(this T value) =>
-            Power.FromPicowatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromPicowatts(T)" />
+        public static Power<double> Picowatts<T>(this T value) =>
+            Power<double>.FromPicowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromTerawatts(UnitsNet.QuantityValue)" />
-        public static Power Terawatts<T>(this T value) =>
-            Power.FromTerawatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromTerawatts(T)" />
+        public static Power<double> Terawatts<T>(this T value) =>
+            Power<double>.FromTerawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromWatts(UnitsNet.QuantityValue)" />
-        public static Power Watts<T>(this T value) =>
-            Power.FromWatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Power{T}.FromWatts(T)" />
+        public static Power<double> Watts<T>(this T value) =>
+            Power<double>.FromWatts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
index 8f39d1efc9..8fc77a94e2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
@@ -28,13 +28,13 @@ namespace UnitsNet.NumberExtensions.NumberToPowerRatio
     /// </summary>
     public static class NumberToPowerRatioExtensions
     {
-        /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(UnitsNet.QuantityValue)" />
-        public static PowerRatio DecibelMilliwatts<T>(this T value) =>
-            PowerRatio.FromDecibelMilliwatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerRatio{T}.FromDecibelMilliwatts(T)" />
+        public static PowerRatio<double> DecibelMilliwatts<T>(this T value) =>
+            PowerRatio<double>.FromDecibelMilliwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerRatio.FromDecibelWatts(UnitsNet.QuantityValue)" />
-        public static PowerRatio DecibelWatts<T>(this T value) =>
-            PowerRatio.FromDecibelWatts(Convert.ToDouble(value));
+        /// <inheritdoc cref="PowerRatio{T}.FromDecibelWatts(T)" />
+        public static PowerRatio<double> DecibelWatts<T>(this T value) =>
+            PowerRatio<double>.FromDecibelWatts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
index f503510093..e98a4a3a58 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
@@ -28,33 +28,33 @@ namespace UnitsNet.NumberExtensions.NumberToPressureChangeRate
     /// </summary>
     public static class NumberToPressureChangeRateExtensions
     {
-        /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(UnitsNet.QuantityValue)" />
-        public static PressureChangeRate AtmospheresPerSecond<T>(this T value) =>
-            PressureChangeRate.FromAtmospheresPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="PressureChangeRate{T}.FromAtmospheresPerSecond(T)" />
+        public static PressureChangeRate<double> AtmospheresPerSecond<T>(this T value) =>
+            PressureChangeRate<double>.FromAtmospheresPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(UnitsNet.QuantityValue)" />
-        public static PressureChangeRate KilopascalsPerMinute<T>(this T value) =>
-            PressureChangeRate.FromKilopascalsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="PressureChangeRate{T}.FromKilopascalsPerMinute(T)" />
+        public static PressureChangeRate<double> KilopascalsPerMinute<T>(this T value) =>
+            PressureChangeRate<double>.FromKilopascalsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(UnitsNet.QuantityValue)" />
-        public static PressureChangeRate KilopascalsPerSecond<T>(this T value) =>
-            PressureChangeRate.FromKilopascalsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="PressureChangeRate{T}.FromKilopascalsPerSecond(T)" />
+        public static PressureChangeRate<double> KilopascalsPerSecond<T>(this T value) =>
+            PressureChangeRate<double>.FromKilopascalsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(UnitsNet.QuantityValue)" />
-        public static PressureChangeRate MegapascalsPerMinute<T>(this T value) =>
-            PressureChangeRate.FromMegapascalsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="PressureChangeRate{T}.FromMegapascalsPerMinute(T)" />
+        public static PressureChangeRate<double> MegapascalsPerMinute<T>(this T value) =>
+            PressureChangeRate<double>.FromMegapascalsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(UnitsNet.QuantityValue)" />
-        public static PressureChangeRate MegapascalsPerSecond<T>(this T value) =>
-            PressureChangeRate.FromMegapascalsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="PressureChangeRate{T}.FromMegapascalsPerSecond(T)" />
+        public static PressureChangeRate<double> MegapascalsPerSecond<T>(this T value) =>
+            PressureChangeRate<double>.FromMegapascalsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(UnitsNet.QuantityValue)" />
-        public static PressureChangeRate PascalsPerMinute<T>(this T value) =>
-            PressureChangeRate.FromPascalsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="PressureChangeRate{T}.FromPascalsPerMinute(T)" />
+        public static PressureChangeRate<double> PascalsPerMinute<T>(this T value) =>
+            PressureChangeRate<double>.FromPascalsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(UnitsNet.QuantityValue)" />
-        public static PressureChangeRate PascalsPerSecond<T>(this T value) =>
-            PressureChangeRate.FromPascalsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="PressureChangeRate{T}.FromPascalsPerSecond(T)" />
+        public static PressureChangeRate<double> PascalsPerSecond<T>(this T value) =>
+            PressureChangeRate<double>.FromPascalsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
index 7d4ec48053..1a8e2339b2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
@@ -28,173 +28,173 @@ namespace UnitsNet.NumberExtensions.NumberToPressure
     /// </summary>
     public static class NumberToPressureExtensions
     {
-        /// <inheritdoc cref="Pressure.FromAtmospheres(UnitsNet.QuantityValue)" />
-        public static Pressure Atmospheres<T>(this T value) =>
-            Pressure.FromAtmospheres(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromAtmospheres(T)" />
+        public static Pressure<double> Atmospheres<T>(this T value) =>
+            Pressure<double>.FromAtmospheres(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromBars(UnitsNet.QuantityValue)" />
-        public static Pressure Bars<T>(this T value) =>
-            Pressure.FromBars(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromBars(T)" />
+        public static Pressure<double> Bars<T>(this T value) =>
+            Pressure<double>.FromBars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromCentibars(UnitsNet.QuantityValue)" />
-        public static Pressure Centibars<T>(this T value) =>
-            Pressure.FromCentibars(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromCentibars(T)" />
+        public static Pressure<double> Centibars<T>(this T value) =>
+            Pressure<double>.FromCentibars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromDecapascals(UnitsNet.QuantityValue)" />
-        public static Pressure Decapascals<T>(this T value) =>
-            Pressure.FromDecapascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromDecapascals(T)" />
+        public static Pressure<double> Decapascals<T>(this T value) =>
+            Pressure<double>.FromDecapascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromDecibars(UnitsNet.QuantityValue)" />
-        public static Pressure Decibars<T>(this T value) =>
-            Pressure.FromDecibars(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromDecibars(T)" />
+        public static Pressure<double> Decibars<T>(this T value) =>
+            Pressure<double>.FromDecibars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Pressure DynesPerSquareCentimeter<T>(this T value) =>
-            Pressure.FromDynesPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromDynesPerSquareCentimeter(T)" />
+        public static Pressure<double> DynesPerSquareCentimeter<T>(this T value) =>
+            Pressure<double>.FromDynesPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromFeetOfHead(UnitsNet.QuantityValue)" />
-        public static Pressure FeetOfHead<T>(this T value) =>
-            Pressure.FromFeetOfHead(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromFeetOfHead(T)" />
+        public static Pressure<double> FeetOfHead<T>(this T value) =>
+            Pressure<double>.FromFeetOfHead(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromGigapascals(UnitsNet.QuantityValue)" />
-        public static Pressure Gigapascals<T>(this T value) =>
-            Pressure.FromGigapascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromGigapascals(T)" />
+        public static Pressure<double> Gigapascals<T>(this T value) =>
+            Pressure<double>.FromGigapascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromHectopascals(UnitsNet.QuantityValue)" />
-        public static Pressure Hectopascals<T>(this T value) =>
-            Pressure.FromHectopascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromHectopascals(T)" />
+        public static Pressure<double> Hectopascals<T>(this T value) =>
+            Pressure<double>.FromHectopascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromInchesOfMercury(UnitsNet.QuantityValue)" />
-        public static Pressure InchesOfMercury<T>(this T value) =>
-            Pressure.FromInchesOfMercury(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromInchesOfMercury(T)" />
+        public static Pressure<double> InchesOfMercury<T>(this T value) =>
+            Pressure<double>.FromInchesOfMercury(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(UnitsNet.QuantityValue)" />
-        public static Pressure InchesOfWaterColumn<T>(this T value) =>
-            Pressure.FromInchesOfWaterColumn(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromInchesOfWaterColumn(T)" />
+        public static Pressure<double> InchesOfWaterColumn<T>(this T value) =>
+            Pressure<double>.FromInchesOfWaterColumn(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilobars(UnitsNet.QuantityValue)" />
-        public static Pressure Kilobars<T>(this T value) =>
-            Pressure.FromKilobars(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilobars(T)" />
+        public static Pressure<double> Kilobars<T>(this T value) =>
+            Pressure<double>.FromKilobars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Pressure KilogramsForcePerSquareCentimeter<T>(this T value) =>
-            Pressure.FromKilogramsForcePerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilogramsForcePerSquareCentimeter(T)" />
+        public static Pressure<double> KilogramsForcePerSquareCentimeter<T>(this T value) =>
+            Pressure<double>.FromKilogramsForcePerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Pressure KilogramsForcePerSquareMeter<T>(this T value) =>
-            Pressure.FromKilogramsForcePerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilogramsForcePerSquareMeter(T)" />
+        public static Pressure<double> KilogramsForcePerSquareMeter<T>(this T value) =>
+            Pressure<double>.FromKilogramsForcePerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static Pressure KilogramsForcePerSquareMillimeter<T>(this T value) =>
-            Pressure.FromKilogramsForcePerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilogramsForcePerSquareMillimeter(T)" />
+        public static Pressure<double> KilogramsForcePerSquareMillimeter<T>(this T value) =>
+            Pressure<double>.FromKilogramsForcePerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Pressure KilonewtonsPerSquareCentimeter<T>(this T value) =>
-            Pressure.FromKilonewtonsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilonewtonsPerSquareCentimeter(T)" />
+        public static Pressure<double> KilonewtonsPerSquareCentimeter<T>(this T value) =>
+            Pressure<double>.FromKilonewtonsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Pressure KilonewtonsPerSquareMeter<T>(this T value) =>
-            Pressure.FromKilonewtonsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilonewtonsPerSquareMeter(T)" />
+        public static Pressure<double> KilonewtonsPerSquareMeter<T>(this T value) =>
+            Pressure<double>.FromKilonewtonsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static Pressure KilonewtonsPerSquareMillimeter<T>(this T value) =>
-            Pressure.FromKilonewtonsPerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilonewtonsPerSquareMillimeter(T)" />
+        public static Pressure<double> KilonewtonsPerSquareMillimeter<T>(this T value) =>
+            Pressure<double>.FromKilonewtonsPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilopascals(UnitsNet.QuantityValue)" />
-        public static Pressure Kilopascals<T>(this T value) =>
-            Pressure.FromKilopascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilopascals(T)" />
+        public static Pressure<double> Kilopascals<T>(this T value) =>
+            Pressure<double>.FromKilopascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
-        public static Pressure KilopoundsForcePerSquareFoot<T>(this T value) =>
-            Pressure.FromKilopoundsForcePerSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilopoundsForcePerSquareFoot(T)" />
+        public static Pressure<double> KilopoundsForcePerSquareFoot<T>(this T value) =>
+            Pressure<double>.FromKilopoundsForcePerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
-        public static Pressure KilopoundsForcePerSquareInch<T>(this T value) =>
-            Pressure.FromKilopoundsForcePerSquareInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromKilopoundsForcePerSquareInch(T)" />
+        public static Pressure<double> KilopoundsForcePerSquareInch<T>(this T value) =>
+            Pressure<double>.FromKilopoundsForcePerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMegabars(UnitsNet.QuantityValue)" />
-        public static Pressure Megabars<T>(this T value) =>
-            Pressure.FromMegabars(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMegabars(T)" />
+        public static Pressure<double> Megabars<T>(this T value) =>
+            Pressure<double>.FromMegabars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Pressure MeganewtonsPerSquareMeter<T>(this T value) =>
-            Pressure.FromMeganewtonsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMeganewtonsPerSquareMeter(T)" />
+        public static Pressure<double> MeganewtonsPerSquareMeter<T>(this T value) =>
+            Pressure<double>.FromMeganewtonsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMegapascals(UnitsNet.QuantityValue)" />
-        public static Pressure Megapascals<T>(this T value) =>
-            Pressure.FromMegapascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMegapascals(T)" />
+        public static Pressure<double> Megapascals<T>(this T value) =>
+            Pressure<double>.FromMegapascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMetersOfHead(UnitsNet.QuantityValue)" />
-        public static Pressure MetersOfHead<T>(this T value) =>
-            Pressure.FromMetersOfHead(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMetersOfHead(T)" />
+        public static Pressure<double> MetersOfHead<T>(this T value) =>
+            Pressure<double>.FromMetersOfHead(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMicrobars(UnitsNet.QuantityValue)" />
-        public static Pressure Microbars<T>(this T value) =>
-            Pressure.FromMicrobars(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMicrobars(T)" />
+        public static Pressure<double> Microbars<T>(this T value) =>
+            Pressure<double>.FromMicrobars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMicropascals(UnitsNet.QuantityValue)" />
-        public static Pressure Micropascals<T>(this T value) =>
-            Pressure.FromMicropascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMicropascals(T)" />
+        public static Pressure<double> Micropascals<T>(this T value) =>
+            Pressure<double>.FromMicropascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMillibars(UnitsNet.QuantityValue)" />
-        public static Pressure Millibars<T>(this T value) =>
-            Pressure.FromMillibars(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMillibars(T)" />
+        public static Pressure<double> Millibars<T>(this T value) =>
+            Pressure<double>.FromMillibars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(UnitsNet.QuantityValue)" />
-        public static Pressure MillimetersOfMercury<T>(this T value) =>
-            Pressure.FromMillimetersOfMercury(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMillimetersOfMercury(T)" />
+        public static Pressure<double> MillimetersOfMercury<T>(this T value) =>
+            Pressure<double>.FromMillimetersOfMercury(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMillipascals(UnitsNet.QuantityValue)" />
-        public static Pressure Millipascals<T>(this T value) =>
-            Pressure.FromMillipascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromMillipascals(T)" />
+        public static Pressure<double> Millipascals<T>(this T value) =>
+            Pressure<double>.FromMillipascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Pressure NewtonsPerSquareCentimeter<T>(this T value) =>
-            Pressure.FromNewtonsPerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromNewtonsPerSquareCentimeter(T)" />
+        public static Pressure<double> NewtonsPerSquareCentimeter<T>(this T value) =>
+            Pressure<double>.FromNewtonsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Pressure NewtonsPerSquareMeter<T>(this T value) =>
-            Pressure.FromNewtonsPerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromNewtonsPerSquareMeter(T)" />
+        public static Pressure<double> NewtonsPerSquareMeter<T>(this T value) =>
+            Pressure<double>.FromNewtonsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static Pressure NewtonsPerSquareMillimeter<T>(this T value) =>
-            Pressure.FromNewtonsPerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromNewtonsPerSquareMillimeter(T)" />
+        public static Pressure<double> NewtonsPerSquareMillimeter<T>(this T value) =>
+            Pressure<double>.FromNewtonsPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPascals(UnitsNet.QuantityValue)" />
-        public static Pressure Pascals<T>(this T value) =>
-            Pressure.FromPascals(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromPascals(T)" />
+        public static Pressure<double> Pascals<T>(this T value) =>
+            Pressure<double>.FromPascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
-        public static Pressure PoundsForcePerSquareFoot<T>(this T value) =>
-            Pressure.FromPoundsForcePerSquareFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromPoundsForcePerSquareFoot(T)" />
+        public static Pressure<double> PoundsForcePerSquareFoot<T>(this T value) =>
+            Pressure<double>.FromPoundsForcePerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
-        public static Pressure PoundsForcePerSquareInch<T>(this T value) =>
-            Pressure.FromPoundsForcePerSquareInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromPoundsForcePerSquareInch(T)" />
+        public static Pressure<double> PoundsForcePerSquareInch<T>(this T value) =>
+            Pressure<double>.FromPoundsForcePerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(UnitsNet.QuantityValue)" />
-        public static Pressure PoundsPerInchSecondSquared<T>(this T value) =>
-            Pressure.FromPoundsPerInchSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromPoundsPerInchSecondSquared(T)" />
+        public static Pressure<double> PoundsPerInchSecondSquared<T>(this T value) =>
+            Pressure<double>.FromPoundsPerInchSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(UnitsNet.QuantityValue)" />
-        public static Pressure TechnicalAtmospheres<T>(this T value) =>
-            Pressure.FromTechnicalAtmospheres(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromTechnicalAtmospheres(T)" />
+        public static Pressure<double> TechnicalAtmospheres<T>(this T value) =>
+            Pressure<double>.FromTechnicalAtmospheres(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
-        public static Pressure TonnesForcePerSquareCentimeter<T>(this T value) =>
-            Pressure.FromTonnesForcePerSquareCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromTonnesForcePerSquareCentimeter(T)" />
+        public static Pressure<double> TonnesForcePerSquareCentimeter<T>(this T value) =>
+            Pressure<double>.FromTonnesForcePerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(UnitsNet.QuantityValue)" />
-        public static Pressure TonnesForcePerSquareMeter<T>(this T value) =>
-            Pressure.FromTonnesForcePerSquareMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromTonnesForcePerSquareMeter(T)" />
+        public static Pressure<double> TonnesForcePerSquareMeter<T>(this T value) =>
+            Pressure<double>.FromTonnesForcePerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
-        public static Pressure TonnesForcePerSquareMillimeter<T>(this T value) =>
-            Pressure.FromTonnesForcePerSquareMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromTonnesForcePerSquareMillimeter(T)" />
+        public static Pressure<double> TonnesForcePerSquareMillimeter<T>(this T value) =>
+            Pressure<double>.FromTonnesForcePerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTorrs(UnitsNet.QuantityValue)" />
-        public static Pressure Torrs<T>(this T value) =>
-            Pressure.FromTorrs(Convert.ToDouble(value));
+        /// <inheritdoc cref="Pressure{T}.FromTorrs(T)" />
+        public static Pressure<double> Torrs<T>(this T value) =>
+            Pressure<double>.FromTorrs(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
index fe9e5315e2..b790f96627 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
@@ -28,13 +28,13 @@ namespace UnitsNet.NumberExtensions.NumberToRatioChangeRate
     /// </summary>
     public static class NumberToRatioChangeRateExtensions
     {
-        /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(UnitsNet.QuantityValue)" />
-        public static RatioChangeRate DecimalFractionsPerSecond<T>(this T value) =>
-            RatioChangeRate.FromDecimalFractionsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RatioChangeRate{T}.FromDecimalFractionsPerSecond(T)" />
+        public static RatioChangeRate<double> DecimalFractionsPerSecond<T>(this T value) =>
+            RatioChangeRate<double>.FromDecimalFractionsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(UnitsNet.QuantityValue)" />
-        public static RatioChangeRate PercentsPerSecond<T>(this T value) =>
-            RatioChangeRate.FromPercentsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RatioChangeRate{T}.FromPercentsPerSecond(T)" />
+        public static RatioChangeRate<double> PercentsPerSecond<T>(this T value) =>
+            RatioChangeRate<double>.FromPercentsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
index c1467d6d2d..daf8303773 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
@@ -28,29 +28,29 @@ namespace UnitsNet.NumberExtensions.NumberToRatio
     /// </summary>
     public static class NumberToRatioExtensions
     {
-        /// <inheritdoc cref="Ratio.FromDecimalFractions(UnitsNet.QuantityValue)" />
-        public static Ratio DecimalFractions<T>(this T value) =>
-            Ratio.FromDecimalFractions(Convert.ToDouble(value));
+        /// <inheritdoc cref="Ratio{T}.FromDecimalFractions(T)" />
+        public static Ratio<double> DecimalFractions<T>(this T value) =>
+            Ratio<double>.FromDecimalFractions(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerBillion(UnitsNet.QuantityValue)" />
-        public static Ratio PartsPerBillion<T>(this T value) =>
-            Ratio.FromPartsPerBillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="Ratio{T}.FromPartsPerBillion(T)" />
+        public static Ratio<double> PartsPerBillion<T>(this T value) =>
+            Ratio<double>.FromPartsPerBillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerMillion(UnitsNet.QuantityValue)" />
-        public static Ratio PartsPerMillion<T>(this T value) =>
-            Ratio.FromPartsPerMillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="Ratio{T}.FromPartsPerMillion(T)" />
+        public static Ratio<double> PartsPerMillion<T>(this T value) =>
+            Ratio<double>.FromPartsPerMillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerThousand(UnitsNet.QuantityValue)" />
-        public static Ratio PartsPerThousand<T>(this T value) =>
-            Ratio.FromPartsPerThousand(Convert.ToDouble(value));
+        /// <inheritdoc cref="Ratio{T}.FromPartsPerThousand(T)" />
+        public static Ratio<double> PartsPerThousand<T>(this T value) =>
+            Ratio<double>.FromPartsPerThousand(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
-        public static Ratio PartsPerTrillion<T>(this T value) =>
-            Ratio.FromPartsPerTrillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="Ratio{T}.FromPartsPerTrillion(T)" />
+        public static Ratio<double> PartsPerTrillion<T>(this T value) =>
+            Ratio<double>.FromPartsPerTrillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPercent(UnitsNet.QuantityValue)" />
-        public static Ratio Percent<T>(this T value) =>
-            Ratio.FromPercent(Convert.ToDouble(value));
+        /// <inheritdoc cref="Ratio{T}.FromPercent(T)" />
+        public static Ratio<double> Percent<T>(this T value) =>
+            Ratio<double>.FromPercent(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
index 39c0be6980..d2f4e59699 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToReactiveEnergy
     /// </summary>
     public static class NumberToReactiveEnergyExtensions
     {
-        /// <inheritdoc cref="ReactiveEnergy.FromKilovoltampereReactiveHours(UnitsNet.QuantityValue)" />
-        public static ReactiveEnergy KilovoltampereReactiveHours<T>(this T value) =>
-            ReactiveEnergy.FromKilovoltampereReactiveHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ReactiveEnergy{T}.FromKilovoltampereReactiveHours(T)" />
+        public static ReactiveEnergy<double> KilovoltampereReactiveHours<T>(this T value) =>
+            ReactiveEnergy<double>.FromKilovoltampereReactiveHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactiveEnergy.FromMegavoltampereReactiveHours(UnitsNet.QuantityValue)" />
-        public static ReactiveEnergy MegavoltampereReactiveHours<T>(this T value) =>
-            ReactiveEnergy.FromMegavoltampereReactiveHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ReactiveEnergy{T}.FromMegavoltampereReactiveHours(T)" />
+        public static ReactiveEnergy<double> MegavoltampereReactiveHours<T>(this T value) =>
+            ReactiveEnergy<double>.FromMegavoltampereReactiveHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactiveEnergy.FromVoltampereReactiveHours(UnitsNet.QuantityValue)" />
-        public static ReactiveEnergy VoltampereReactiveHours<T>(this T value) =>
-            ReactiveEnergy.FromVoltampereReactiveHours(Convert.ToDouble(value));
+        /// <inheritdoc cref="ReactiveEnergy{T}.FromVoltampereReactiveHours(T)" />
+        public static ReactiveEnergy<double> VoltampereReactiveHours<T>(this T value) =>
+            ReactiveEnergy<double>.FromVoltampereReactiveHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
index 75118e1eda..93756ac9a4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToReactivePower
     /// </summary>
     public static class NumberToReactivePowerExtensions
     {
-        /// <inheritdoc cref="ReactivePower.FromGigavoltamperesReactive(UnitsNet.QuantityValue)" />
-        public static ReactivePower GigavoltamperesReactive<T>(this T value) =>
-            ReactivePower.FromGigavoltamperesReactive(Convert.ToDouble(value));
+        /// <inheritdoc cref="ReactivePower{T}.FromGigavoltamperesReactive(T)" />
+        public static ReactivePower<double> GigavoltamperesReactive<T>(this T value) =>
+            ReactivePower<double>.FromGigavoltamperesReactive(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactivePower.FromKilovoltamperesReactive(UnitsNet.QuantityValue)" />
-        public static ReactivePower KilovoltamperesReactive<T>(this T value) =>
-            ReactivePower.FromKilovoltamperesReactive(Convert.ToDouble(value));
+        /// <inheritdoc cref="ReactivePower{T}.FromKilovoltamperesReactive(T)" />
+        public static ReactivePower<double> KilovoltamperesReactive<T>(this T value) =>
+            ReactivePower<double>.FromKilovoltamperesReactive(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactivePower.FromMegavoltamperesReactive(UnitsNet.QuantityValue)" />
-        public static ReactivePower MegavoltamperesReactive<T>(this T value) =>
-            ReactivePower.FromMegavoltamperesReactive(Convert.ToDouble(value));
+        /// <inheritdoc cref="ReactivePower{T}.FromMegavoltamperesReactive(T)" />
+        public static ReactivePower<double> MegavoltamperesReactive<T>(this T value) =>
+            ReactivePower<double>.FromMegavoltamperesReactive(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactivePower.FromVoltamperesReactive(UnitsNet.QuantityValue)" />
-        public static ReactivePower VoltamperesReactive<T>(this T value) =>
-            ReactivePower.FromVoltamperesReactive(Convert.ToDouble(value));
+        /// <inheritdoc cref="ReactivePower{T}.FromVoltamperesReactive(T)" />
+        public static ReactivePower<double> VoltamperesReactive<T>(this T value) =>
+            ReactivePower<double>.FromVoltamperesReactive(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
index 91a0b33ba1..01625de10f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToRelativeHumidity
     /// </summary>
     public static class NumberToRelativeHumidityExtensions
     {
-        /// <inheritdoc cref="RelativeHumidity.FromPercent(UnitsNet.QuantityValue)" />
-        public static RelativeHumidity Percent<T>(this T value) =>
-            RelativeHumidity.FromPercent(Convert.ToDouble(value));
+        /// <inheritdoc cref="RelativeHumidity{T}.FromPercent(T)" />
+        public static RelativeHumidity<double> Percent<T>(this T value) =>
+            RelativeHumidity<double>.FromPercent(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
index 156eb25e82..9096c039e3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
@@ -28,21 +28,21 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalAcceleration
     /// </summary>
     public static class NumberToRotationalAccelerationExtensions
     {
-        /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static RotationalAcceleration DegreesPerSecondSquared<T>(this T value) =>
-            RotationalAcceleration.FromDegreesPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalAcceleration{T}.FromDegreesPerSecondSquared(T)" />
+        public static RotationalAcceleration<double> DegreesPerSecondSquared<T>(this T value) =>
+            RotationalAcceleration<double>.FromDegreesPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static RotationalAcceleration RadiansPerSecondSquared<T>(this T value) =>
-            RotationalAcceleration.FromRadiansPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalAcceleration{T}.FromRadiansPerSecondSquared(T)" />
+        public static RotationalAcceleration<double> RadiansPerSecondSquared<T>(this T value) =>
+            RotationalAcceleration<double>.FromRadiansPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalAcceleration RevolutionsPerMinutePerSecond<T>(this T value) =>
-            RotationalAcceleration.FromRevolutionsPerMinutePerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalAcceleration{T}.FromRevolutionsPerMinutePerSecond(T)" />
+        public static RotationalAcceleration<double> RevolutionsPerMinutePerSecond<T>(this T value) =>
+            RotationalAcceleration<double>.FromRevolutionsPerMinutePerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(UnitsNet.QuantityValue)" />
-        public static RotationalAcceleration RevolutionsPerSecondSquared<T>(this T value) =>
-            RotationalAcceleration.FromRevolutionsPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalAcceleration{T}.FromRevolutionsPerSecondSquared(T)" />
+        public static RotationalAcceleration<double> RevolutionsPerSecondSquared<T>(this T value) =>
+            RotationalAcceleration<double>.FromRevolutionsPerSecondSquared(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
index eae1fce0fa..42db43067d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
@@ -28,57 +28,57 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalSpeed
     /// </summary>
     public static class NumberToRotationalSpeedExtensions
     {
-        /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed CentiradiansPerSecond<T>(this T value) =>
-            RotationalSpeed.FromCentiradiansPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromCentiradiansPerSecond(T)" />
+        public static RotationalSpeed<double> CentiradiansPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromCentiradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed DeciradiansPerSecond<T>(this T value) =>
-            RotationalSpeed.FromDeciradiansPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromDeciradiansPerSecond(T)" />
+        public static RotationalSpeed<double> DeciradiansPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromDeciradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed DegreesPerMinute<T>(this T value) =>
-            RotationalSpeed.FromDegreesPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromDegreesPerMinute(T)" />
+        public static RotationalSpeed<double> DegreesPerMinute<T>(this T value) =>
+            RotationalSpeed<double>.FromDegreesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed DegreesPerSecond<T>(this T value) =>
-            RotationalSpeed.FromDegreesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromDegreesPerSecond(T)" />
+        public static RotationalSpeed<double> DegreesPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromDegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed MicrodegreesPerSecond<T>(this T value) =>
-            RotationalSpeed.FromMicrodegreesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromMicrodegreesPerSecond(T)" />
+        public static RotationalSpeed<double> MicrodegreesPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromMicrodegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed MicroradiansPerSecond<T>(this T value) =>
-            RotationalSpeed.FromMicroradiansPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromMicroradiansPerSecond(T)" />
+        public static RotationalSpeed<double> MicroradiansPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromMicroradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed MillidegreesPerSecond<T>(this T value) =>
-            RotationalSpeed.FromMillidegreesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromMillidegreesPerSecond(T)" />
+        public static RotationalSpeed<double> MillidegreesPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromMillidegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed MilliradiansPerSecond<T>(this T value) =>
-            RotationalSpeed.FromMilliradiansPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromMilliradiansPerSecond(T)" />
+        public static RotationalSpeed<double> MilliradiansPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromMilliradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed NanodegreesPerSecond<T>(this T value) =>
-            RotationalSpeed.FromNanodegreesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromNanodegreesPerSecond(T)" />
+        public static RotationalSpeed<double> NanodegreesPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromNanodegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed NanoradiansPerSecond<T>(this T value) =>
-            RotationalSpeed.FromNanoradiansPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromNanoradiansPerSecond(T)" />
+        public static RotationalSpeed<double> NanoradiansPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromNanoradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed RadiansPerSecond<T>(this T value) =>
-            RotationalSpeed.FromRadiansPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromRadiansPerSecond(T)" />
+        public static RotationalSpeed<double> RadiansPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromRadiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed RevolutionsPerMinute<T>(this T value) =>
-            RotationalSpeed.FromRevolutionsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromRevolutionsPerMinute(T)" />
+        public static RotationalSpeed<double> RevolutionsPerMinute<T>(this T value) =>
+            RotationalSpeed<double>.FromRevolutionsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(UnitsNet.QuantityValue)" />
-        public static RotationalSpeed RevolutionsPerSecond<T>(this T value) =>
-            RotationalSpeed.FromRevolutionsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalSpeed{T}.FromRevolutionsPerSecond(T)" />
+        public static RotationalSpeed<double> RevolutionsPerSecond<T>(this T value) =>
+            RotationalSpeed<double>.FromRevolutionsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
index 8784ebce04..3819dc4f2b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
@@ -28,137 +28,137 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalStiffness
     /// </summary>
     public static class NumberToRotationalStiffnessExtensions
     {
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness CentinewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromCentinewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromCentinewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> CentinewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromCentinewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness CentinewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromCentinewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromCentinewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> CentinewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromCentinewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness CentinewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromCentinewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromCentinewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> CentinewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromCentinewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness DecanewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromDecanewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromDecanewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> DecanewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromDecanewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness DecanewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromDecanewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromDecanewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> DecanewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromDecanewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness DecanewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromDecanewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromDecanewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> DecanewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromDecanewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness DecinewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromDecinewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromDecinewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> DecinewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromDecinewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness DecinewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromDecinewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromDecinewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> DecinewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromDecinewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness DecinewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromDecinewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromDecinewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> DecinewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromDecinewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness KilonewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromKilonewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromKilonewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> KilonewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromKilonewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness KilonewtonMetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromKilonewtonMetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromKilonewtonMetersPerRadian(T)" />
+        public static RotationalStiffness<double> KilonewtonMetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromKilonewtonMetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness KilonewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromKilonewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromKilonewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> KilonewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromKilonewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness KilonewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromKilonewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromKilonewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> KilonewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromKilonewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerDegrees(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness KilopoundForceFeetPerDegrees<T>(this T value) =>
-            RotationalStiffness.FromKilopoundForceFeetPerDegrees(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromKilopoundForceFeetPerDegrees(T)" />
+        public static RotationalStiffness<double> KilopoundForceFeetPerDegrees<T>(this T value) =>
+            RotationalStiffness<double>.FromKilopoundForceFeetPerDegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MeganewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromMeganewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMeganewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> MeganewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromMeganewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MeganewtonMetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromMeganewtonMetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMeganewtonMetersPerRadian(T)" />
+        public static RotationalStiffness<double> MeganewtonMetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromMeganewtonMetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MeganewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromMeganewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMeganewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> MeganewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromMeganewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MeganewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromMeganewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMeganewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> MeganewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromMeganewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MicronewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromMicronewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMicronewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> MicronewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromMicronewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MicronewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromMicronewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMicronewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> MicronewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromMicronewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MicronewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromMicronewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMicronewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> MicronewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromMicronewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MillinewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromMillinewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMillinewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> MillinewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromMillinewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MillinewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromMillinewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMillinewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> MillinewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromMillinewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness MillinewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromMillinewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromMillinewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> MillinewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromMillinewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness NanonewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromNanonewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromNanonewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> NanonewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromNanonewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness NanonewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromNanonewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromNanonewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> NanonewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromNanonewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness NanonewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromNanonewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromNanonewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> NanonewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromNanonewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness NewtonMetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromNewtonMetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromNewtonMetersPerDegree(T)" />
+        public static RotationalStiffness<double> NewtonMetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromNewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness NewtonMetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromNewtonMetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromNewtonMetersPerRadian(T)" />
+        public static RotationalStiffness<double> NewtonMetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromNewtonMetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness NewtonMillimetersPerDegree<T>(this T value) =>
-            RotationalStiffness.FromNewtonMillimetersPerDegree(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromNewtonMillimetersPerDegree(T)" />
+        public static RotationalStiffness<double> NewtonMillimetersPerDegree<T>(this T value) =>
+            RotationalStiffness<double>.FromNewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness NewtonMillimetersPerRadian<T>(this T value) =>
-            RotationalStiffness.FromNewtonMillimetersPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromNewtonMillimetersPerRadian(T)" />
+        public static RotationalStiffness<double> NewtonMillimetersPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromNewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerRadian(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness PoundForceFeetPerRadian<T>(this T value) =>
-            RotationalStiffness.FromPoundForceFeetPerRadian(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromPoundForceFeetPerRadian(T)" />
+        public static RotationalStiffness<double> PoundForceFeetPerRadian<T>(this T value) =>
+            RotationalStiffness<double>.FromPoundForceFeetPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerDegrees(UnitsNet.QuantityValue)" />
-        public static RotationalStiffness PoundForceFeetPerDegrees<T>(this T value) =>
-            RotationalStiffness.FromPoundForceFeetPerDegrees(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffness{T}.FromPoundForceFeetPerDegrees(T)" />
+        public static RotationalStiffness<double> PoundForceFeetPerDegrees<T>(this T value) =>
+            RotationalStiffness<double>.FromPoundForceFeetPerDegrees(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
index d6cd6bb377..1364ef6ece 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
@@ -28,25 +28,25 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalStiffnessPerLength
     /// </summary>
     public static class NumberToRotationalStiffnessPerLengthExtensions
     {
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
-        public static RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter<T>(this T value) =>
-            RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffnessPerLength{T}.FromKilonewtonMetersPerRadianPerMeter(T)" />
+        public static RotationalStiffnessPerLength<double> KilonewtonMetersPerRadianPerMeter<T>(this T value) =>
+            RotationalStiffnessPerLength<double>.FromKilonewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(UnitsNet.QuantityValue)" />
-        public static RotationalStiffnessPerLength KilopoundForceFeetPerDegreesPerFeet<T>(this T value) =>
-            RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffnessPerLength{T}.FromKilopoundForceFeetPerDegreesPerFeet(T)" />
+        public static RotationalStiffnessPerLength<double> KilopoundForceFeetPerDegreesPerFeet<T>(this T value) =>
+            RotationalStiffnessPerLength<double>.FromKilopoundForceFeetPerDegreesPerFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
-        public static RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter<T>(this T value) =>
-            RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffnessPerLength{T}.FromMeganewtonMetersPerRadianPerMeter(T)" />
+        public static RotationalStiffnessPerLength<double> MeganewtonMetersPerRadianPerMeter<T>(this T value) =>
+            RotationalStiffnessPerLength<double>.FromMeganewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
-        public static RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter<T>(this T value) =>
-            RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffnessPerLength{T}.FromNewtonMetersPerRadianPerMeter(T)" />
+        public static RotationalStiffnessPerLength<double> NewtonMetersPerRadianPerMeter<T>(this T value) =>
+            RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(UnitsNet.QuantityValue)" />
-        public static RotationalStiffnessPerLength PoundForceFeetPerDegreesPerFeet<T>(this T value) =>
-            RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="RotationalStiffnessPerLength{T}.FromPoundForceFeetPerDegreesPerFeet(T)" />
+        public static RotationalStiffnessPerLength<double> PoundForceFeetPerDegreesPerFeet<T>(this T value) =>
+            RotationalStiffnessPerLength<double>.FromPoundForceFeetPerDegreesPerFeet(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
index fdbcfd2703..fe90173629 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToSolidAngle
     /// </summary>
     public static class NumberToSolidAngleExtensions
     {
-        /// <inheritdoc cref="SolidAngle.FromSteradians(UnitsNet.QuantityValue)" />
-        public static SolidAngle Steradians<T>(this T value) =>
-            SolidAngle.FromSteradians(Convert.ToDouble(value));
+        /// <inheritdoc cref="SolidAngle{T}.FromSteradians(T)" />
+        public static SolidAngle<double> Steradians<T>(this T value) =>
+            SolidAngle<double>.FromSteradians(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
index 5d02c7975f..d82c009ce4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
@@ -28,105 +28,105 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificEnergy
     /// </summary>
     public static class NumberToSpecificEnergyExtensions
     {
-        /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy BtuPerPound<T>(this T value) =>
-            SpecificEnergy.FromBtuPerPound(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromBtuPerPound(T)" />
+        public static SpecificEnergy<double> BtuPerPound<T>(this T value) =>
+            SpecificEnergy<double>.FromBtuPerPound(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy CaloriesPerGram<T>(this T value) =>
-            SpecificEnergy.FromCaloriesPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromCaloriesPerGram(T)" />
+        public static SpecificEnergy<double> CaloriesPerGram<T>(this T value) =>
+            SpecificEnergy<double>.FromCaloriesPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy GigawattDaysPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromGigawattDaysPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromGigawattDaysPerKilogram(T)" />
+        public static SpecificEnergy<double> GigawattDaysPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromGigawattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerShortTon(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy GigawattDaysPerShortTon<T>(this T value) =>
-            SpecificEnergy.FromGigawattDaysPerShortTon(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromGigawattDaysPerShortTon(T)" />
+        public static SpecificEnergy<double> GigawattDaysPerShortTon<T>(this T value) =>
+            SpecificEnergy<double>.FromGigawattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerTonne(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy GigawattDaysPerTonne<T>(this T value) =>
-            SpecificEnergy.FromGigawattDaysPerTonne(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromGigawattDaysPerTonne(T)" />
+        public static SpecificEnergy<double> GigawattDaysPerTonne<T>(this T value) =>
+            SpecificEnergy<double>.FromGigawattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy GigawattHoursPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromGigawattHoursPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromGigawattHoursPerKilogram(T)" />
+        public static SpecificEnergy<double> GigawattHoursPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromGigawattHoursPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy JoulesPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromJoulesPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromJoulesPerKilogram(T)" />
+        public static SpecificEnergy<double> JoulesPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromJoulesPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy KilocaloriesPerGram<T>(this T value) =>
-            SpecificEnergy.FromKilocaloriesPerGram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromKilocaloriesPerGram(T)" />
+        public static SpecificEnergy<double> KilocaloriesPerGram<T>(this T value) =>
+            SpecificEnergy<double>.FromKilocaloriesPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy KilojoulesPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromKilojoulesPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromKilojoulesPerKilogram(T)" />
+        public static SpecificEnergy<double> KilojoulesPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromKilojoulesPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy KilowattDaysPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromKilowattDaysPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromKilowattDaysPerKilogram(T)" />
+        public static SpecificEnergy<double> KilowattDaysPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromKilowattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerShortTon(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy KilowattDaysPerShortTon<T>(this T value) =>
-            SpecificEnergy.FromKilowattDaysPerShortTon(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromKilowattDaysPerShortTon(T)" />
+        public static SpecificEnergy<double> KilowattDaysPerShortTon<T>(this T value) =>
+            SpecificEnergy<double>.FromKilowattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerTonne(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy KilowattDaysPerTonne<T>(this T value) =>
-            SpecificEnergy.FromKilowattDaysPerTonne(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromKilowattDaysPerTonne(T)" />
+        public static SpecificEnergy<double> KilowattDaysPerTonne<T>(this T value) =>
+            SpecificEnergy<double>.FromKilowattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy KilowattHoursPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromKilowattHoursPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromKilowattHoursPerKilogram(T)" />
+        public static SpecificEnergy<double> KilowattHoursPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromKilowattHoursPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy MegajoulesPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromMegajoulesPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromMegajoulesPerKilogram(T)" />
+        public static SpecificEnergy<double> MegajoulesPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromMegajoulesPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy MegawattDaysPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromMegawattDaysPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromMegawattDaysPerKilogram(T)" />
+        public static SpecificEnergy<double> MegawattDaysPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromMegawattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerShortTon(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy MegawattDaysPerShortTon<T>(this T value) =>
-            SpecificEnergy.FromMegawattDaysPerShortTon(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromMegawattDaysPerShortTon(T)" />
+        public static SpecificEnergy<double> MegawattDaysPerShortTon<T>(this T value) =>
+            SpecificEnergy<double>.FromMegawattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerTonne(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy MegawattDaysPerTonne<T>(this T value) =>
-            SpecificEnergy.FromMegawattDaysPerTonne(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromMegawattDaysPerTonne(T)" />
+        public static SpecificEnergy<double> MegawattDaysPerTonne<T>(this T value) =>
+            SpecificEnergy<double>.FromMegawattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy MegawattHoursPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromMegawattHoursPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromMegawattHoursPerKilogram(T)" />
+        public static SpecificEnergy<double> MegawattHoursPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromMegawattHoursPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy TerawattDaysPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromTerawattDaysPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromTerawattDaysPerKilogram(T)" />
+        public static SpecificEnergy<double> TerawattDaysPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromTerawattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerShortTon(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy TerawattDaysPerShortTon<T>(this T value) =>
-            SpecificEnergy.FromTerawattDaysPerShortTon(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromTerawattDaysPerShortTon(T)" />
+        public static SpecificEnergy<double> TerawattDaysPerShortTon<T>(this T value) =>
+            SpecificEnergy<double>.FromTerawattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerTonne(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy TerawattDaysPerTonne<T>(this T value) =>
-            SpecificEnergy.FromTerawattDaysPerTonne(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromTerawattDaysPerTonne(T)" />
+        public static SpecificEnergy<double> TerawattDaysPerTonne<T>(this T value) =>
+            SpecificEnergy<double>.FromTerawattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy WattDaysPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromWattDaysPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromWattDaysPerKilogram(T)" />
+        public static SpecificEnergy<double> WattDaysPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromWattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerShortTon(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy WattDaysPerShortTon<T>(this T value) =>
-            SpecificEnergy.FromWattDaysPerShortTon(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromWattDaysPerShortTon(T)" />
+        public static SpecificEnergy<double> WattDaysPerShortTon<T>(this T value) =>
+            SpecificEnergy<double>.FromWattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerTonne(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy WattDaysPerTonne<T>(this T value) =>
-            SpecificEnergy.FromWattDaysPerTonne(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromWattDaysPerTonne(T)" />
+        public static SpecificEnergy<double> WattDaysPerTonne<T>(this T value) =>
+            SpecificEnergy<double>.FromWattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificEnergy WattHoursPerKilogram<T>(this T value) =>
-            SpecificEnergy.FromWattHoursPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEnergy{T}.FromWattHoursPerKilogram(T)" />
+        public static SpecificEnergy<double> WattHoursPerKilogram<T>(this T value) =>
+            SpecificEnergy<double>.FromWattHoursPerKilogram(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
index 2cf3ea386c..04ba0a1451 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
@@ -28,41 +28,41 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificEntropy
     /// </summary>
     public static class NumberToSpecificEntropyExtensions
     {
-        /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy BtusPerPoundFahrenheit<T>(this T value) =>
-            SpecificEntropy.FromBtusPerPoundFahrenheit(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromBtusPerPoundFahrenheit(T)" />
+        public static SpecificEntropy<double> BtusPerPoundFahrenheit<T>(this T value) =>
+            SpecificEntropy<double>.FromBtusPerPoundFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy CaloriesPerGramKelvin<T>(this T value) =>
-            SpecificEntropy.FromCaloriesPerGramKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromCaloriesPerGramKelvin(T)" />
+        public static SpecificEntropy<double> CaloriesPerGramKelvin<T>(this T value) =>
+            SpecificEntropy<double>.FromCaloriesPerGramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy JoulesPerKilogramDegreeCelsius<T>(this T value) =>
-            SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromJoulesPerKilogramDegreeCelsius(T)" />
+        public static SpecificEntropy<double> JoulesPerKilogramDegreeCelsius<T>(this T value) =>
+            SpecificEntropy<double>.FromJoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy JoulesPerKilogramKelvin<T>(this T value) =>
-            SpecificEntropy.FromJoulesPerKilogramKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromJoulesPerKilogramKelvin(T)" />
+        public static SpecificEntropy<double> JoulesPerKilogramKelvin<T>(this T value) =>
+            SpecificEntropy<double>.FromJoulesPerKilogramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy KilocaloriesPerGramKelvin<T>(this T value) =>
-            SpecificEntropy.FromKilocaloriesPerGramKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromKilocaloriesPerGramKelvin(T)" />
+        public static SpecificEntropy<double> KilocaloriesPerGramKelvin<T>(this T value) =>
+            SpecificEntropy<double>.FromKilocaloriesPerGramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy KilojoulesPerKilogramDegreeCelsius<T>(this T value) =>
-            SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromKilojoulesPerKilogramDegreeCelsius(T)" />
+        public static SpecificEntropy<double> KilojoulesPerKilogramDegreeCelsius<T>(this T value) =>
+            SpecificEntropy<double>.FromKilojoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy KilojoulesPerKilogramKelvin<T>(this T value) =>
-            SpecificEntropy.FromKilojoulesPerKilogramKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromKilojoulesPerKilogramKelvin(T)" />
+        public static SpecificEntropy<double> KilojoulesPerKilogramKelvin<T>(this T value) =>
+            SpecificEntropy<double>.FromKilojoulesPerKilogramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy MegajoulesPerKilogramDegreeCelsius<T>(this T value) =>
-            SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromMegajoulesPerKilogramDegreeCelsius(T)" />
+        public static SpecificEntropy<double> MegajoulesPerKilogramDegreeCelsius<T>(this T value) =>
+            SpecificEntropy<double>.FromMegajoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
-        public static SpecificEntropy MegajoulesPerKilogramKelvin<T>(this T value) =>
-            SpecificEntropy.FromMegajoulesPerKilogramKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificEntropy{T}.FromMegajoulesPerKilogramKelvin(T)" />
+        public static SpecificEntropy<double> MegajoulesPerKilogramKelvin<T>(this T value) =>
+            SpecificEntropy<double>.FromMegajoulesPerKilogramKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
index ee2d77d537..1cd2a71486 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
@@ -28,17 +28,17 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificVolume
     /// </summary>
     public static class NumberToSpecificVolumeExtensions
     {
-        /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(UnitsNet.QuantityValue)" />
-        public static SpecificVolume CubicFeetPerPound<T>(this T value) =>
-            SpecificVolume.FromCubicFeetPerPound(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificVolume{T}.FromCubicFeetPerPound(T)" />
+        public static SpecificVolume<double> CubicFeetPerPound<T>(this T value) =>
+            SpecificVolume<double>.FromCubicFeetPerPound(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificVolume CubicMetersPerKilogram<T>(this T value) =>
-            SpecificVolume.FromCubicMetersPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificVolume{T}.FromCubicMetersPerKilogram(T)" />
+        public static SpecificVolume<double> CubicMetersPerKilogram<T>(this T value) =>
+            SpecificVolume<double>.FromCubicMetersPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificVolume.FromMillicubicMetersPerKilogram(UnitsNet.QuantityValue)" />
-        public static SpecificVolume MillicubicMetersPerKilogram<T>(this T value) =>
-            SpecificVolume.FromMillicubicMetersPerKilogram(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificVolume{T}.FromMillicubicMetersPerKilogram(T)" />
+        public static SpecificVolume<double> MillicubicMetersPerKilogram<T>(this T value) =>
+            SpecificVolume<double>.FromMillicubicMetersPerKilogram(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
index c21e5d0d51..621679d58b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
@@ -28,73 +28,73 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificWeight
     /// </summary>
     public static class NumberToSpecificWeightExtensions
     {
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilogramsForcePerCubicCentimeter<T>(this T value) =>
-            SpecificWeight.FromKilogramsForcePerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilogramsForcePerCubicCentimeter(T)" />
+        public static SpecificWeight<double> KilogramsForcePerCubicCentimeter<T>(this T value) =>
+            SpecificWeight<double>.FromKilogramsForcePerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilogramsForcePerCubicMeter<T>(this T value) =>
-            SpecificWeight.FromKilogramsForcePerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilogramsForcePerCubicMeter(T)" />
+        public static SpecificWeight<double> KilogramsForcePerCubicMeter<T>(this T value) =>
+            SpecificWeight<double>.FromKilogramsForcePerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilogramsForcePerCubicMillimeter<T>(this T value) =>
-            SpecificWeight.FromKilogramsForcePerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilogramsForcePerCubicMillimeter(T)" />
+        public static SpecificWeight<double> KilogramsForcePerCubicMillimeter<T>(this T value) =>
+            SpecificWeight<double>.FromKilogramsForcePerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilonewtonsPerCubicCentimeter<T>(this T value) =>
-            SpecificWeight.FromKilonewtonsPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilonewtonsPerCubicCentimeter(T)" />
+        public static SpecificWeight<double> KilonewtonsPerCubicCentimeter<T>(this T value) =>
+            SpecificWeight<double>.FromKilonewtonsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilonewtonsPerCubicMeter<T>(this T value) =>
-            SpecificWeight.FromKilonewtonsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilonewtonsPerCubicMeter(T)" />
+        public static SpecificWeight<double> KilonewtonsPerCubicMeter<T>(this T value) =>
+            SpecificWeight<double>.FromKilonewtonsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilonewtonsPerCubicMillimeter<T>(this T value) =>
-            SpecificWeight.FromKilonewtonsPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilonewtonsPerCubicMillimeter(T)" />
+        public static SpecificWeight<double> KilonewtonsPerCubicMillimeter<T>(this T value) =>
+            SpecificWeight<double>.FromKilonewtonsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilopoundsForcePerCubicFoot<T>(this T value) =>
-            SpecificWeight.FromKilopoundsForcePerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilopoundsForcePerCubicFoot(T)" />
+        public static SpecificWeight<double> KilopoundsForcePerCubicFoot<T>(this T value) =>
+            SpecificWeight<double>.FromKilopoundsForcePerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
-        public static SpecificWeight KilopoundsForcePerCubicInch<T>(this T value) =>
-            SpecificWeight.FromKilopoundsForcePerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromKilopoundsForcePerCubicInch(T)" />
+        public static SpecificWeight<double> KilopoundsForcePerCubicInch<T>(this T value) =>
+            SpecificWeight<double>.FromKilopoundsForcePerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight MeganewtonsPerCubicMeter<T>(this T value) =>
-            SpecificWeight.FromMeganewtonsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromMeganewtonsPerCubicMeter(T)" />
+        public static SpecificWeight<double> MeganewtonsPerCubicMeter<T>(this T value) =>
+            SpecificWeight<double>.FromMeganewtonsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight NewtonsPerCubicCentimeter<T>(this T value) =>
-            SpecificWeight.FromNewtonsPerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromNewtonsPerCubicCentimeter(T)" />
+        public static SpecificWeight<double> NewtonsPerCubicCentimeter<T>(this T value) =>
+            SpecificWeight<double>.FromNewtonsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight NewtonsPerCubicMeter<T>(this T value) =>
-            SpecificWeight.FromNewtonsPerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromNewtonsPerCubicMeter(T)" />
+        public static SpecificWeight<double> NewtonsPerCubicMeter<T>(this T value) =>
+            SpecificWeight<double>.FromNewtonsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight NewtonsPerCubicMillimeter<T>(this T value) =>
-            SpecificWeight.FromNewtonsPerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromNewtonsPerCubicMillimeter(T)" />
+        public static SpecificWeight<double> NewtonsPerCubicMillimeter<T>(this T value) =>
+            SpecificWeight<double>.FromNewtonsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
-        public static SpecificWeight PoundsForcePerCubicFoot<T>(this T value) =>
-            SpecificWeight.FromPoundsForcePerCubicFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromPoundsForcePerCubicFoot(T)" />
+        public static SpecificWeight<double> PoundsForcePerCubicFoot<T>(this T value) =>
+            SpecificWeight<double>.FromPoundsForcePerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
-        public static SpecificWeight PoundsForcePerCubicInch<T>(this T value) =>
-            SpecificWeight.FromPoundsForcePerCubicInch(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromPoundsForcePerCubicInch(T)" />
+        public static SpecificWeight<double> PoundsForcePerCubicInch<T>(this T value) =>
+            SpecificWeight<double>.FromPoundsForcePerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight TonnesForcePerCubicCentimeter<T>(this T value) =>
-            SpecificWeight.FromTonnesForcePerCubicCentimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromTonnesForcePerCubicCentimeter(T)" />
+        public static SpecificWeight<double> TonnesForcePerCubicCentimeter<T>(this T value) =>
+            SpecificWeight<double>.FromTonnesForcePerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight TonnesForcePerCubicMeter<T>(this T value) =>
-            SpecificWeight.FromTonnesForcePerCubicMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromTonnesForcePerCubicMeter(T)" />
+        public static SpecificWeight<double> TonnesForcePerCubicMeter<T>(this T value) =>
+            SpecificWeight<double>.FromTonnesForcePerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
-        public static SpecificWeight TonnesForcePerCubicMillimeter<T>(this T value) =>
-            SpecificWeight.FromTonnesForcePerCubicMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="SpecificWeight{T}.FromTonnesForcePerCubicMillimeter(T)" />
+        public static SpecificWeight<double> TonnesForcePerCubicMillimeter<T>(this T value) =>
+            SpecificWeight<double>.FromTonnesForcePerCubicMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
index 687b90db47..5ce164060f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
@@ -28,133 +28,133 @@ namespace UnitsNet.NumberExtensions.NumberToSpeed
     /// </summary>
     public static class NumberToSpeedExtensions
     {
-        /// <inheritdoc cref="Speed.FromCentimetersPerHour(UnitsNet.QuantityValue)" />
-        public static Speed CentimetersPerHour<T>(this T value) =>
-            Speed.FromCentimetersPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromCentimetersPerHour(T)" />
+        public static Speed<double> CentimetersPerHour<T>(this T value) =>
+            Speed<double>.FromCentimetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromCentimetersPerMinutes(UnitsNet.QuantityValue)" />
-        public static Speed CentimetersPerMinutes<T>(this T value) =>
-            Speed.FromCentimetersPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromCentimetersPerMinutes(T)" />
+        public static Speed<double> CentimetersPerMinutes<T>(this T value) =>
+            Speed<double>.FromCentimetersPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromCentimetersPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed CentimetersPerSecond<T>(this T value) =>
-            Speed.FromCentimetersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromCentimetersPerSecond(T)" />
+        public static Speed<double> CentimetersPerSecond<T>(this T value) =>
+            Speed<double>.FromCentimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromDecimetersPerMinutes(UnitsNet.QuantityValue)" />
-        public static Speed DecimetersPerMinutes<T>(this T value) =>
-            Speed.FromDecimetersPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromDecimetersPerMinutes(T)" />
+        public static Speed<double> DecimetersPerMinutes<T>(this T value) =>
+            Speed<double>.FromDecimetersPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromDecimetersPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed DecimetersPerSecond<T>(this T value) =>
-            Speed.FromDecimetersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromDecimetersPerSecond(T)" />
+        public static Speed<double> DecimetersPerSecond<T>(this T value) =>
+            Speed<double>.FromDecimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromFeetPerHour(UnitsNet.QuantityValue)" />
-        public static Speed FeetPerHour<T>(this T value) =>
-            Speed.FromFeetPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromFeetPerHour(T)" />
+        public static Speed<double> FeetPerHour<T>(this T value) =>
+            Speed<double>.FromFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromFeetPerMinute(UnitsNet.QuantityValue)" />
-        public static Speed FeetPerMinute<T>(this T value) =>
-            Speed.FromFeetPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromFeetPerMinute(T)" />
+        public static Speed<double> FeetPerMinute<T>(this T value) =>
+            Speed<double>.FromFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromFeetPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed FeetPerSecond<T>(this T value) =>
-            Speed.FromFeetPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromFeetPerSecond(T)" />
+        public static Speed<double> FeetPerSecond<T>(this T value) =>
+            Speed<double>.FromFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromInchesPerHour(UnitsNet.QuantityValue)" />
-        public static Speed InchesPerHour<T>(this T value) =>
-            Speed.FromInchesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromInchesPerHour(T)" />
+        public static Speed<double> InchesPerHour<T>(this T value) =>
+            Speed<double>.FromInchesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromInchesPerMinute(UnitsNet.QuantityValue)" />
-        public static Speed InchesPerMinute<T>(this T value) =>
-            Speed.FromInchesPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromInchesPerMinute(T)" />
+        public static Speed<double> InchesPerMinute<T>(this T value) =>
+            Speed<double>.FromInchesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromInchesPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed InchesPerSecond<T>(this T value) =>
-            Speed.FromInchesPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromInchesPerSecond(T)" />
+        public static Speed<double> InchesPerSecond<T>(this T value) =>
+            Speed<double>.FromInchesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKilometersPerHour(UnitsNet.QuantityValue)" />
-        public static Speed KilometersPerHour<T>(this T value) =>
-            Speed.FromKilometersPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromKilometersPerHour(T)" />
+        public static Speed<double> KilometersPerHour<T>(this T value) =>
+            Speed<double>.FromKilometersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKilometersPerMinutes(UnitsNet.QuantityValue)" />
-        public static Speed KilometersPerMinutes<T>(this T value) =>
-            Speed.FromKilometersPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromKilometersPerMinutes(T)" />
+        public static Speed<double> KilometersPerMinutes<T>(this T value) =>
+            Speed<double>.FromKilometersPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKilometersPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed KilometersPerSecond<T>(this T value) =>
-            Speed.FromKilometersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromKilometersPerSecond(T)" />
+        public static Speed<double> KilometersPerSecond<T>(this T value) =>
+            Speed<double>.FromKilometersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKnots(UnitsNet.QuantityValue)" />
-        public static Speed Knots<T>(this T value) =>
-            Speed.FromKnots(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromKnots(T)" />
+        public static Speed<double> Knots<T>(this T value) =>
+            Speed<double>.FromKnots(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMetersPerHour(UnitsNet.QuantityValue)" />
-        public static Speed MetersPerHour<T>(this T value) =>
-            Speed.FromMetersPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMetersPerHour(T)" />
+        public static Speed<double> MetersPerHour<T>(this T value) =>
+            Speed<double>.FromMetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMetersPerMinutes(UnitsNet.QuantityValue)" />
-        public static Speed MetersPerMinutes<T>(this T value) =>
-            Speed.FromMetersPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMetersPerMinutes(T)" />
+        public static Speed<double> MetersPerMinutes<T>(this T value) =>
+            Speed<double>.FromMetersPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMetersPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed MetersPerSecond<T>(this T value) =>
-            Speed.FromMetersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMetersPerSecond(T)" />
+        public static Speed<double> MetersPerSecond<T>(this T value) =>
+            Speed<double>.FromMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMicrometersPerMinutes(UnitsNet.QuantityValue)" />
-        public static Speed MicrometersPerMinutes<T>(this T value) =>
-            Speed.FromMicrometersPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMicrometersPerMinutes(T)" />
+        public static Speed<double> MicrometersPerMinutes<T>(this T value) =>
+            Speed<double>.FromMicrometersPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMicrometersPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed MicrometersPerSecond<T>(this T value) =>
-            Speed.FromMicrometersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMicrometersPerSecond(T)" />
+        public static Speed<double> MicrometersPerSecond<T>(this T value) =>
+            Speed<double>.FromMicrometersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMilesPerHour(UnitsNet.QuantityValue)" />
-        public static Speed MilesPerHour<T>(this T value) =>
-            Speed.FromMilesPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMilesPerHour(T)" />
+        public static Speed<double> MilesPerHour<T>(this T value) =>
+            Speed<double>.FromMilesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerHour(UnitsNet.QuantityValue)" />
-        public static Speed MillimetersPerHour<T>(this T value) =>
-            Speed.FromMillimetersPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMillimetersPerHour(T)" />
+        public static Speed<double> MillimetersPerHour<T>(this T value) =>
+            Speed<double>.FromMillimetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerMinutes(UnitsNet.QuantityValue)" />
-        public static Speed MillimetersPerMinutes<T>(this T value) =>
-            Speed.FromMillimetersPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMillimetersPerMinutes(T)" />
+        public static Speed<double> MillimetersPerMinutes<T>(this T value) =>
+            Speed<double>.FromMillimetersPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed MillimetersPerSecond<T>(this T value) =>
-            Speed.FromMillimetersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromMillimetersPerSecond(T)" />
+        public static Speed<double> MillimetersPerSecond<T>(this T value) =>
+            Speed<double>.FromMillimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromNanometersPerMinutes(UnitsNet.QuantityValue)" />
-        public static Speed NanometersPerMinutes<T>(this T value) =>
-            Speed.FromNanometersPerMinutes(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromNanometersPerMinutes(T)" />
+        public static Speed<double> NanometersPerMinutes<T>(this T value) =>
+            Speed<double>.FromNanometersPerMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromNanometersPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed NanometersPerSecond<T>(this T value) =>
-            Speed.FromNanometersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromNanometersPerSecond(T)" />
+        public static Speed<double> NanometersPerSecond<T>(this T value) =>
+            Speed<double>.FromNanometersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(UnitsNet.QuantityValue)" />
-        public static Speed UsSurveyFeetPerHour<T>(this T value) =>
-            Speed.FromUsSurveyFeetPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromUsSurveyFeetPerHour(T)" />
+        public static Speed<double> UsSurveyFeetPerHour<T>(this T value) =>
+            Speed<double>.FromUsSurveyFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(UnitsNet.QuantityValue)" />
-        public static Speed UsSurveyFeetPerMinute<T>(this T value) =>
-            Speed.FromUsSurveyFeetPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromUsSurveyFeetPerMinute(T)" />
+        public static Speed<double> UsSurveyFeetPerMinute<T>(this T value) =>
+            Speed<double>.FromUsSurveyFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed UsSurveyFeetPerSecond<T>(this T value) =>
-            Speed.FromUsSurveyFeetPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromUsSurveyFeetPerSecond(T)" />
+        public static Speed<double> UsSurveyFeetPerSecond<T>(this T value) =>
+            Speed<double>.FromUsSurveyFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromYardsPerHour(UnitsNet.QuantityValue)" />
-        public static Speed YardsPerHour<T>(this T value) =>
-            Speed.FromYardsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromYardsPerHour(T)" />
+        public static Speed<double> YardsPerHour<T>(this T value) =>
+            Speed<double>.FromYardsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromYardsPerMinute(UnitsNet.QuantityValue)" />
-        public static Speed YardsPerMinute<T>(this T value) =>
-            Speed.FromYardsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromYardsPerMinute(T)" />
+        public static Speed<double> YardsPerMinute<T>(this T value) =>
+            Speed<double>.FromYardsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromYardsPerSecond(UnitsNet.QuantityValue)" />
-        public static Speed YardsPerSecond<T>(this T value) =>
-            Speed.FromYardsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="Speed{T}.FromYardsPerSecond(T)" />
+        public static Speed<double> YardsPerSecond<T>(this T value) =>
+            Speed<double>.FromYardsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
index e4def9ea99..2168ad589c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
@@ -28,45 +28,45 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureChangeRate
     /// </summary>
     public static class NumberToTemperatureChangeRateExtensions
     {
-        /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate CentidegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromCentidegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> CentidegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromCentidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate DecadegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromDecadegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> DecadegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromDecadegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate DecidegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromDecidegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> DecidegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromDecidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate DegreesCelsiusPerMinute<T>(this T value) =>
-            TemperatureChangeRate.FromDegreesCelsiusPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromDegreesCelsiusPerMinute(T)" />
+        public static TemperatureChangeRate<double> DegreesCelsiusPerMinute<T>(this T value) =>
+            TemperatureChangeRate<double>.FromDegreesCelsiusPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate DegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromDegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromDegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> DegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate HectodegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromHectodegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> HectodegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromHectodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate KilodegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromKilodegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> KilodegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromKilodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate MicrodegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromMicrodegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> MicrodegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromMicrodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate MillidegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromMillidegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> MillidegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromMillidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
-        public static TemperatureChangeRate NanodegreesCelsiusPerSecond<T>(this T value) =>
-            TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureChangeRate{T}.FromNanodegreesCelsiusPerSecond(T)" />
+        public static TemperatureChangeRate<double> NanodegreesCelsiusPerSecond<T>(this T value) =>
+            TemperatureChangeRate<double>.FromNanodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
index 408c8afa08..041e53c555 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
@@ -28,41 +28,41 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureDelta
     /// </summary>
     public static class NumberToTemperatureDeltaExtensions
     {
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta DegreesCelsius<T>(this T value) =>
-            TemperatureDelta.FromDegreesCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromDegreesCelsius(T)" />
+        public static TemperatureDelta<double> DegreesCelsius<T>(this T value) =>
+            TemperatureDelta<double>.FromDegreesCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta DegreesDelisle<T>(this T value) =>
-            TemperatureDelta.FromDegreesDelisle(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromDegreesDelisle(T)" />
+        public static TemperatureDelta<double> DegreesDelisle<T>(this T value) =>
+            TemperatureDelta<double>.FromDegreesDelisle(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta DegreesFahrenheit<T>(this T value) =>
-            TemperatureDelta.FromDegreesFahrenheit(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromDegreesFahrenheit(T)" />
+        public static TemperatureDelta<double> DegreesFahrenheit<T>(this T value) =>
+            TemperatureDelta<double>.FromDegreesFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta DegreesNewton<T>(this T value) =>
-            TemperatureDelta.FromDegreesNewton(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromDegreesNewton(T)" />
+        public static TemperatureDelta<double> DegreesNewton<T>(this T value) =>
+            TemperatureDelta<double>.FromDegreesNewton(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta DegreesRankine<T>(this T value) =>
-            TemperatureDelta.FromDegreesRankine(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromDegreesRankine(T)" />
+        public static TemperatureDelta<double> DegreesRankine<T>(this T value) =>
+            TemperatureDelta<double>.FromDegreesRankine(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta DegreesReaumur<T>(this T value) =>
-            TemperatureDelta.FromDegreesReaumur(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromDegreesReaumur(T)" />
+        public static TemperatureDelta<double> DegreesReaumur<T>(this T value) =>
+            TemperatureDelta<double>.FromDegreesReaumur(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta DegreesRoemer<T>(this T value) =>
-            TemperatureDelta.FromDegreesRoemer(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromDegreesRoemer(T)" />
+        public static TemperatureDelta<double> DegreesRoemer<T>(this T value) =>
+            TemperatureDelta<double>.FromDegreesRoemer(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromKelvins(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta Kelvins<T>(this T value) =>
-            TemperatureDelta.FromKelvins(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromKelvins(T)" />
+        public static TemperatureDelta<double> Kelvins<T>(this T value) =>
+            TemperatureDelta<double>.FromKelvins(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromMillidegreesCelsius(UnitsNet.QuantityValue)" />
-        public static TemperatureDelta MillidegreesCelsius<T>(this T value) =>
-            TemperatureDelta.FromMillidegreesCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="TemperatureDelta{T}.FromMillidegreesCelsius(T)" />
+        public static TemperatureDelta<double> MillidegreesCelsius<T>(this T value) =>
+            TemperatureDelta<double>.FromMillidegreesCelsius(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
index 2fed0ca505..6e4e36de2e 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
@@ -28,45 +28,45 @@ namespace UnitsNet.NumberExtensions.NumberToTemperature
     /// </summary>
     public static class NumberToTemperatureExtensions
     {
-        /// <inheritdoc cref="Temperature.FromDegreesCelsius(UnitsNet.QuantityValue)" />
-        public static Temperature DegreesCelsius<T>(this T value) =>
-            Temperature.FromDegreesCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromDegreesCelsius(T)" />
+        public static Temperature<double> DegreesCelsius<T>(this T value) =>
+            Temperature<double>.FromDegreesCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesDelisle(UnitsNet.QuantityValue)" />
-        public static Temperature DegreesDelisle<T>(this T value) =>
-            Temperature.FromDegreesDelisle(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromDegreesDelisle(T)" />
+        public static Temperature<double> DegreesDelisle<T>(this T value) =>
+            Temperature<double>.FromDegreesDelisle(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
-        public static Temperature DegreesFahrenheit<T>(this T value) =>
-            Temperature.FromDegreesFahrenheit(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromDegreesFahrenheit(T)" />
+        public static Temperature<double> DegreesFahrenheit<T>(this T value) =>
+            Temperature<double>.FromDegreesFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesNewton(UnitsNet.QuantityValue)" />
-        public static Temperature DegreesNewton<T>(this T value) =>
-            Temperature.FromDegreesNewton(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromDegreesNewton(T)" />
+        public static Temperature<double> DegreesNewton<T>(this T value) =>
+            Temperature<double>.FromDegreesNewton(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesRankine(UnitsNet.QuantityValue)" />
-        public static Temperature DegreesRankine<T>(this T value) =>
-            Temperature.FromDegreesRankine(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromDegreesRankine(T)" />
+        public static Temperature<double> DegreesRankine<T>(this T value) =>
+            Temperature<double>.FromDegreesRankine(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesReaumur(UnitsNet.QuantityValue)" />
-        public static Temperature DegreesReaumur<T>(this T value) =>
-            Temperature.FromDegreesReaumur(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromDegreesReaumur(T)" />
+        public static Temperature<double> DegreesReaumur<T>(this T value) =>
+            Temperature<double>.FromDegreesReaumur(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesRoemer(UnitsNet.QuantityValue)" />
-        public static Temperature DegreesRoemer<T>(this T value) =>
-            Temperature.FromDegreesRoemer(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromDegreesRoemer(T)" />
+        public static Temperature<double> DegreesRoemer<T>(this T value) =>
+            Temperature<double>.FromDegreesRoemer(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromKelvins(UnitsNet.QuantityValue)" />
-        public static Temperature Kelvins<T>(this T value) =>
-            Temperature.FromKelvins(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromKelvins(T)" />
+        public static Temperature<double> Kelvins<T>(this T value) =>
+            Temperature<double>.FromKelvins(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromMillidegreesCelsius(UnitsNet.QuantityValue)" />
-        public static Temperature MillidegreesCelsius<T>(this T value) =>
-            Temperature.FromMillidegreesCelsius(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromMillidegreesCelsius(T)" />
+        public static Temperature<double> MillidegreesCelsius<T>(this T value) =>
+            Temperature<double>.FromMillidegreesCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromSolarTemperatures(UnitsNet.QuantityValue)" />
-        public static Temperature SolarTemperatures<T>(this T value) =>
-            Temperature.FromSolarTemperatures(Convert.ToDouble(value));
+        /// <inheritdoc cref="Temperature{T}.FromSolarTemperatures(T)" />
+        public static Temperature<double> SolarTemperatures<T>(this T value) =>
+            Temperature<double>.FromSolarTemperatures(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
index be0b76365f..acef4d76f8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
@@ -28,13 +28,13 @@ namespace UnitsNet.NumberExtensions.NumberToThermalConductivity
     /// </summary>
     public static class NumberToThermalConductivityExtensions
     {
-        /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(UnitsNet.QuantityValue)" />
-        public static ThermalConductivity BtusPerHourFootFahrenheit<T>(this T value) =>
-            ThermalConductivity.FromBtusPerHourFootFahrenheit(Convert.ToDouble(value));
+        /// <inheritdoc cref="ThermalConductivity{T}.FromBtusPerHourFootFahrenheit(T)" />
+        public static ThermalConductivity<double> BtusPerHourFootFahrenheit<T>(this T value) =>
+            ThermalConductivity<double>.FromBtusPerHourFootFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(UnitsNet.QuantityValue)" />
-        public static ThermalConductivity WattsPerMeterKelvin<T>(this T value) =>
-            ThermalConductivity.FromWattsPerMeterKelvin(Convert.ToDouble(value));
+        /// <inheritdoc cref="ThermalConductivity{T}.FromWattsPerMeterKelvin(T)" />
+        public static ThermalConductivity<double> WattsPerMeterKelvin<T>(this T value) =>
+            ThermalConductivity<double>.FromWattsPerMeterKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
index f3400c139d..b25d5153bd 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
@@ -28,25 +28,25 @@ namespace UnitsNet.NumberExtensions.NumberToThermalResistance
     /// </summary>
     public static class NumberToThermalResistanceExtensions
     {
-        /// <inheritdoc cref="ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(UnitsNet.QuantityValue)" />
-        public static ThermalResistance HourSquareFeetDegreesFahrenheitPerBtu<T>(this T value) =>
-            ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(Convert.ToDouble(value));
+        /// <inheritdoc cref="ThermalResistance{T}.FromHourSquareFeetDegreesFahrenheitPerBtu(T)" />
+        public static ThermalResistance<double> HourSquareFeetDegreesFahrenheitPerBtu<T>(this T value) =>
+            ThermalResistance<double>.FromHourSquareFeetDegreesFahrenheitPerBtu(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(UnitsNet.QuantityValue)" />
-        public static ThermalResistance SquareCentimeterHourDegreesCelsiusPerKilocalorie<T>(this T value) =>
-            ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(Convert.ToDouble(value));
+        /// <inheritdoc cref="ThermalResistance{T}.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(T)" />
+        public static ThermalResistance<double> SquareCentimeterHourDegreesCelsiusPerKilocalorie<T>(this T value) =>
+            ThermalResistance<double>.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterKelvinsPerWatt(UnitsNet.QuantityValue)" />
-        public static ThermalResistance SquareCentimeterKelvinsPerWatt<T>(this T value) =>
-            ThermalResistance.FromSquareCentimeterKelvinsPerWatt(Convert.ToDouble(value));
+        /// <inheritdoc cref="ThermalResistance{T}.FromSquareCentimeterKelvinsPerWatt(T)" />
+        public static ThermalResistance<double> SquareCentimeterKelvinsPerWatt<T>(this T value) =>
+            ThermalResistance<double>.FromSquareCentimeterKelvinsPerWatt(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(UnitsNet.QuantityValue)" />
-        public static ThermalResistance SquareMeterDegreesCelsiusPerWatt<T>(this T value) =>
-            ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(Convert.ToDouble(value));
+        /// <inheritdoc cref="ThermalResistance{T}.FromSquareMeterDegreesCelsiusPerWatt(T)" />
+        public static ThermalResistance<double> SquareMeterDegreesCelsiusPerWatt<T>(this T value) =>
+            ThermalResistance<double>.FromSquareMeterDegreesCelsiusPerWatt(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareMeterKelvinsPerKilowatt(UnitsNet.QuantityValue)" />
-        public static ThermalResistance SquareMeterKelvinsPerKilowatt<T>(this T value) =>
-            ThermalResistance.FromSquareMeterKelvinsPerKilowatt(Convert.ToDouble(value));
+        /// <inheritdoc cref="ThermalResistance{T}.FromSquareMeterKelvinsPerKilowatt(T)" />
+        public static ThermalResistance<double> SquareMeterKelvinsPerKilowatt<T>(this T value) =>
+            ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
index 70ae1052d2..f04375db8d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
@@ -28,93 +28,93 @@ namespace UnitsNet.NumberExtensions.NumberToTorque
     /// </summary>
     public static class NumberToTorqueExtensions
     {
-        /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(UnitsNet.QuantityValue)" />
-        public static Torque KilogramForceCentimeters<T>(this T value) =>
-            Torque.FromKilogramForceCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilogramForceCentimeters(T)" />
+        public static Torque<double> KilogramForceCentimeters<T>(this T value) =>
+            Torque<double>.FromKilogramForceCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilogramForceMeters(UnitsNet.QuantityValue)" />
-        public static Torque KilogramForceMeters<T>(this T value) =>
-            Torque.FromKilogramForceMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilogramForceMeters(T)" />
+        public static Torque<double> KilogramForceMeters<T>(this T value) =>
+            Torque<double>.FromKilogramForceMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(UnitsNet.QuantityValue)" />
-        public static Torque KilogramForceMillimeters<T>(this T value) =>
-            Torque.FromKilogramForceMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilogramForceMillimeters(T)" />
+        public static Torque<double> KilogramForceMillimeters<T>(this T value) =>
+            Torque<double>.FromKilogramForceMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(UnitsNet.QuantityValue)" />
-        public static Torque KilonewtonCentimeters<T>(this T value) =>
-            Torque.FromKilonewtonCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilonewtonCentimeters(T)" />
+        public static Torque<double> KilonewtonCentimeters<T>(this T value) =>
+            Torque<double>.FromKilonewtonCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilonewtonMeters(UnitsNet.QuantityValue)" />
-        public static Torque KilonewtonMeters<T>(this T value) =>
-            Torque.FromKilonewtonMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilonewtonMeters(T)" />
+        public static Torque<double> KilonewtonMeters<T>(this T value) =>
+            Torque<double>.FromKilonewtonMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(UnitsNet.QuantityValue)" />
-        public static Torque KilonewtonMillimeters<T>(this T value) =>
-            Torque.FromKilonewtonMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilonewtonMillimeters(T)" />
+        public static Torque<double> KilonewtonMillimeters<T>(this T value) =>
+            Torque<double>.FromKilonewtonMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilopoundForceFeet(UnitsNet.QuantityValue)" />
-        public static Torque KilopoundForceFeet<T>(this T value) =>
-            Torque.FromKilopoundForceFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilopoundForceFeet(T)" />
+        public static Torque<double> KilopoundForceFeet<T>(this T value) =>
+            Torque<double>.FromKilopoundForceFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilopoundForceInches(UnitsNet.QuantityValue)" />
-        public static Torque KilopoundForceInches<T>(this T value) =>
-            Torque.FromKilopoundForceInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromKilopoundForceInches(T)" />
+        public static Torque<double> KilopoundForceInches<T>(this T value) =>
+            Torque<double>.FromKilopoundForceInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(UnitsNet.QuantityValue)" />
-        public static Torque MeganewtonCentimeters<T>(this T value) =>
-            Torque.FromMeganewtonCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromMeganewtonCentimeters(T)" />
+        public static Torque<double> MeganewtonCentimeters<T>(this T value) =>
+            Torque<double>.FromMeganewtonCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMeganewtonMeters(UnitsNet.QuantityValue)" />
-        public static Torque MeganewtonMeters<T>(this T value) =>
-            Torque.FromMeganewtonMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromMeganewtonMeters(T)" />
+        public static Torque<double> MeganewtonMeters<T>(this T value) =>
+            Torque<double>.FromMeganewtonMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(UnitsNet.QuantityValue)" />
-        public static Torque MeganewtonMillimeters<T>(this T value) =>
-            Torque.FromMeganewtonMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromMeganewtonMillimeters(T)" />
+        public static Torque<double> MeganewtonMillimeters<T>(this T value) =>
+            Torque<double>.FromMeganewtonMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMegapoundForceFeet(UnitsNet.QuantityValue)" />
-        public static Torque MegapoundForceFeet<T>(this T value) =>
-            Torque.FromMegapoundForceFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromMegapoundForceFeet(T)" />
+        public static Torque<double> MegapoundForceFeet<T>(this T value) =>
+            Torque<double>.FromMegapoundForceFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMegapoundForceInches(UnitsNet.QuantityValue)" />
-        public static Torque MegapoundForceInches<T>(this T value) =>
-            Torque.FromMegapoundForceInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromMegapoundForceInches(T)" />
+        public static Torque<double> MegapoundForceInches<T>(this T value) =>
+            Torque<double>.FromMegapoundForceInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromNewtonCentimeters(UnitsNet.QuantityValue)" />
-        public static Torque NewtonCentimeters<T>(this T value) =>
-            Torque.FromNewtonCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromNewtonCentimeters(T)" />
+        public static Torque<double> NewtonCentimeters<T>(this T value) =>
+            Torque<double>.FromNewtonCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromNewtonMeters(UnitsNet.QuantityValue)" />
-        public static Torque NewtonMeters<T>(this T value) =>
-            Torque.FromNewtonMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromNewtonMeters(T)" />
+        public static Torque<double> NewtonMeters<T>(this T value) =>
+            Torque<double>.FromNewtonMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromNewtonMillimeters(UnitsNet.QuantityValue)" />
-        public static Torque NewtonMillimeters<T>(this T value) =>
-            Torque.FromNewtonMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromNewtonMillimeters(T)" />
+        public static Torque<double> NewtonMillimeters<T>(this T value) =>
+            Torque<double>.FromNewtonMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromPoundalFeet(UnitsNet.QuantityValue)" />
-        public static Torque PoundalFeet<T>(this T value) =>
-            Torque.FromPoundalFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromPoundalFeet(T)" />
+        public static Torque<double> PoundalFeet<T>(this T value) =>
+            Torque<double>.FromPoundalFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromPoundForceFeet(UnitsNet.QuantityValue)" />
-        public static Torque PoundForceFeet<T>(this T value) =>
-            Torque.FromPoundForceFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromPoundForceFeet(T)" />
+        public static Torque<double> PoundForceFeet<T>(this T value) =>
+            Torque<double>.FromPoundForceFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromPoundForceInches(UnitsNet.QuantityValue)" />
-        public static Torque PoundForceInches<T>(this T value) =>
-            Torque.FromPoundForceInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromPoundForceInches(T)" />
+        public static Torque<double> PoundForceInches<T>(this T value) =>
+            Torque<double>.FromPoundForceInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromTonneForceCentimeters(UnitsNet.QuantityValue)" />
-        public static Torque TonneForceCentimeters<T>(this T value) =>
-            Torque.FromTonneForceCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromTonneForceCentimeters(T)" />
+        public static Torque<double> TonneForceCentimeters<T>(this T value) =>
+            Torque<double>.FromTonneForceCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromTonneForceMeters(UnitsNet.QuantityValue)" />
-        public static Torque TonneForceMeters<T>(this T value) =>
-            Torque.FromTonneForceMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromTonneForceMeters(T)" />
+        public static Torque<double> TonneForceMeters<T>(this T value) =>
+            Torque<double>.FromTonneForceMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromTonneForceMillimeters(UnitsNet.QuantityValue)" />
-        public static Torque TonneForceMillimeters<T>(this T value) =>
-            Torque.FromTonneForceMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Torque{T}.FromTonneForceMillimeters(T)" />
+        public static Torque<double> TonneForceMillimeters<T>(this T value) =>
+            Torque<double>.FromTonneForceMillimeters(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
index a6d4151882..d381209adf 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
@@ -28,89 +28,89 @@ namespace UnitsNet.NumberExtensions.NumberToTorquePerLength
     /// </summary>
     public static class NumberToTorquePerLengthExtensions
     {
-        /// <inheritdoc cref="TorquePerLength.FromKilogramForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilogramForceCentimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromKilogramForceCentimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilogramForceCentimetersPerMeter(T)" />
+        public static TorquePerLength<double> KilogramForceCentimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromKilogramForceCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilogramForceMetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromKilogramForceMetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilogramForceMetersPerMeter(T)" />
+        public static TorquePerLength<double> KilogramForceMetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromKilogramForceMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilogramForceMillimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromKilogramForceMillimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilogramForceMillimetersPerMeter(T)" />
+        public static TorquePerLength<double> KilogramForceMillimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromKilogramForceMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilonewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilonewtonCentimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromKilonewtonCentimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilonewtonCentimetersPerMeter(T)" />
+        public static TorquePerLength<double> KilonewtonCentimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromKilonewtonCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilonewtonMetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromKilonewtonMetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilonewtonMetersPerMeter(T)" />
+        public static TorquePerLength<double> KilonewtonMetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromKilonewtonMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilonewtonMillimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromKilonewtonMillimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilonewtonMillimetersPerMeter(T)" />
+        public static TorquePerLength<double> KilonewtonMillimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromKilonewtonMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilopoundForceFeetPerFoot<T>(this T value) =>
-            TorquePerLength.FromKilopoundForceFeetPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilopoundForceFeetPerFoot(T)" />
+        public static TorquePerLength<double> KilopoundForceFeetPerFoot<T>(this T value) =>
+            TorquePerLength<double>.FromKilopoundForceFeetPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
-        public static TorquePerLength KilopoundForceInchesPerFoot<T>(this T value) =>
-            TorquePerLength.FromKilopoundForceInchesPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromKilopoundForceInchesPerFoot(T)" />
+        public static TorquePerLength<double> KilopoundForceInchesPerFoot<T>(this T value) =>
+            TorquePerLength<double>.FromKilopoundForceInchesPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMeganewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength MeganewtonCentimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromMeganewtonCentimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromMeganewtonCentimetersPerMeter(T)" />
+        public static TorquePerLength<double> MeganewtonCentimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromMeganewtonCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength MeganewtonMetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromMeganewtonMetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromMeganewtonMetersPerMeter(T)" />
+        public static TorquePerLength<double> MeganewtonMetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromMeganewtonMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength MeganewtonMillimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromMeganewtonMillimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromMeganewtonMillimetersPerMeter(T)" />
+        public static TorquePerLength<double> MeganewtonMillimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromMeganewtonMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
-        public static TorquePerLength MegapoundForceFeetPerFoot<T>(this T value) =>
-            TorquePerLength.FromMegapoundForceFeetPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromMegapoundForceFeetPerFoot(T)" />
+        public static TorquePerLength<double> MegapoundForceFeetPerFoot<T>(this T value) =>
+            TorquePerLength<double>.FromMegapoundForceFeetPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
-        public static TorquePerLength MegapoundForceInchesPerFoot<T>(this T value) =>
-            TorquePerLength.FromMegapoundForceInchesPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromMegapoundForceInchesPerFoot(T)" />
+        public static TorquePerLength<double> MegapoundForceInchesPerFoot<T>(this T value) =>
+            TorquePerLength<double>.FromMegapoundForceInchesPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromNewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength NewtonCentimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromNewtonCentimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromNewtonCentimetersPerMeter(T)" />
+        public static TorquePerLength<double> NewtonCentimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromNewtonCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromNewtonMetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength NewtonMetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromNewtonMetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromNewtonMetersPerMeter(T)" />
+        public static TorquePerLength<double> NewtonMetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromNewtonMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromNewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength NewtonMillimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromNewtonMillimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromNewtonMillimetersPerMeter(T)" />
+        public static TorquePerLength<double> NewtonMillimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromNewtonMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromPoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
-        public static TorquePerLength PoundForceFeetPerFoot<T>(this T value) =>
-            TorquePerLength.FromPoundForceFeetPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromPoundForceFeetPerFoot(T)" />
+        public static TorquePerLength<double> PoundForceFeetPerFoot<T>(this T value) =>
+            TorquePerLength<double>.FromPoundForceFeetPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromPoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
-        public static TorquePerLength PoundForceInchesPerFoot<T>(this T value) =>
-            TorquePerLength.FromPoundForceInchesPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromPoundForceInchesPerFoot(T)" />
+        public static TorquePerLength<double> PoundForceInchesPerFoot<T>(this T value) =>
+            TorquePerLength<double>.FromPoundForceInchesPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromTonneForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength TonneForceCentimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromTonneForceCentimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromTonneForceCentimetersPerMeter(T)" />
+        public static TorquePerLength<double> TonneForceCentimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromTonneForceCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromTonneForceMetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength TonneForceMetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromTonneForceMetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromTonneForceMetersPerMeter(T)" />
+        public static TorquePerLength<double> TonneForceMetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromTonneForceMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromTonneForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
-        public static TorquePerLength TonneForceMillimetersPerMeter<T>(this T value) =>
-            TorquePerLength.FromTonneForceMillimetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="TorquePerLength{T}.FromTonneForceMillimetersPerMeter(T)" />
+        public static TorquePerLength<double> TonneForceMillimetersPerMeter<T>(this T value) =>
+            TorquePerLength<double>.FromTonneForceMillimetersPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
index 0bd9694799..6f94086a1f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToTurbidity
     /// </summary>
     public static class NumberToTurbidityExtensions
     {
-        /// <inheritdoc cref="Turbidity.FromNTU(UnitsNet.QuantityValue)" />
-        public static Turbidity NTU<T>(this T value) =>
-            Turbidity.FromNTU(Convert.ToDouble(value));
+        /// <inheritdoc cref="Turbidity{T}.FromNTU(T)" />
+        public static Turbidity<double> NTU<T>(this T value) =>
+            Turbidity<double>.FromNTU(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
index 8c4683785d..095ebbfe03 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
@@ -28,9 +28,9 @@ namespace UnitsNet.NumberExtensions.NumberToVitaminA
     /// </summary>
     public static class NumberToVitaminAExtensions
     {
-        /// <inheritdoc cref="VitaminA.FromInternationalUnits(UnitsNet.QuantityValue)" />
-        public static VitaminA InternationalUnits<T>(this T value) =>
-            VitaminA.FromInternationalUnits(Convert.ToDouble(value));
+        /// <inheritdoc cref="VitaminA{T}.FromInternationalUnits(T)" />
+        public static VitaminA<double> InternationalUnits<T>(this T value) =>
+            VitaminA<double>.FromInternationalUnits(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
index 456736fb1e..2355d9a8cd 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
@@ -28,85 +28,85 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeConcentration
     /// </summary>
     public static class NumberToVolumeConcentrationExtensions
     {
-        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration CentilitersPerLiter<T>(this T value) =>
-            VolumeConcentration.FromCentilitersPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromCentilitersPerLiter(T)" />
+        public static VolumeConcentration<double> CentilitersPerLiter<T>(this T value) =>
+            VolumeConcentration<double>.FromCentilitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMililiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration CentilitersPerMililiter<T>(this T value) =>
-            VolumeConcentration.FromCentilitersPerMililiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromCentilitersPerMililiter(T)" />
+        public static VolumeConcentration<double> CentilitersPerMililiter<T>(this T value) =>
+            VolumeConcentration<double>.FromCentilitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration DecilitersPerLiter<T>(this T value) =>
-            VolumeConcentration.FromDecilitersPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromDecilitersPerLiter(T)" />
+        public static VolumeConcentration<double> DecilitersPerLiter<T>(this T value) =>
+            VolumeConcentration<double>.FromDecilitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMililiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration DecilitersPerMililiter<T>(this T value) =>
-            VolumeConcentration.FromDecilitersPerMililiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromDecilitersPerMililiter(T)" />
+        public static VolumeConcentration<double> DecilitersPerMililiter<T>(this T value) =>
+            VolumeConcentration<double>.FromDecilitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration DecimalFractions<T>(this T value) =>
-            VolumeConcentration.FromDecimalFractions(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromDecimalFractions(T)" />
+        public static VolumeConcentration<double> DecimalFractions<T>(this T value) =>
+            VolumeConcentration<double>.FromDecimalFractions(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration LitersPerLiter<T>(this T value) =>
-            VolumeConcentration.FromLitersPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromLitersPerLiter(T)" />
+        public static VolumeConcentration<double> LitersPerLiter<T>(this T value) =>
+            VolumeConcentration<double>.FromLitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromLitersPerMililiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration LitersPerMililiter<T>(this T value) =>
-            VolumeConcentration.FromLitersPerMililiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromLitersPerMililiter(T)" />
+        public static VolumeConcentration<double> LitersPerMililiter<T>(this T value) =>
+            VolumeConcentration<double>.FromLitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration MicrolitersPerLiter<T>(this T value) =>
-            VolumeConcentration.FromMicrolitersPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromMicrolitersPerLiter(T)" />
+        public static VolumeConcentration<double> MicrolitersPerLiter<T>(this T value) =>
+            VolumeConcentration<double>.FromMicrolitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMililiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration MicrolitersPerMililiter<T>(this T value) =>
-            VolumeConcentration.FromMicrolitersPerMililiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromMicrolitersPerMililiter(T)" />
+        public static VolumeConcentration<double> MicrolitersPerMililiter<T>(this T value) =>
+            VolumeConcentration<double>.FromMicrolitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration MillilitersPerLiter<T>(this T value) =>
-            VolumeConcentration.FromMillilitersPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromMillilitersPerLiter(T)" />
+        public static VolumeConcentration<double> MillilitersPerLiter<T>(this T value) =>
+            VolumeConcentration<double>.FromMillilitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMililiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration MillilitersPerMililiter<T>(this T value) =>
-            VolumeConcentration.FromMillilitersPerMililiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromMillilitersPerMililiter(T)" />
+        public static VolumeConcentration<double> MillilitersPerMililiter<T>(this T value) =>
+            VolumeConcentration<double>.FromMillilitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration NanolitersPerLiter<T>(this T value) =>
-            VolumeConcentration.FromNanolitersPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromNanolitersPerLiter(T)" />
+        public static VolumeConcentration<double> NanolitersPerLiter<T>(this T value) =>
+            VolumeConcentration<double>.FromNanolitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMililiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration NanolitersPerMililiter<T>(this T value) =>
-            VolumeConcentration.FromNanolitersPerMililiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromNanolitersPerMililiter(T)" />
+        public static VolumeConcentration<double> NanolitersPerMililiter<T>(this T value) =>
+            VolumeConcentration<double>.FromNanolitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration PartsPerBillion<T>(this T value) =>
-            VolumeConcentration.FromPartsPerBillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromPartsPerBillion(T)" />
+        public static VolumeConcentration<double> PartsPerBillion<T>(this T value) =>
+            VolumeConcentration<double>.FromPartsPerBillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration PartsPerMillion<T>(this T value) =>
-            VolumeConcentration.FromPartsPerMillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromPartsPerMillion(T)" />
+        public static VolumeConcentration<double> PartsPerMillion<T>(this T value) =>
+            VolumeConcentration<double>.FromPartsPerMillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration PartsPerThousand<T>(this T value) =>
-            VolumeConcentration.FromPartsPerThousand(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromPartsPerThousand(T)" />
+        public static VolumeConcentration<double> PartsPerThousand<T>(this T value) =>
+            VolumeConcentration<double>.FromPartsPerThousand(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration PartsPerTrillion<T>(this T value) =>
-            VolumeConcentration.FromPartsPerTrillion(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromPartsPerTrillion(T)" />
+        public static VolumeConcentration<double> PartsPerTrillion<T>(this T value) =>
+            VolumeConcentration<double>.FromPartsPerTrillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPercent(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration Percent<T>(this T value) =>
-            VolumeConcentration.FromPercent(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromPercent(T)" />
+        public static VolumeConcentration<double> Percent<T>(this T value) =>
+            VolumeConcentration<double>.FromPercent(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration PicolitersPerLiter<T>(this T value) =>
-            VolumeConcentration.FromPicolitersPerLiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromPicolitersPerLiter(T)" />
+        public static VolumeConcentration<double> PicolitersPerLiter<T>(this T value) =>
+            VolumeConcentration<double>.FromPicolitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMililiter(UnitsNet.QuantityValue)" />
-        public static VolumeConcentration PicolitersPerMililiter<T>(this T value) =>
-            VolumeConcentration.FromPicolitersPerMililiter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeConcentration{T}.FromPicolitersPerMililiter(T)" />
+        public static VolumeConcentration<double> PicolitersPerMililiter<T>(this T value) =>
+            VolumeConcentration<double>.FromPicolitersPerMililiter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
index a9c12ad65f..eca99271aa 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
@@ -28,209 +28,209 @@ namespace UnitsNet.NumberExtensions.NumberToVolume
     /// </summary>
     public static class NumberToVolumeExtensions
     {
-        /// <inheritdoc cref="Volume.FromAcreFeet(UnitsNet.QuantityValue)" />
-        public static Volume AcreFeet<T>(this T value) =>
-            Volume.FromAcreFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromAcreFeet(T)" />
+        public static Volume<double> AcreFeet<T>(this T value) =>
+            Volume<double>.FromAcreFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromAuTablespoons(UnitsNet.QuantityValue)" />
-        public static Volume AuTablespoons<T>(this T value) =>
-            Volume.FromAuTablespoons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromAuTablespoons(T)" />
+        public static Volume<double> AuTablespoons<T>(this T value) =>
+            Volume<double>.FromAuTablespoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromBoardFeet(UnitsNet.QuantityValue)" />
-        public static Volume BoardFeet<T>(this T value) =>
-            Volume.FromBoardFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromBoardFeet(T)" />
+        public static Volume<double> BoardFeet<T>(this T value) =>
+            Volume<double>.FromBoardFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCentiliters(UnitsNet.QuantityValue)" />
-        public static Volume Centiliters<T>(this T value) =>
-            Volume.FromCentiliters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCentiliters(T)" />
+        public static Volume<double> Centiliters<T>(this T value) =>
+            Volume<double>.FromCentiliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicCentimeters(UnitsNet.QuantityValue)" />
-        public static Volume CubicCentimeters<T>(this T value) =>
-            Volume.FromCubicCentimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicCentimeters(T)" />
+        public static Volume<double> CubicCentimeters<T>(this T value) =>
+            Volume<double>.FromCubicCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicDecimeters(UnitsNet.QuantityValue)" />
-        public static Volume CubicDecimeters<T>(this T value) =>
-            Volume.FromCubicDecimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicDecimeters(T)" />
+        public static Volume<double> CubicDecimeters<T>(this T value) =>
+            Volume<double>.FromCubicDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicFeet(UnitsNet.QuantityValue)" />
-        public static Volume CubicFeet<T>(this T value) =>
-            Volume.FromCubicFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicFeet(T)" />
+        public static Volume<double> CubicFeet<T>(this T value) =>
+            Volume<double>.FromCubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicHectometers(UnitsNet.QuantityValue)" />
-        public static Volume CubicHectometers<T>(this T value) =>
-            Volume.FromCubicHectometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicHectometers(T)" />
+        public static Volume<double> CubicHectometers<T>(this T value) =>
+            Volume<double>.FromCubicHectometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicInches(UnitsNet.QuantityValue)" />
-        public static Volume CubicInches<T>(this T value) =>
-            Volume.FromCubicInches(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicInches(T)" />
+        public static Volume<double> CubicInches<T>(this T value) =>
+            Volume<double>.FromCubicInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicKilometers(UnitsNet.QuantityValue)" />
-        public static Volume CubicKilometers<T>(this T value) =>
-            Volume.FromCubicKilometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicKilometers(T)" />
+        public static Volume<double> CubicKilometers<T>(this T value) =>
+            Volume<double>.FromCubicKilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMeters(UnitsNet.QuantityValue)" />
-        public static Volume CubicMeters<T>(this T value) =>
-            Volume.FromCubicMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicMeters(T)" />
+        public static Volume<double> CubicMeters<T>(this T value) =>
+            Volume<double>.FromCubicMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMicrometers(UnitsNet.QuantityValue)" />
-        public static Volume CubicMicrometers<T>(this T value) =>
-            Volume.FromCubicMicrometers(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicMicrometers(T)" />
+        public static Volume<double> CubicMicrometers<T>(this T value) =>
+            Volume<double>.FromCubicMicrometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMiles(UnitsNet.QuantityValue)" />
-        public static Volume CubicMiles<T>(this T value) =>
-            Volume.FromCubicMiles(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicMiles(T)" />
+        public static Volume<double> CubicMiles<T>(this T value) =>
+            Volume<double>.FromCubicMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMillimeters(UnitsNet.QuantityValue)" />
-        public static Volume CubicMillimeters<T>(this T value) =>
-            Volume.FromCubicMillimeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicMillimeters(T)" />
+        public static Volume<double> CubicMillimeters<T>(this T value) =>
+            Volume<double>.FromCubicMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicYards(UnitsNet.QuantityValue)" />
-        public static Volume CubicYards<T>(this T value) =>
-            Volume.FromCubicYards(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromCubicYards(T)" />
+        public static Volume<double> CubicYards<T>(this T value) =>
+            Volume<double>.FromCubicYards(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromDecausGallons(UnitsNet.QuantityValue)" />
-        public static Volume DecausGallons<T>(this T value) =>
-            Volume.FromDecausGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromDecausGallons(T)" />
+        public static Volume<double> DecausGallons<T>(this T value) =>
+            Volume<double>.FromDecausGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromDeciliters(UnitsNet.QuantityValue)" />
-        public static Volume Deciliters<T>(this T value) =>
-            Volume.FromDeciliters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromDeciliters(T)" />
+        public static Volume<double> Deciliters<T>(this T value) =>
+            Volume<double>.FromDeciliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromDeciusGallons(UnitsNet.QuantityValue)" />
-        public static Volume DeciusGallons<T>(this T value) =>
-            Volume.FromDeciusGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromDeciusGallons(T)" />
+        public static Volume<double> DeciusGallons<T>(this T value) =>
+            Volume<double>.FromDeciusGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectocubicFeet(UnitsNet.QuantityValue)" />
-        public static Volume HectocubicFeet<T>(this T value) =>
-            Volume.FromHectocubicFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromHectocubicFeet(T)" />
+        public static Volume<double> HectocubicFeet<T>(this T value) =>
+            Volume<double>.FromHectocubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectocubicMeters(UnitsNet.QuantityValue)" />
-        public static Volume HectocubicMeters<T>(this T value) =>
-            Volume.FromHectocubicMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromHectocubicMeters(T)" />
+        public static Volume<double> HectocubicMeters<T>(this T value) =>
+            Volume<double>.FromHectocubicMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectoliters(UnitsNet.QuantityValue)" />
-        public static Volume Hectoliters<T>(this T value) =>
-            Volume.FromHectoliters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromHectoliters(T)" />
+        public static Volume<double> Hectoliters<T>(this T value) =>
+            Volume<double>.FromHectoliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectousGallons(UnitsNet.QuantityValue)" />
-        public static Volume HectousGallons<T>(this T value) =>
-            Volume.FromHectousGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromHectousGallons(T)" />
+        public static Volume<double> HectousGallons<T>(this T value) =>
+            Volume<double>.FromHectousGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialBeerBarrels(UnitsNet.QuantityValue)" />
-        public static Volume ImperialBeerBarrels<T>(this T value) =>
-            Volume.FromImperialBeerBarrels(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromImperialBeerBarrels(T)" />
+        public static Volume<double> ImperialBeerBarrels<T>(this T value) =>
+            Volume<double>.FromImperialBeerBarrels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialGallons(UnitsNet.QuantityValue)" />
-        public static Volume ImperialGallons<T>(this T value) =>
-            Volume.FromImperialGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromImperialGallons(T)" />
+        public static Volume<double> ImperialGallons<T>(this T value) =>
+            Volume<double>.FromImperialGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialOunces(UnitsNet.QuantityValue)" />
-        public static Volume ImperialOunces<T>(this T value) =>
-            Volume.FromImperialOunces(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromImperialOunces(T)" />
+        public static Volume<double> ImperialOunces<T>(this T value) =>
+            Volume<double>.FromImperialOunces(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialPints(UnitsNet.QuantityValue)" />
-        public static Volume ImperialPints<T>(this T value) =>
-            Volume.FromImperialPints(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromImperialPints(T)" />
+        public static Volume<double> ImperialPints<T>(this T value) =>
+            Volume<double>.FromImperialPints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKilocubicFeet(UnitsNet.QuantityValue)" />
-        public static Volume KilocubicFeet<T>(this T value) =>
-            Volume.FromKilocubicFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromKilocubicFeet(T)" />
+        public static Volume<double> KilocubicFeet<T>(this T value) =>
+            Volume<double>.FromKilocubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKilocubicMeters(UnitsNet.QuantityValue)" />
-        public static Volume KilocubicMeters<T>(this T value) =>
-            Volume.FromKilocubicMeters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromKilocubicMeters(T)" />
+        public static Volume<double> KilocubicMeters<T>(this T value) =>
+            Volume<double>.FromKilocubicMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKiloimperialGallons(UnitsNet.QuantityValue)" />
-        public static Volume KiloimperialGallons<T>(this T value) =>
-            Volume.FromKiloimperialGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromKiloimperialGallons(T)" />
+        public static Volume<double> KiloimperialGallons<T>(this T value) =>
+            Volume<double>.FromKiloimperialGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKiloliters(UnitsNet.QuantityValue)" />
-        public static Volume Kiloliters<T>(this T value) =>
-            Volume.FromKiloliters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromKiloliters(T)" />
+        public static Volume<double> Kiloliters<T>(this T value) =>
+            Volume<double>.FromKiloliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKilousGallons(UnitsNet.QuantityValue)" />
-        public static Volume KilousGallons<T>(this T value) =>
-            Volume.FromKilousGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromKilousGallons(T)" />
+        public static Volume<double> KilousGallons<T>(this T value) =>
+            Volume<double>.FromKilousGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromLiters(UnitsNet.QuantityValue)" />
-        public static Volume Liters<T>(this T value) =>
-            Volume.FromLiters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromLiters(T)" />
+        public static Volume<double> Liters<T>(this T value) =>
+            Volume<double>.FromLiters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegacubicFeet(UnitsNet.QuantityValue)" />
-        public static Volume MegacubicFeet<T>(this T value) =>
-            Volume.FromMegacubicFeet(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMegacubicFeet(T)" />
+        public static Volume<double> MegacubicFeet<T>(this T value) =>
+            Volume<double>.FromMegacubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegaimperialGallons(UnitsNet.QuantityValue)" />
-        public static Volume MegaimperialGallons<T>(this T value) =>
-            Volume.FromMegaimperialGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMegaimperialGallons(T)" />
+        public static Volume<double> MegaimperialGallons<T>(this T value) =>
+            Volume<double>.FromMegaimperialGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegaliters(UnitsNet.QuantityValue)" />
-        public static Volume Megaliters<T>(this T value) =>
-            Volume.FromMegaliters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMegaliters(T)" />
+        public static Volume<double> Megaliters<T>(this T value) =>
+            Volume<double>.FromMegaliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegausGallons(UnitsNet.QuantityValue)" />
-        public static Volume MegausGallons<T>(this T value) =>
-            Volume.FromMegausGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMegausGallons(T)" />
+        public static Volume<double> MegausGallons<T>(this T value) =>
+            Volume<double>.FromMegausGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMetricCups(UnitsNet.QuantityValue)" />
-        public static Volume MetricCups<T>(this T value) =>
-            Volume.FromMetricCups(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMetricCups(T)" />
+        public static Volume<double> MetricCups<T>(this T value) =>
+            Volume<double>.FromMetricCups(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMetricTeaspoons(UnitsNet.QuantityValue)" />
-        public static Volume MetricTeaspoons<T>(this T value) =>
-            Volume.FromMetricTeaspoons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMetricTeaspoons(T)" />
+        public static Volume<double> MetricTeaspoons<T>(this T value) =>
+            Volume<double>.FromMetricTeaspoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMicroliters(UnitsNet.QuantityValue)" />
-        public static Volume Microliters<T>(this T value) =>
-            Volume.FromMicroliters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMicroliters(T)" />
+        public static Volume<double> Microliters<T>(this T value) =>
+            Volume<double>.FromMicroliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMilliliters(UnitsNet.QuantityValue)" />
-        public static Volume Milliliters<T>(this T value) =>
-            Volume.FromMilliliters(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromMilliliters(T)" />
+        public static Volume<double> Milliliters<T>(this T value) =>
+            Volume<double>.FromMilliliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromOilBarrels(UnitsNet.QuantityValue)" />
-        public static Volume OilBarrels<T>(this T value) =>
-            Volume.FromOilBarrels(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromOilBarrels(T)" />
+        public static Volume<double> OilBarrels<T>(this T value) =>
+            Volume<double>.FromOilBarrels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUkTablespoons(UnitsNet.QuantityValue)" />
-        public static Volume UkTablespoons<T>(this T value) =>
-            Volume.FromUkTablespoons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUkTablespoons(T)" />
+        public static Volume<double> UkTablespoons<T>(this T value) =>
+            Volume<double>.FromUkTablespoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsBeerBarrels(UnitsNet.QuantityValue)" />
-        public static Volume UsBeerBarrels<T>(this T value) =>
-            Volume.FromUsBeerBarrels(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsBeerBarrels(T)" />
+        public static Volume<double> UsBeerBarrels<T>(this T value) =>
+            Volume<double>.FromUsBeerBarrels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsCustomaryCups(UnitsNet.QuantityValue)" />
-        public static Volume UsCustomaryCups<T>(this T value) =>
-            Volume.FromUsCustomaryCups(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsCustomaryCups(T)" />
+        public static Volume<double> UsCustomaryCups<T>(this T value) =>
+            Volume<double>.FromUsCustomaryCups(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsGallons(UnitsNet.QuantityValue)" />
-        public static Volume UsGallons<T>(this T value) =>
-            Volume.FromUsGallons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsGallons(T)" />
+        public static Volume<double> UsGallons<T>(this T value) =>
+            Volume<double>.FromUsGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsLegalCups(UnitsNet.QuantityValue)" />
-        public static Volume UsLegalCups<T>(this T value) =>
-            Volume.FromUsLegalCups(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsLegalCups(T)" />
+        public static Volume<double> UsLegalCups<T>(this T value) =>
+            Volume<double>.FromUsLegalCups(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsOunces(UnitsNet.QuantityValue)" />
-        public static Volume UsOunces<T>(this T value) =>
-            Volume.FromUsOunces(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsOunces(T)" />
+        public static Volume<double> UsOunces<T>(this T value) =>
+            Volume<double>.FromUsOunces(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsPints(UnitsNet.QuantityValue)" />
-        public static Volume UsPints<T>(this T value) =>
-            Volume.FromUsPints(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsPints(T)" />
+        public static Volume<double> UsPints<T>(this T value) =>
+            Volume<double>.FromUsPints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsQuarts(UnitsNet.QuantityValue)" />
-        public static Volume UsQuarts<T>(this T value) =>
-            Volume.FromUsQuarts(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsQuarts(T)" />
+        public static Volume<double> UsQuarts<T>(this T value) =>
+            Volume<double>.FromUsQuarts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsTablespoons(UnitsNet.QuantityValue)" />
-        public static Volume UsTablespoons<T>(this T value) =>
-            Volume.FromUsTablespoons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsTablespoons(T)" />
+        public static Volume<double> UsTablespoons<T>(this T value) =>
+            Volume<double>.FromUsTablespoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsTeaspoons(UnitsNet.QuantityValue)" />
-        public static Volume UsTeaspoons<T>(this T value) =>
-            Volume.FromUsTeaspoons(Convert.ToDouble(value));
+        /// <inheritdoc cref="Volume{T}.FromUsTeaspoons(T)" />
+        public static Volume<double> UsTeaspoons<T>(this T value) =>
+            Volume<double>.FromUsTeaspoons(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
index a0eb2e39f7..3500c082e8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
@@ -28,229 +28,229 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeFlow
     /// </summary>
     public static class NumberToVolumeFlowExtensions
     {
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow AcreFeetPerDay<T>(this T value) =>
-            VolumeFlow.FromAcreFeetPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromAcreFeetPerDay(T)" />
+        public static VolumeFlow<double> AcreFeetPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromAcreFeetPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow AcreFeetPerHour<T>(this T value) =>
-            VolumeFlow.FromAcreFeetPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromAcreFeetPerHour(T)" />
+        public static VolumeFlow<double> AcreFeetPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromAcreFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow AcreFeetPerMinute<T>(this T value) =>
-            VolumeFlow.FromAcreFeetPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromAcreFeetPerMinute(T)" />
+        public static VolumeFlow<double> AcreFeetPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromAcreFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow AcreFeetPerSecond<T>(this T value) =>
-            VolumeFlow.FromAcreFeetPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromAcreFeetPerSecond(T)" />
+        public static VolumeFlow<double> AcreFeetPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromAcreFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CentilitersPerDay<T>(this T value) =>
-            VolumeFlow.FromCentilitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCentilitersPerDay(T)" />
+        public static VolumeFlow<double> CentilitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromCentilitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CentilitersPerMinute<T>(this T value) =>
-            VolumeFlow.FromCentilitersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCentilitersPerMinute(T)" />
+        public static VolumeFlow<double> CentilitersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromCentilitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CentilitersPerSecond<T>(this T value) =>
-            VolumeFlow.FromCentilitersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCentilitersPerSecond(T)" />
+        public static VolumeFlow<double> CentilitersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromCentilitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicCentimetersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicCentimetersPerMinute<T>(this T value) =>
-            VolumeFlow.FromCubicCentimetersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicCentimetersPerMinute(T)" />
+        public static VolumeFlow<double> CubicCentimetersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromCubicCentimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicDecimetersPerMinute<T>(this T value) =>
-            VolumeFlow.FromCubicDecimetersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicDecimetersPerMinute(T)" />
+        public static VolumeFlow<double> CubicDecimetersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromCubicDecimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicFeetPerHour<T>(this T value) =>
-            VolumeFlow.FromCubicFeetPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicFeetPerHour(T)" />
+        public static VolumeFlow<double> CubicFeetPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromCubicFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicFeetPerMinute<T>(this T value) =>
-            VolumeFlow.FromCubicFeetPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicFeetPerMinute(T)" />
+        public static VolumeFlow<double> CubicFeetPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromCubicFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicFeetPerSecond<T>(this T value) =>
-            VolumeFlow.FromCubicFeetPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicFeetPerSecond(T)" />
+        public static VolumeFlow<double> CubicFeetPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromCubicFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicMetersPerDay<T>(this T value) =>
-            VolumeFlow.FromCubicMetersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicMetersPerDay(T)" />
+        public static VolumeFlow<double> CubicMetersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromCubicMetersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicMetersPerHour<T>(this T value) =>
-            VolumeFlow.FromCubicMetersPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicMetersPerHour(T)" />
+        public static VolumeFlow<double> CubicMetersPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromCubicMetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicMetersPerMinute<T>(this T value) =>
-            VolumeFlow.FromCubicMetersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicMetersPerMinute(T)" />
+        public static VolumeFlow<double> CubicMetersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromCubicMetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicMetersPerSecond<T>(this T value) =>
-            VolumeFlow.FromCubicMetersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicMetersPerSecond(T)" />
+        public static VolumeFlow<double> CubicMetersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromCubicMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicMillimetersPerSecond<T>(this T value) =>
-            VolumeFlow.FromCubicMillimetersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicMillimetersPerSecond(T)" />
+        public static VolumeFlow<double> CubicMillimetersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromCubicMillimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicYardsPerDay<T>(this T value) =>
-            VolumeFlow.FromCubicYardsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicYardsPerDay(T)" />
+        public static VolumeFlow<double> CubicYardsPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromCubicYardsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicYardsPerHour<T>(this T value) =>
-            VolumeFlow.FromCubicYardsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicYardsPerHour(T)" />
+        public static VolumeFlow<double> CubicYardsPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromCubicYardsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicYardsPerMinute<T>(this T value) =>
-            VolumeFlow.FromCubicYardsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicYardsPerMinute(T)" />
+        public static VolumeFlow<double> CubicYardsPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromCubicYardsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow CubicYardsPerSecond<T>(this T value) =>
-            VolumeFlow.FromCubicYardsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromCubicYardsPerSecond(T)" />
+        public static VolumeFlow<double> CubicYardsPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromCubicYardsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow DecilitersPerDay<T>(this T value) =>
-            VolumeFlow.FromDecilitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromDecilitersPerDay(T)" />
+        public static VolumeFlow<double> DecilitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromDecilitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow DecilitersPerMinute<T>(this T value) =>
-            VolumeFlow.FromDecilitersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromDecilitersPerMinute(T)" />
+        public static VolumeFlow<double> DecilitersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromDecilitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow DecilitersPerSecond<T>(this T value) =>
-            VolumeFlow.FromDecilitersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromDecilitersPerSecond(T)" />
+        public static VolumeFlow<double> DecilitersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromDecilitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow KilolitersPerDay<T>(this T value) =>
-            VolumeFlow.FromKilolitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromKilolitersPerDay(T)" />
+        public static VolumeFlow<double> KilolitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromKilolitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow KilolitersPerMinute<T>(this T value) =>
-            VolumeFlow.FromKilolitersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromKilolitersPerMinute(T)" />
+        public static VolumeFlow<double> KilolitersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromKilolitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow KilolitersPerSecond<T>(this T value) =>
-            VolumeFlow.FromKilolitersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromKilolitersPerSecond(T)" />
+        public static VolumeFlow<double> KilolitersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromKilolitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow KilousGallonsPerMinute<T>(this T value) =>
-            VolumeFlow.FromKilousGallonsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromKilousGallonsPerMinute(T)" />
+        public static VolumeFlow<double> KilousGallonsPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromKilousGallonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow LitersPerDay<T>(this T value) =>
-            VolumeFlow.FromLitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromLitersPerDay(T)" />
+        public static VolumeFlow<double> LitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromLitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow LitersPerHour<T>(this T value) =>
-            VolumeFlow.FromLitersPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromLitersPerHour(T)" />
+        public static VolumeFlow<double> LitersPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromLitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow LitersPerMinute<T>(this T value) =>
-            VolumeFlow.FromLitersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromLitersPerMinute(T)" />
+        public static VolumeFlow<double> LitersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromLitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow LitersPerSecond<T>(this T value) =>
-            VolumeFlow.FromLitersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromLitersPerSecond(T)" />
+        public static VolumeFlow<double> LitersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromLitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MegalitersPerDay<T>(this T value) =>
-            VolumeFlow.FromMegalitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMegalitersPerDay(T)" />
+        public static VolumeFlow<double> MegalitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromMegalitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MegaukGallonsPerSecond<T>(this T value) =>
-            VolumeFlow.FromMegaukGallonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMegaukGallonsPerSecond(T)" />
+        public static VolumeFlow<double> MegaukGallonsPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromMegaukGallonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MicrolitersPerDay<T>(this T value) =>
-            VolumeFlow.FromMicrolitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMicrolitersPerDay(T)" />
+        public static VolumeFlow<double> MicrolitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromMicrolitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MicrolitersPerMinute<T>(this T value) =>
-            VolumeFlow.FromMicrolitersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMicrolitersPerMinute(T)" />
+        public static VolumeFlow<double> MicrolitersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromMicrolitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MicrolitersPerSecond<T>(this T value) =>
-            VolumeFlow.FromMicrolitersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMicrolitersPerSecond(T)" />
+        public static VolumeFlow<double> MicrolitersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromMicrolitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MillilitersPerDay<T>(this T value) =>
-            VolumeFlow.FromMillilitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMillilitersPerDay(T)" />
+        public static VolumeFlow<double> MillilitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromMillilitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MillilitersPerMinute<T>(this T value) =>
-            VolumeFlow.FromMillilitersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMillilitersPerMinute(T)" />
+        public static VolumeFlow<double> MillilitersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromMillilitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MillilitersPerSecond<T>(this T value) =>
-            VolumeFlow.FromMillilitersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMillilitersPerSecond(T)" />
+        public static VolumeFlow<double> MillilitersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromMillilitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow MillionUsGallonsPerDay<T>(this T value) =>
-            VolumeFlow.FromMillionUsGallonsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromMillionUsGallonsPerDay(T)" />
+        public static VolumeFlow<double> MillionUsGallonsPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromMillionUsGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow NanolitersPerDay<T>(this T value) =>
-            VolumeFlow.FromNanolitersPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromNanolitersPerDay(T)" />
+        public static VolumeFlow<double> NanolitersPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromNanolitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow NanolitersPerMinute<T>(this T value) =>
-            VolumeFlow.FromNanolitersPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromNanolitersPerMinute(T)" />
+        public static VolumeFlow<double> NanolitersPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromNanolitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow NanolitersPerSecond<T>(this T value) =>
-            VolumeFlow.FromNanolitersPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromNanolitersPerSecond(T)" />
+        public static VolumeFlow<double> NanolitersPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromNanolitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow OilBarrelsPerDay<T>(this T value) =>
-            VolumeFlow.FromOilBarrelsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromOilBarrelsPerDay(T)" />
+        public static VolumeFlow<double> OilBarrelsPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromOilBarrelsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow OilBarrelsPerHour<T>(this T value) =>
-            VolumeFlow.FromOilBarrelsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromOilBarrelsPerHour(T)" />
+        public static VolumeFlow<double> OilBarrelsPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromOilBarrelsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow OilBarrelsPerMinute<T>(this T value) =>
-            VolumeFlow.FromOilBarrelsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromOilBarrelsPerMinute(T)" />
+        public static VolumeFlow<double> OilBarrelsPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromOilBarrelsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow OilBarrelsPerSecond<T>(this T value) =>
-            VolumeFlow.FromOilBarrelsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromOilBarrelsPerSecond(T)" />
+        public static VolumeFlow<double> OilBarrelsPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromOilBarrelsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UkGallonsPerDay<T>(this T value) =>
-            VolumeFlow.FromUkGallonsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUkGallonsPerDay(T)" />
+        public static VolumeFlow<double> UkGallonsPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromUkGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UkGallonsPerHour<T>(this T value) =>
-            VolumeFlow.FromUkGallonsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUkGallonsPerHour(T)" />
+        public static VolumeFlow<double> UkGallonsPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromUkGallonsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UkGallonsPerMinute<T>(this T value) =>
-            VolumeFlow.FromUkGallonsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUkGallonsPerMinute(T)" />
+        public static VolumeFlow<double> UkGallonsPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromUkGallonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UkGallonsPerSecond<T>(this T value) =>
-            VolumeFlow.FromUkGallonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUkGallonsPerSecond(T)" />
+        public static VolumeFlow<double> UkGallonsPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromUkGallonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UsGallonsPerDay<T>(this T value) =>
-            VolumeFlow.FromUsGallonsPerDay(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUsGallonsPerDay(T)" />
+        public static VolumeFlow<double> UsGallonsPerDay<T>(this T value) =>
+            VolumeFlow<double>.FromUsGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UsGallonsPerHour<T>(this T value) =>
-            VolumeFlow.FromUsGallonsPerHour(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUsGallonsPerHour(T)" />
+        public static VolumeFlow<double> UsGallonsPerHour<T>(this T value) =>
+            VolumeFlow<double>.FromUsGallonsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UsGallonsPerMinute<T>(this T value) =>
-            VolumeFlow.FromUsGallonsPerMinute(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUsGallonsPerMinute(T)" />
+        public static VolumeFlow<double> UsGallonsPerMinute<T>(this T value) =>
+            VolumeFlow<double>.FromUsGallonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(UnitsNet.QuantityValue)" />
-        public static VolumeFlow UsGallonsPerSecond<T>(this T value) =>
-            VolumeFlow.FromUsGallonsPerSecond(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumeFlow{T}.FromUsGallonsPerSecond(T)" />
+        public static VolumeFlow<double> UsGallonsPerSecond<T>(this T value) =>
+            VolumeFlow<double>.FromUsGallonsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
index c9eef0a0d3..b467d4b1a4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
@@ -28,33 +28,33 @@ namespace UnitsNet.NumberExtensions.NumberToVolumePerLength
     /// </summary>
     public static class NumberToVolumePerLengthExtensions
     {
-        /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(UnitsNet.QuantityValue)" />
-        public static VolumePerLength CubicMetersPerMeter<T>(this T value) =>
-            VolumePerLength.FromCubicMetersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumePerLength{T}.FromCubicMetersPerMeter(T)" />
+        public static VolumePerLength<double> CubicMetersPerMeter<T>(this T value) =>
+            VolumePerLength<double>.FromCubicMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(UnitsNet.QuantityValue)" />
-        public static VolumePerLength CubicYardsPerFoot<T>(this T value) =>
-            VolumePerLength.FromCubicYardsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumePerLength{T}.FromCubicYardsPerFoot(T)" />
+        public static VolumePerLength<double> CubicYardsPerFoot<T>(this T value) =>
+            VolumePerLength<double>.FromCubicYardsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(UnitsNet.QuantityValue)" />
-        public static VolumePerLength CubicYardsPerUsSurveyFoot<T>(this T value) =>
-            VolumePerLength.FromCubicYardsPerUsSurveyFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumePerLength{T}.FromCubicYardsPerUsSurveyFoot(T)" />
+        public static VolumePerLength<double> CubicYardsPerUsSurveyFoot<T>(this T value) =>
+            VolumePerLength<double>.FromCubicYardsPerUsSurveyFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerKilometer(UnitsNet.QuantityValue)" />
-        public static VolumePerLength LitersPerKilometer<T>(this T value) =>
-            VolumePerLength.FromLitersPerKilometer(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumePerLength{T}.FromLitersPerKilometer(T)" />
+        public static VolumePerLength<double> LitersPerKilometer<T>(this T value) =>
+            VolumePerLength<double>.FromLitersPerKilometer(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(UnitsNet.QuantityValue)" />
-        public static VolumePerLength LitersPerMeter<T>(this T value) =>
-            VolumePerLength.FromLitersPerMeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumePerLength{T}.FromLitersPerMeter(T)" />
+        public static VolumePerLength<double> LitersPerMeter<T>(this T value) =>
+            VolumePerLength<double>.FromLitersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerMillimeter(UnitsNet.QuantityValue)" />
-        public static VolumePerLength LitersPerMillimeter<T>(this T value) =>
-            VolumePerLength.FromLitersPerMillimeter(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumePerLength{T}.FromLitersPerMillimeter(T)" />
+        public static VolumePerLength<double> LitersPerMillimeter<T>(this T value) =>
+            VolumePerLength<double>.FromLitersPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(UnitsNet.QuantityValue)" />
-        public static VolumePerLength OilBarrelsPerFoot<T>(this T value) =>
-            VolumePerLength.FromOilBarrelsPerFoot(Convert.ToDouble(value));
+        /// <inheritdoc cref="VolumePerLength{T}.FromOilBarrelsPerFoot(T)" />
+        public static VolumePerLength<double> OilBarrelsPerFoot<T>(this T value) =>
+            VolumePerLength<double>.FromOilBarrelsPerFoot(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
index 9619780002..7f9109039f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
@@ -28,29 +28,29 @@ namespace UnitsNet.NumberExtensions.NumberToWarpingMomentOfInertia
     /// </summary>
     public static class NumberToWarpingMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromCentimetersToTheSixth(UnitsNet.QuantityValue)" />
-        public static WarpingMomentOfInertia CentimetersToTheSixth<T>(this T value) =>
-            WarpingMomentOfInertia.FromCentimetersToTheSixth(Convert.ToDouble(value));
+        /// <inheritdoc cref="WarpingMomentOfInertia{T}.FromCentimetersToTheSixth(T)" />
+        public static WarpingMomentOfInertia<double> CentimetersToTheSixth<T>(this T value) =>
+            WarpingMomentOfInertia<double>.FromCentimetersToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromDecimetersToTheSixth(UnitsNet.QuantityValue)" />
-        public static WarpingMomentOfInertia DecimetersToTheSixth<T>(this T value) =>
-            WarpingMomentOfInertia.FromDecimetersToTheSixth(Convert.ToDouble(value));
+        /// <inheritdoc cref="WarpingMomentOfInertia{T}.FromDecimetersToTheSixth(T)" />
+        public static WarpingMomentOfInertia<double> DecimetersToTheSixth<T>(this T value) =>
+            WarpingMomentOfInertia<double>.FromDecimetersToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromFeetToTheSixth(UnitsNet.QuantityValue)" />
-        public static WarpingMomentOfInertia FeetToTheSixth<T>(this T value) =>
-            WarpingMomentOfInertia.FromFeetToTheSixth(Convert.ToDouble(value));
+        /// <inheritdoc cref="WarpingMomentOfInertia{T}.FromFeetToTheSixth(T)" />
+        public static WarpingMomentOfInertia<double> FeetToTheSixth<T>(this T value) =>
+            WarpingMomentOfInertia<double>.FromFeetToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromInchesToTheSixth(UnitsNet.QuantityValue)" />
-        public static WarpingMomentOfInertia InchesToTheSixth<T>(this T value) =>
-            WarpingMomentOfInertia.FromInchesToTheSixth(Convert.ToDouble(value));
+        /// <inheritdoc cref="WarpingMomentOfInertia{T}.FromInchesToTheSixth(T)" />
+        public static WarpingMomentOfInertia<double> InchesToTheSixth<T>(this T value) =>
+            WarpingMomentOfInertia<double>.FromInchesToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromMetersToTheSixth(UnitsNet.QuantityValue)" />
-        public static WarpingMomentOfInertia MetersToTheSixth<T>(this T value) =>
-            WarpingMomentOfInertia.FromMetersToTheSixth(Convert.ToDouble(value));
+        /// <inheritdoc cref="WarpingMomentOfInertia{T}.FromMetersToTheSixth(T)" />
+        public static WarpingMomentOfInertia<double> MetersToTheSixth<T>(this T value) =>
+            WarpingMomentOfInertia<double>.FromMetersToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromMillimetersToTheSixth(UnitsNet.QuantityValue)" />
-        public static WarpingMomentOfInertia MillimetersToTheSixth<T>(this T value) =>
-            WarpingMomentOfInertia.FromMillimetersToTheSixth(Convert.ToDouble(value));
+        /// <inheritdoc cref="WarpingMomentOfInertia{T}.FromMillimetersToTheSixth(T)" />
+        public static WarpingMomentOfInertia<double> MillimetersToTheSixth<T>(this T value) =>
+            WarpingMomentOfInertia<double>.FromMillimetersToTheSixth(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Serialization.JsonNet.CompatibilityTests/UnitsNetJsonConverterTests.cs b/UnitsNet.Serialization.JsonNet.CompatibilityTests/UnitsNetJsonConverterTests.cs
index 3a71fbc5fe..457e0b3075 100644
--- a/UnitsNet.Serialization.JsonNet.CompatibilityTests/UnitsNetJsonConverterTests.cs
+++ b/UnitsNet.Serialization.JsonNet.CompatibilityTests/UnitsNetJsonConverterTests.cs
@@ -32,7 +32,7 @@ public class Serialize : UnitsNetJsonConverterTests
             [Fact]
             public void Information_CanSerializeVeryLargeValues()
             {
-                Information i = Information.FromExabytes(1E+9);
+                Information<double> i = Information<double>.FromExabytes(1E+9);
                 var expectedJson = "{\n  \"Unit\": \"InformationUnit.Exabyte\",\n  \"Value\": 1000000000.0\n}";
 
                 string json = SerializeObject(i);
@@ -43,7 +43,7 @@ public void Information_CanSerializeVeryLargeValues()
             [Fact]
             public void Mass_ExpectConstructedValueAndUnit()
             {
-                Mass mass = Mass.FromPounds(200);
+                Mass<double> mass = Mass<double>.FromPounds(200);
                 var expectedJson = "{\n  \"Unit\": \"MassUnit.Pound\",\n  \"Value\": 200.0\n}";
 
                 string json = SerializeObject(mass);
@@ -54,7 +54,7 @@ public void Mass_ExpectConstructedValueAndUnit()
             [Fact]
             public void Information_ExpectConstructedValueAndUnit()
             {
-                Information quantity = Information.FromKilobytes(54);
+                Information<double> quantity = Information<double>.FromKilobytes(54);
                 var expectedJson = "{\n  \"Unit\": \"InformationUnit.Kilobyte\",\n  \"Value\": 54.0\n}";
 
                 string json = SerializeObject(quantity);
@@ -65,7 +65,7 @@ public void Information_ExpectConstructedValueAndUnit()
             [Fact]
             public void NonNullNullableValue_ExpectJsonUnaffected()
             {
-                Mass? nullableMass = Mass.FromKilograms(10);
+                Mass<double>? nullableMass = Mass<double>.FromKilograms(10);
                 var expectedJson = "{\n  \"Unit\": \"MassUnit.Kilogram\",\n  \"Value\": 10.0\n}";
 
                 string json = SerializeObject(nullableMass);
@@ -79,8 +79,8 @@ public void NonNullNullableValueNestedInObject_ExpectJsonUnaffected()
             {
                 var testObj = new TestObj
                 {
-                    NullableFrequency = Frequency.FromHertz(10),
-                    NonNullableFrequency = Frequency.FromHertz(10)
+                    NullableFrequency = Frequency<double>.FromHertz(10),
+                    NonNullableFrequency = Frequency<double>.FromHertz(10)
                 };
                 // Ugly manually formatted JSON string is used because string literals with newlines are rendered differently
                 //  on the build server (i.e. the build server uses '\r' instead of '\n')
@@ -110,7 +110,7 @@ public void NullValue_ExpectJsonContainsNullString()
             [Fact]
             public void Ratio_ExpectDecimalFractionsUsedAsBaseValueAndUnit()
             {
-                Ratio ratio = Ratio.FromPartsPerThousand(250);
+                Ratio<double> ratio = Ratio<double>.FromPartsPerThousand(250);
                 var expectedJson = "{\n  \"Unit\": \"RatioUnit.PartPerThousand\",\n  \"Value\": 250.0\n}";
 
                 string json = SerializeObject(ratio);
@@ -156,9 +156,9 @@ public class Deserialize : UnitsNetJsonConverterTests
             [Fact]
             public void Information_CanDeserializeVeryLargeValues()
             {
-                Information original = Information.FromExabytes(1E+9);
+                Information<double> original = Information<double>.FromExabytes(1E+9);
                 string json = SerializeObject(original);
-                var deserialized = DeserializeObject<Information>(json);
+                var deserialized = DeserializeObject<Information<double>>(json);
 
                 Assert.Equal(original, deserialized);
             }
@@ -166,10 +166,10 @@ public void Information_CanDeserializeVeryLargeValues()
             [Fact]
             public void Mass_ExpectJsonCorrectlyDeserialized()
             {
-                Mass originalMass = Mass.FromKilograms(33.33);
+                Mass<double> originalMass = Mass<double>.FromKilograms(33.33);
                 string json = SerializeObject(originalMass);
 
-                var deserializedMass = DeserializeObject<Mass>(json);
+                var deserializedMass = DeserializeObject<Mass<double>>(json);
 
                 Assert.Equal(originalMass, deserializedMass);
             }
@@ -177,10 +177,10 @@ public void Mass_ExpectJsonCorrectlyDeserialized()
             [Fact]
             public void NonNullNullableValue_ExpectValueDeserializedCorrectly()
             {
-                Mass? nullableMass = Mass.FromKilograms(10);
+                Mass<double>? nullableMass = Mass<double>.FromKilograms(10);
                 string json = SerializeObject(nullableMass);
 
-                Mass? deserializedNullableMass = DeserializeObject<Mass?>(json);
+                Mass<double>? deserializedNullableMass = DeserializeObject<Mass<double>?>(json);
 
                 Assert.Equal(nullableMass.Value, deserializedNullableMass);
             }
@@ -190,8 +190,8 @@ public void NonNullNullableValueNestedInObject_ExpectValueDeserializedCorrectly(
             {
                 var testObj = new TestObj
                 {
-                    NullableFrequency = Frequency.FromHertz(10),
-                    NonNullableFrequency = Frequency.FromHertz(10)
+                    NullableFrequency = Frequency<double>.FromHertz(10),
+                    NonNullableFrequency = Frequency<double>.FromHertz(10)
                 };
                 string json = SerializeObject(testObj);
 
@@ -204,7 +204,7 @@ public void NonNullNullableValueNestedInObject_ExpectValueDeserializedCorrectly(
             public void NullValue_ExpectNullReturned()
             {
                 string json = SerializeObject(null);
-                var deserializedNullMass = DeserializeObject<Mass?>(json);
+                var deserializedNullMass = DeserializeObject<Mass<double>?>(json);
 
                 Assert.Null(deserializedNullMass);
             }
@@ -215,7 +215,7 @@ public void NullValueNestedInObject_ExpectValueDeserializedToNullCorrectly()
                 var testObj = new TestObj
                 {
                     NullableFrequency = null,
-                    NonNullableFrequency = Frequency.FromHertz(10)
+                    NonNullableFrequency = Frequency<double>.FromHertz(10)
                 };
                 string json = SerializeObject(testObj);
 
@@ -227,13 +227,13 @@ public void NullValueNestedInObject_ExpectValueDeserializedToNullCorrectly()
             [Fact]
             public void UnitEnumChangedAfterSerialization_ExpectUnitCorrectlyDeserialized()
             {
-                Mass originalMass = Mass.FromKilograms(33.33);
+                Mass<double> originalMass = Mass<double>.FromKilograms(33.33);
                 string json = SerializeObject(originalMass);
                 // Someone manually changed the serialized JSON string to 1000 grams.
                 json = json.Replace("33.33", "1000");
                 json = json.Replace("MassUnit.Kilogram", "MassUnit.Gram");
 
-                var deserializedMass = DeserializeObject<Mass>(json);
+                var deserializedMass = DeserializeObject<Mass<double>>(json);
 
                 // The original value serialized was 33.33 kg, but someone edited the JSON to be 1000 g. We expect the JSON is
                 //  still deserializable, and the correct value of 1000 g is obtained.
@@ -245,7 +245,7 @@ public void UnitInIComparable_ExpectUnitCorrectlyDeserialized()
             {
                 TestObjWithIComparable testObjWithIComparable = new TestObjWithIComparable()
                 {
-                    Value = Power.FromWatts(10)
+                    Value = Power<double>.FromWatts(10)
                 };
                 JsonSerializerSettings jsonSerializerSettings = CreateJsonSerializerSettings();
 
@@ -253,8 +253,8 @@ public void UnitInIComparable_ExpectUnitCorrectlyDeserialized()
 
                 var deserializedTestObject = JsonConvert.DeserializeObject<TestObjWithIComparable>(json,jsonSerializerSettings);
 
-                Assert.Equal(typeof(Power), deserializedTestObject.Value.GetType());
-                Assert.Equal(Power.FromWatts(10), (Power)deserializedTestObject.Value);
+                Assert.Equal(typeof(Power<double>), deserializedTestObject.Value.GetType());
+                Assert.Equal(Power<double>.FromWatts(10), (Power<double>)deserializedTestObject.Value);
             }
 
             [Fact]
@@ -314,7 +314,7 @@ public void ThreeObjectsInIComparableWithDifferentValues_ExpectAllCorrectlyDeser
                 TestObjWithThreeIComparable testObjWithIComparable = new TestObjWithThreeIComparable()
                 {
                     Value1 = 10.0,
-                    Value2 = Power.FromWatts(19),
+                    Value2 = Power<double>.FromWatts(19),
                     Value3 = new ComparableClass() { Value = 10 },
                 };
                 JsonSerializerSettings jsonSerializerSettings = CreateJsonSerializerSettings();
@@ -324,8 +324,8 @@ public void ThreeObjectsInIComparableWithDifferentValues_ExpectAllCorrectlyDeser
 
                 Assert.Equal(typeof(double), deserializedTestObject.Value1.GetType());
                 Assert.Equal(10d, deserializedTestObject.Value1);
-                Assert.Equal(typeof(Power), deserializedTestObject.Value2.GetType());
-                Assert.Equal(Power.FromWatts(19), deserializedTestObject.Value2);
+                Assert.Equal(typeof(Power<double>), deserializedTestObject.Value2.GetType());
+                Assert.Equal(Power<double>.FromWatts(19), deserializedTestObject.Value2);
                 Assert.Equal(typeof(ComparableClass), deserializedTestObject.Value3.GetType());
                 Assert.Equal(testObjWithIComparable.Value3, deserializedTestObject.Value3);
             }
@@ -408,8 +408,8 @@ private static JsonSerializerSettings CreateJsonSerializerSettings()
 
         private class TestObj
         {
-            public Frequency? NullableFrequency { get; set; }
-            public Frequency NonNullableFrequency { get; set; }
+            public Frequency<double>? NullableFrequency { get; set; }
+            public Frequency<double> NonNullableFrequency { get; set; }
         }
 
         private class TestObjWithValueAndUnit : IComparable
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs
index 2782da5ed8..c173be9b71 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs
@@ -89,7 +89,7 @@ private static IQuantity ParseValueUnit(ValueUnit vu)
             double value = vu.Value;
             Enum unitValue = (Enum)Enum.Parse(unitEnumType, unitEnumValue); // Ex: MassUnit.Kilogram
 
-            return Quantity.From(value, unitValue);
+            return Quantity.From<double>(value, unitValue);
         }
 
         private static object TryDeserializeIComparable(JsonReader reader, JsonSerializer serializer)
diff --git a/UnitsNet.Tests/AssemblyAttributeTests.cs b/UnitsNet.Tests/AssemblyAttributeTests.cs
index 754846727d..d836dc0479 100644
--- a/UnitsNet.Tests/AssemblyAttributeTests.cs
+++ b/UnitsNet.Tests/AssemblyAttributeTests.cs
@@ -13,7 +13,7 @@ public class AssemblyAttributeTests
         [Fact]
         public static void AssemblyShouldBeClsCompliant()
         {
-            var assembly = typeof(Length).GetTypeInfo().Assembly;
+            var assembly = typeof(Length<double>).GetTypeInfo().Assembly;
 
             var attributes = assembly.CustomAttributes.Select(x => x.AttributeType);
             Assert.Contains(typeof(CLSCompliantAttribute), attributes);
@@ -22,7 +22,7 @@ public static void AssemblyShouldBeClsCompliant()
         [Fact]
         public static void AssemblyCopyrightShouldContain2013()
         {
-            var assembly = typeof(Length).GetTypeInfo().Assembly;
+            var assembly = typeof(Length<double>).GetTypeInfo().Assembly;
 
             var copyrightAttribute = assembly
                 .CustomAttributes
diff --git a/UnitsNet.Tests/BaseDimensionsTests.cs b/UnitsNet.Tests/BaseDimensionsTests.cs
index 9c0b593590..fa134d7d3b 100644
--- a/UnitsNet.Tests/BaseDimensionsTests.cs
+++ b/UnitsNet.Tests/BaseDimensionsTests.cs
@@ -379,35 +379,35 @@ public void LuminousIntensityDimensionsDivideCorrectly()
         [Fact]
         public void CheckBaseDimensionDivisionWithSpeedEqualsDistanceDividedByTimeOnStaticProperty()
         {
-            var calculatedDimensions = Length.BaseDimensions.Divide(Duration.BaseDimensions);
-            Assert.True(calculatedDimensions == Speed.BaseDimensions);
+            var calculatedDimensions = Length<double>.BaseDimensions.Divide(Duration<double>.BaseDimensions);
+            Assert.True(calculatedDimensions == Speed<double>.BaseDimensions);
         }
 
         [Fact]
         public void CheckBaseDimensionDivisionWithSpeedEqualsDistanceDividedByTimeOnInstanceProperty()
         {
-            var length = Length.FromKilometers(100);
-            var duration = Duration.FromHours(1);
+            var length = Length<double>.FromKilometers(100);
+            var duration = Duration<double>.FromHours(1);
 
             var calculatedDimensions = length.Dimensions.Divide(duration.Dimensions);
-            Assert.True(calculatedDimensions == Speed.BaseDimensions);
+            Assert.True(calculatedDimensions == Speed<double>.BaseDimensions);
         }
 
         [Fact]
         public void CheckBaseDimensionMultiplicationWithForceEqualsMassTimesAccelerationOnStaticProperty()
         {
-            var calculatedDimensions = Mass.BaseDimensions.Multiply(Acceleration.BaseDimensions);
-            Assert.True(calculatedDimensions == Force.BaseDimensions);
+            var calculatedDimensions = Mass<double>.BaseDimensions.Multiply(Acceleration<double>.BaseDimensions);
+            Assert.True(calculatedDimensions == Force<double>.BaseDimensions);
         }
 
         [Fact]
         public void CheckBaseDimensionMultiplicationWithForceEqualsMassTimesAccelerationOnInstanceProperty()
         {
-            var mass = Mass.FromPounds(205);
-            var acceleration = Acceleration.FromMetersPerSecondSquared(9.8);
+            var mass = Mass<double>.FromPounds(205);
+            var acceleration = Acceleration<double>.FromMetersPerSecondSquared(9.8);
 
             var calculatedDimensions = mass.Dimensions.Multiply(acceleration.Dimensions);
-            Assert.True(calculatedDimensions == Force.BaseDimensions);
+            Assert.True(calculatedDimensions == Force<double>.BaseDimensions);
         }
 
         [Fact]
@@ -661,41 +661,41 @@ public void LuminousIntensityDimensionsDivideCorrectlyWithOperatorOverloads()
         [Fact]
         public void CheckBaseDimensionDivisionWithSpeedEqualsDistanceDividedByTimeOnStaticPropertyWithOperatorOverloads()
         {
-            var calculatedDimensions = Length.BaseDimensions / Duration.BaseDimensions;
-            Assert.True(calculatedDimensions == Speed.BaseDimensions);
+            var calculatedDimensions = Length<double>.BaseDimensions / Duration<double>.BaseDimensions;
+            Assert.True(calculatedDimensions == Speed<double>.BaseDimensions);
         }
 
         [Fact]
         public void CheckBaseDimensionDivisionWithSpeedEqualsDistanceDividedByTimeOnInstancePropertyWithOperatorOverloads()
         {
-            var length = Length.FromKilometers(100);
-            var duration = Duration.FromHours(1);
+            var length = Length<double>.FromKilometers(100);
+            var duration = Duration<double>.FromHours(1);
 
             var calculatedDimensions = length.Dimensions / duration.Dimensions;
-            Assert.True(calculatedDimensions == Speed.BaseDimensions);
+            Assert.True(calculatedDimensions == Speed<double>.BaseDimensions);
         }
 
         [Fact]
         public void CheckBaseDimensionMultiplicationWithForceEqualsMassTimesAccelerationOnStaticPropertyWithOperatorOverloads()
         {
-            var calculatedDimensions = Mass.BaseDimensions * Acceleration.BaseDimensions;
-            Assert.True(calculatedDimensions == Force.BaseDimensions);
+            var calculatedDimensions = Mass<double>.BaseDimensions * Acceleration<double>.BaseDimensions;
+            Assert.True(calculatedDimensions == Force<double>.BaseDimensions);
         }
 
         [Fact]
         public void CheckBaseDimensionMultiplicationWithForceEqualsMassTimesAccelerationOnInstancePropertyWithOperatorOverloads()
         {
-            var mass = Mass.FromPounds(205);
-            var acceleration = Acceleration.FromMetersPerSecondSquared(9.8);
+            var mass = Mass<double>.FromPounds(205);
+            var acceleration = Acceleration<double>.FromMetersPerSecondSquared(9.8);
 
             var calculatedDimensions = mass.Dimensions * acceleration.Dimensions;
-            Assert.True(calculatedDimensions == Force.BaseDimensions);
+            Assert.True(calculatedDimensions == Force<double>.BaseDimensions);
         }
 
         [Fact]
         public void CheckToStringUsingMolarEntropy()
         {
-            Assert.Equal("[Length]^2[Mass][Time]^-2[Temperature][Amount]", MolarEntropy.BaseDimensions.ToString());
+            Assert.Equal("[Length]^2[Mass][Time]^-2[Temperature][Amount]", MolarEntropy<double>.BaseDimensions.ToString());
         }
 
         [Fact]
@@ -736,7 +736,7 @@ public void IsDimensionlessMethodImplementedCorrectly()
             Assert.False(BaseDimensions.Dimensionless.IsDerivedQuantity());
 
             // Example case
-            Assert.True(Level.BaseDimensions.IsDimensionless());
+            Assert.True(Level<double>.BaseDimensions.IsDimensionless());
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AccelerationTests.cs b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
index 4e3ff9422f..d04a6fdc55 100644
--- a/UnitsNet.Tests/CustomCode/AccelerationTests.cs
+++ b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
@@ -40,8 +40,8 @@ public class AccelerationTests : AccelerationTestsBase
         [Fact]
         public void AccelerationTimesDensityEqualsSpecificWeight()
         {
-            SpecificWeight specificWeight = Acceleration.FromMetersPerSecondSquared(10) * Density.FromKilogramsPerCubicMeter(2);
-            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(20), specificWeight);
+            var specificWeight = Acceleration<double>.FromMetersPerSecondSquared(10) * Density<double>.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(SpecificWeight<double>.FromNewtonsPerCubicMeter(20), specificWeight);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs b/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs
index fcfa8e337e..b186f30020 100644
--- a/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs
@@ -29,7 +29,6 @@ namespace UnitsNet.Tests.CustomCode
     public class AmountOfSubstanceTests : AmountOfSubstanceTestsBase
     {
         protected override bool SupportsSIUnitSystem => true;
-
         protected override double CentimolesInOneMole => 1e2;
         protected override double CentipoundMolesInOneMole => 0.002204622621848776 * 1e2;
         protected override double DecimolesInOneMole => 1e1;
@@ -45,21 +44,21 @@ public class AmountOfSubstanceTests : AmountOfSubstanceTestsBase
         protected override double NanopoundMolesInOneMole => 0.002204622621848776 * 1e9;
         protected override double PoundMolesInOneMole => 0.002204622621848776;
         protected override double MegamolesInOneMole => 1e-6;
-
+        
         [Fact]
         public void NumberOfParticlesInOneMoleEqualsAvogadroConstant()
         {
-            var oneMole = AmountOfSubstance.FromMoles(1);
+            var oneMole = AmountOfSubstance<double>.FromMoles(1);
             var numberOfParticles = oneMole.NumberOfParticles();
-            Assert.Equal(AmountOfSubstance.AvogadroConstant, numberOfParticles);
+            Assert.Equal(AmountOfSubstance<double>.AvogadroConstant, numberOfParticles);
         }
 
         [Fact]
         public void NumberOfParticlesInTwoMolesIsDoubleAvogadroConstant()
         {
-            var twoMoles = AmountOfSubstance.FromMoles(2);
+            var twoMoles = AmountOfSubstance<double>.FromMoles(2);
             var numberOfParticles = twoMoles.NumberOfParticles();
-            Assert.Equal(AmountOfSubstance.AvogadroConstant * 2, numberOfParticles);
+            Assert.Equal(AmountOfSubstance<double>.AvogadroConstant * 2, numberOfParticles);
         }
 
         [Theory]
@@ -71,10 +70,10 @@ public void MassFromAmountOfSubstanceAndMolarMass(
             double molarMassValue, MolarMassUnit molarMassUnit,
             double expectedMass, MassUnit expectedMassUnit, double tolerence = 1e-5)
         {
-            AmountOfSubstance amountOfSubstance = new AmountOfSubstance(amountOfSubstanceValue, amountOfSubstanceUnit);
-            MolarMass molarMass = new MolarMass(molarMassValue, molarMassUnit);
-
-            Mass mass = amountOfSubstance * molarMass;
+            var amountOfSubstance = new AmountOfSubstance<double>(amountOfSubstanceValue, amountOfSubstanceUnit);
+            var molarMass = new MolarMass<double>( molarMassValue, molarMassUnit);
+            
+            var mass = amountOfSubstance * molarMass;
 
             AssertEx.EqualTolerance(expectedMass, mass.As(expectedMassUnit), tolerence);
         }
@@ -90,12 +89,12 @@ public void MolarityFromComponentMassAndSolutionVolume(
             double solutionVolumeValue, VolumeUnit solutionVolumeUnit,
             double expectedMolarityValue, MolarityUnit expectedMolarityUnit, double tolerence = 1e-5)
         {
-            var componentMass = new Mass(componentMassValue, componentMassUnit);
-            var componentMolarMass = new MolarMass(componentMolarMassValue, componentMolarMassUnit);
-            var volumeSolution = new Volume(solutionVolumeValue, solutionVolumeUnit);
-            AmountOfSubstance amountOfSubstance = componentMass / componentMolarMass;
+            var componentMass = new Mass<double>(componentMassValue, componentMassUnit);
+            var componentMolarMass = new MolarMass<double>( componentMolarMassValue, componentMolarMassUnit);
+            var volumeSolution = new Volume<double>( solutionVolumeValue, solutionVolumeUnit);
+            var amountOfSubstance = componentMass / componentMolarMass;
 
-            Molarity molarity = amountOfSubstance / volumeSolution;
+            var molarity = amountOfSubstance / volumeSolution;
 
             AssertEx.EqualTolerance(expectedMolarityValue, molarity.As(expectedMolarityUnit), tolerence);
         }
@@ -111,12 +110,12 @@ public void VolumeSolutionFromComponentMassAndDesiredConcentration(
             double desiredMolarityValue, MolarityUnit desiredMolarityUnit,
             double expectedSolutionVolumeValue, VolumeUnit expectedSolutionVolumeUnit, double tolerence = 1e-5)
         {
-            var componentMass = new Mass(componentMassValue, componentMassUnit);
-            var componentMolarMass = new MolarMass(componentMolarMassValue, componentMolarMassUnit);
-            var desiredMolarity = new Molarity(desiredMolarityValue, desiredMolarityUnit);
-            AmountOfSubstance amountOfSubstance = componentMass / componentMolarMass;
+            var componentMass = new Mass<double>(componentMassValue, componentMassUnit);
+            var componentMolarMass = new MolarMass<double>(componentMolarMassValue, componentMolarMassUnit);
+            var desiredMolarity = new Molarity<double>( desiredMolarityValue, desiredMolarityUnit);
+            var amountOfSubstance = componentMass / componentMolarMass;
 
-            Volume volumeSolution = amountOfSubstance / desiredMolarity;
+            var volumeSolution = amountOfSubstance / desiredMolarity;
 
             AssertEx.EqualTolerance(expectedSolutionVolumeValue, volumeSolution.As(expectedSolutionVolumeUnit), tolerence);
         }
diff --git a/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs b/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs
index 726457cbe1..118ac2fcaa 100644
--- a/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs
+++ b/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs
@@ -19,14 +19,14 @@ public class AmplitudeRatioTests : AmplitudeRatioTestsBase
 
         protected override void AssertLogarithmicAddition()
         {
-            AmplitudeRatio v = AmplitudeRatio.FromDecibelVolts(40);
+            var v = AmplitudeRatio<double>.FromDecibelVolts(40);
             AssertEx.EqualTolerance(46.0205999133, (v + v).DecibelVolts, DecibelVoltsTolerance);
         }
 
         protected override void AssertLogarithmicSubtraction()
         {
-            AmplitudeRatio v = AmplitudeRatio.FromDecibelVolts(40);
-            AssertEx.EqualTolerance(46.6982292275, (AmplitudeRatio.FromDecibelVolts(50) - v).DecibelVolts, DecibelVoltsTolerance);
+            var v = AmplitudeRatio<double>.FromDecibelVolts(40);
+            AssertEx.EqualTolerance(46.6982292275, (AmplitudeRatio<double>.FromDecibelVolts(50) - v).DecibelVolts, DecibelVoltsTolerance);
         }
 
         [Theory]
@@ -35,10 +35,10 @@ protected override void AssertLogarithmicSubtraction()
         [InlineData(-10)]
         public void InvalidVoltage_ExpectArgumentOutOfRangeException(double voltage)
         {
-            ElectricPotential invalidVoltage = ElectricPotential.FromVolts(voltage);
+            var invalidVoltage = ElectricPotential<double>.FromVolts(voltage);
 
             // ReSharper disable once ObjectCreationAsStatement
-            Assert.Throws<ArgumentOutOfRangeException>(() => new AmplitudeRatio(invalidVoltage));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new AmplitudeRatio<double>( invalidVoltage));
         }
 
         [Theory]
@@ -49,9 +49,9 @@ public void InvalidVoltage_ExpectArgumentOutOfRangeException(double voltage)
         public void ExpectVoltageConvertedToAmplitudeRatioCorrectly(double voltage, double expected)
         {
             // Amplitude ratio increases linearly by 20 dBV with power-of-10 increases of voltage.
-            ElectricPotential v = ElectricPotential.FromVolts(voltage);
+            var v = ElectricPotential<double>.FromVolts(voltage);
 
-            double actual = AmplitudeRatio.FromElectricPotential(v).DecibelVolts;
+            double actual = AmplitudeRatio<double>.FromElectricPotential(v).DecibelVolts;
             Assert.Equal(expected, actual);
         }
 
@@ -64,7 +64,7 @@ public void ExpectVoltageConvertedToAmplitudeRatioCorrectly(double voltage, doub
         public void ExpectAmplitudeRatioConvertedToVoltageCorrectly(double amplitudeRatio, double expected)
         {
             // Voltage increases by powers of 10 for every 20 dBV increase in amplitude ratio.
-            AmplitudeRatio ar = AmplitudeRatio.FromDecibelVolts(amplitudeRatio);
+            var ar = AmplitudeRatio<double>.FromDecibelVolts(amplitudeRatio);
 
             double actual = ar.ToElectricPotential().Volts;
             Assert.Equal(expected, actual);
@@ -79,9 +79,9 @@ public void ExpectAmplitudeRatioConvertedToVoltageCorrectly(double amplitudeRati
         [InlineData(60, 13.01)]
         public void AmplitudeRatioToPowerRatio_50OhmImpedance(double dBmV, double expected)
         {
-            AmplitudeRatio ampRatio = AmplitudeRatio.FromDecibelMillivolts(dBmV);
+            var ampRatio = AmplitudeRatio<double>.FromDecibelMillivolts(dBmV);
 
-            double actual = Math.Round(ampRatio.ToPowerRatio(ElectricResistance.FromOhms(50)).DecibelMilliwatts, 2);
+            double actual = Math.Round(ampRatio.ToPowerRatio(ElectricResistance<double>.FromOhms(50)).DecibelMilliwatts, 2);
             Assert.Equal(expected, actual);
         }
 
@@ -92,9 +92,9 @@ public void AmplitudeRatioToPowerRatio_50OhmImpedance(double dBmV, double expect
         [InlineData(60, 11.25)]
         public void AmplitudeRatioToPowerRatio_75OhmImpedance(double dBmV, double expected)
         {
-            AmplitudeRatio ampRatio = AmplitudeRatio.FromDecibelMillivolts(dBmV);
+            var ampRatio = AmplitudeRatio<double>.FromDecibelMillivolts(dBmV);
 
-            double actual = Math.Round(ampRatio.ToPowerRatio(ElectricResistance.FromOhms(75)).DecibelMilliwatts, 2);
+            double actual = Math.Round(ampRatio.ToPowerRatio(ElectricResistance<double>.FromOhms(75)).DecibelMilliwatts, 2);
             Assert.Equal(expected, actual);
         }
     }
diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index 77f2956280..b0a7667070 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -41,15 +41,15 @@ public class AngleTests : AngleTestsBase
         [Fact]
         public void AngleDividedByDurationEqualsRotationalSpeed()
         {
-            RotationalSpeed rotationalSpeed = Angle.FromRadians(10) / Duration.FromSeconds(5);
-            Assert.Equal(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
+            var rotationalSpeed = Angle<double>.FromRadians(10) / Duration<double>.FromSeconds(5);
+            Assert.Equal(rotationalSpeed, RotationalSpeed<double>.FromRadiansPerSecond(2));
         }
 
         [Fact]
         public void AngleDividedByTimeSpanEqualsRotationalSpeed()
         {
-            RotationalSpeed rotationalSpeed = Angle.FromRadians(10) / TimeSpan.FromSeconds(5);
-            Assert.Equal(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
+            var rotationalSpeed = Angle<double>.FromRadians(10) / TimeSpan.FromSeconds(5);
+            Assert.Equal(rotationalSpeed, RotationalSpeed<double>.FromRadiansPerSecond(2));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs b/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs
index 04fb07e048..a4e3044630 100644
--- a/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs
@@ -45,8 +45,8 @@ public class AreaMomentOfInertiaTests : AreaMomentOfInertiaTestsBase
         [Fact]
         public void AreaMomentOfInertiaDividedByLengthEqualsVolume()
         {
-            Volume volume = AreaMomentOfInertia.FromMetersToTheFourth(20) / Length.FromMeters(10);
-            Assert.Equal(Volume.FromCubicMeters(2), volume);
+            var volume = AreaMomentOfInertia<double>.FromMetersToTheFourth(20) / Length<double>.FromMeters(10);
+            Assert.Equal(Volume<double>.FromCubicMeters(2), volume);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AreaTests.cs b/UnitsNet.Tests/CustomCode/AreaTests.cs
index c917293d45..a4f791e35e 100644
--- a/UnitsNet.Tests/CustomCode/AreaTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaTests.cs
@@ -41,15 +41,15 @@ public class AreaTests : AreaTestsBase
         [Fact]
         public void AreaDividedByLengthEqualsLength()
         {
-            Length length = Area.FromSquareMeters(50)/Length.FromMeters(5);
-            Assert.Equal(length, Length.FromMeters(10));
+            var length = Area<double>.FromSquareMeters(50)/Length<double>.FromMeters(5);
+            Assert.Equal(length, Length<double>.FromMeters(10));
         }
 
         [Fact]
         public void AreaTimesMassFluxEqualsMassFlow()
         {
-            MassFlow massFlow = Area.FromSquareMeters(20) * MassFlux.FromKilogramsPerSecondPerSquareMeter(2);
-            Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(40));
+            var massFlow = Area<double>.FromSquareMeters(20) * MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
+            Assert.Equal(massFlow, MassFlow<double>.FromKilogramsPerSecond(40));
         }
 
         [Fact]
@@ -66,9 +66,9 @@ public void AreaTimesDensityEqualsLinearDensity()
         [InlineData(2, 3.141592653589793)]
         public void AreaFromCicleDiameterCalculatedCorrectly(double diameterMeters, double expected)
         {
-            Length diameter = Length.FromMeters(diameterMeters);
+            var diameter = Length<double>.FromMeters(diameterMeters);
 
-            double actual = Area.FromCircleDiameter(diameter).SquareMeters;
+            double actual = Area<double>.FromCircleDiameter(diameter).SquareMeters;
 
             Assert.Equal(expected, actual);
         }
@@ -80,9 +80,9 @@ public void AreaFromCicleDiameterCalculatedCorrectly(double diameterMeters, doub
         [InlineData(2, 12.566370614359173)]
         public void AreaFromCicleRadiusCalculatedCorrectly(double radiusMeters, double expected)
         {
-            Length radius = Length.FromMeters(radiusMeters);
+            var radius = Length<double>.FromMeters(radiusMeters);
 
-            double actual = Area.FromCircleRadius(radius).SquareMeters;
+            double actual = Area<double>.FromCircleRadius(radius).SquareMeters;
 
             Assert.Equal(expected, actual);
         }
@@ -90,28 +90,28 @@ public void AreaFromCicleRadiusCalculatedCorrectly(double radiusMeters, double e
         [Fact]
         public void AreaTimesSpeedEqualsVolumeFlow()
         {
-            VolumeFlow volumeFlow = Area.FromSquareMeters(20) * Speed.FromMetersPerSecond(2);
-            Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(40), volumeFlow);
+            var volumeFlow = Area<double>.FromSquareMeters(20) * Speed<double>.FromMetersPerSecond(2);
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerSecond(40), volumeFlow);
         }
 
         [Fact]
         public void Constructor_UnitSystemSI_AssignsSIUnit()
         {
-            var area = new Area(1.0, UnitSystem.SI);
+            var area = new Area<double>(1.0, UnitSystem.SI);
             Assert.Equal(AreaUnit.SquareMeter, area.Unit);
         }
 
         [Fact]
         public void As_GivenSIUnitSystem_ReturnsSIValue()
         {
-            var squareInches = new Area(2.0, AreaUnit.SquareInch);
+            var squareInches = new Area<double>(2.0, AreaUnit.SquareInch);
             Assert.Equal(0.00129032, squareInches.As(UnitSystem.SI));
         }
 
         [Fact]
         public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         {
-            var squareInches = new Area(2.0, AreaUnit.SquareInch);
+            var squareInches = new Area<double>(2.0, AreaUnit.SquareInch);
 
             var inSI = squareInches.ToUnit(UnitSystem.SI);
 
diff --git a/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs b/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs
index 3079c5d0d6..25399c28cc 100644
--- a/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs
+++ b/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs
@@ -19,21 +19,21 @@ public class BrakeSpecificFuelConsumptionTests : BrakeSpecificFuelConsumptionTes
         [Fact]
         public void PowerTimesBrakeSpecificFuelConsumptionEqualsMassFlow()
         {
-            MassFlow massFlow = BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(180.0) * Power.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0);
+            var massFlow = BrakeSpecificFuelConsumption<double>.FromGramsPerKiloWattHour(180.0) * Power<double>.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0);
             AssertEx.EqualTolerance(20.0, massFlow.TonnesPerDay, 1e-11);
         }
 
         [Fact]
         public void DoubleDividedByBrakeSpecificFuelConsumptionEqualsSpecificEnergy()
         {
-            SpecificEnergy massFlow = 2.0 / BrakeSpecificFuelConsumption.FromKilogramsPerJoule(4.0);
-            Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(0.5), massFlow);
+            var specificEnergy = 2.0 / BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(4.0);
+            Assert.Equal(SpecificEnergy<double>.FromJoulesPerKilogram(0.5), specificEnergy);
         }
 
         [Fact]
         public void BrakeSpecificFuelConsumptionTimesSpecificEnergyEqualsEnergy()
         {
-            double value = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(20.0) * SpecificEnergy.FromJoulesPerKilogram(10.0);
+            double value = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(20.0) * SpecificEnergy<double>.FromJoulesPerKilogram(10.0);
             Assert.Equal(200.0, value);
         }
     }
diff --git a/UnitsNet.Tests/CustomCode/DensityTests.cs b/UnitsNet.Tests/CustomCode/DensityTests.cs
index 8e61cb8225..8ad6fc10da 100644
--- a/UnitsNet.Tests/CustomCode/DensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/DensityTests.cs
@@ -92,36 +92,36 @@ public class DensityTests : DensityTestsBase
         [Fact]
         public static void DensityTimesVolumeEqualsMass()
         {
-            Mass mass = Density.FromKilogramsPerCubicMeter(2) * Volume.FromCubicMeters(3);
-            Assert.Equal(mass, Mass.FromKilograms(6));
+            var mass = Density<double>.FromKilogramsPerCubicMeter(2) * Volume<double>.FromCubicMeters(3);
+            Assert.Equal(mass, Mass<double>.FromKilograms(6));
         }
 
         [Fact]
         public static void VolumeTimesDensityEqualsMass()
         {
-            Mass mass = Volume.FromCubicMeters(3) * Density.FromKilogramsPerCubicMeter(2);
-            Assert.Equal(mass, Mass.FromKilograms(6));
+            var mass = Volume<double>.FromCubicMeters(3) * Density<double>.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(mass, Mass<double>.FromKilograms(6));
         }
 
         [Fact]
         public static void DensityTimesKinematicViscosityEqualsDynamicViscosity()
         {
-            DynamicViscosity dynamicViscosity = Density.FromKilogramsPerCubicMeter(2) * KinematicViscosity.FromSquareMetersPerSecond(10);
-            Assert.Equal(dynamicViscosity, DynamicViscosity.FromNewtonSecondsPerMeterSquared(20));
+            var dynamicViscosity = Density<double>.FromKilogramsPerCubicMeter(2) * KinematicViscosity<double>.FromSquareMetersPerSecond(10);
+            Assert.Equal(dynamicViscosity, DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(20));
         }
 
         [Fact]
         public void DensityTimesSpeedEqualsMassFlux()
         {
-            MassFlux massFlux = Density.FromKilogramsPerCubicMeter(20) * Speed.FromMetersPerSecond(2);
-            Assert.Equal(massFlux, MassFlux.FromKilogramsPerSecondPerSquareMeter(40));
+            var massFlux = Density<double>.FromKilogramsPerCubicMeter(20) * Speed<double>.FromMetersPerSecond(2);
+            Assert.Equal(massFlux, MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(40));
         }
 
         [Fact]
         public void DensityTimesAccelerationEqualsSpecificWeight()
         {
-            SpecificWeight specificWeight = Density.FromKilogramsPerCubicMeter(10) * Acceleration.FromMetersPerSecondSquared(2);
-            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(20), specificWeight);
+            var specificWeight = Density<double>.FromKilogramsPerCubicMeter(10) * Acceleration<double>.FromMetersPerSecondSquared(2);
+            Assert.Equal(SpecificWeight<double>.FromNewtonsPerCubicMeter(20), specificWeight);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/CustomCode/DurationTests.cs b/UnitsNet.Tests/CustomCode/DurationTests.cs
index 9c7a6fbe92..0f24a2b405 100644
--- a/UnitsNet.Tests/CustomCode/DurationTests.cs
+++ b/UnitsNet.Tests/CustomCode/DurationTests.cs
@@ -34,138 +34,138 @@ public class DurationTests : DurationTestsBase
         [Fact]
         public static void ToTimeSpanShouldThrowExceptionOnValuesLargerThanTimeSpanMax()
         {
-            Duration duration = Duration.FromSeconds(TimeSpan.MaxValue.TotalSeconds + 1);
+            var duration = Duration<double>.FromSeconds(TimeSpan.MaxValue.TotalSeconds + 1);
             Assert.Throws<ArgumentOutOfRangeException>(() => duration.ToTimeSpan());
         }
 
         [Fact]
         public static void ToTimeSpanShouldThrowExceptionOnValuesSmallerThanTimeSpanMin()
         {
-            Duration duration = Duration.FromSeconds(TimeSpan.MinValue.TotalSeconds - 1);
+            var duration = Duration<double>.FromSeconds(TimeSpan.MinValue.TotalSeconds - 1);
             Assert.Throws<ArgumentOutOfRangeException>(() => duration.ToTimeSpan());
         }
 
         [Fact]
         public static void ToTimeSpanShouldNotThrowExceptionOnValuesSlightlyLargerThanTimeSpanMin()
         {
-            Duration duration = Duration.FromSeconds(TimeSpan.MinValue.TotalSeconds + 1);
-            TimeSpan timeSpan = duration.ToTimeSpan();
+            var duration = Duration<double>.FromSeconds(TimeSpan.MinValue.TotalSeconds + 1);
+            var timeSpan = duration.ToTimeSpan();
             AssertEx.EqualTolerance(duration.Seconds, timeSpan.TotalSeconds, 1e-3);
         }
 
         [Fact]
         public static void ToTimeSpanShouldNotThrowExceptionOnValuesSlightlySmallerThanTimeSpanMax()
         {
-            Duration duration = Duration.FromSeconds(TimeSpan.MaxValue.TotalSeconds - 1);
-            TimeSpan timeSpan = duration.ToTimeSpan();
+            var duration = Duration<double>.FromSeconds(TimeSpan.MaxValue.TotalSeconds - 1);
+            var timeSpan = duration.ToTimeSpan();
             AssertEx.EqualTolerance(duration.Seconds, timeSpan.TotalSeconds, 1e-3);
         }
 
         [Fact]
         public static void ExplicitCastToTimeSpanShouldReturnSameValue()
         {
-            Duration duration = Duration.FromSeconds(60);
-            TimeSpan timeSpan = (TimeSpan)duration;
+            var duration = Duration<double>.FromSeconds(60);
+            var timeSpan = (TimeSpan)duration;
             AssertEx.EqualTolerance(duration.Seconds, timeSpan.TotalSeconds, 1e-10);
         }
 
         [Fact]
         public static void ExplicitCastToDurationShouldReturnSameValue()
         {
-            TimeSpan timeSpan = TimeSpan.FromSeconds(60);
-            Duration duration = (Duration)timeSpan;
+            var timeSpan = TimeSpan.FromSeconds(60);
+            var duration = (Duration<double>)timeSpan;
             AssertEx.EqualTolerance(timeSpan.TotalSeconds, duration.Seconds, 1e-10);
         }
 
         [Fact]
         public static void DateTimePlusDurationReturnsDateTime()
         {
-            DateTime dateTime = new DateTime(2016, 1, 1);
-            Duration oneDay = Duration.FromDays(1);
-            DateTime result = dateTime + oneDay;
-            DateTime expected = new DateTime(2016, 1, 2);
+            var dateTime = new DateTime(2016, 1, 1);
+            var oneDay = Duration<double>.FromDays(1);
+            var result = dateTime + oneDay;
+            var expected = new DateTime(2016, 1, 2);
             Assert.Equal(expected, result);
         }
 
         [Fact]
         public static void DateTimeMinusDurationReturnsDateTime()
         {
-            DateTime dateTime = new DateTime(2016, 1, 2);
-            Duration oneDay = Duration.FromDays(1);
-            DateTime result = dateTime - oneDay;
-            DateTime expected = new DateTime(2016, 1, 1);
+            var dateTime = new DateTime(2016, 1, 2);
+            var oneDay = Duration<double>.FromDays(1);
+            var result = dateTime - oneDay;
+            var expected = new DateTime(2016, 1, 1);
             Assert.Equal(expected, result);
         }
 
         [Fact]
         public static void TimeSpanLessThanDurationShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(10);
-            Duration duration = Duration.FromHours(11);
+            var timeSpan = TimeSpan.FromHours(10);
+            var duration = Duration<double>.FromHours(11);
             Assert.True(timeSpan < duration, "timeSpan should be less than duration");
         }
 
         [Fact]
         public static void TimeSpanGreaterThanDurationShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(12);
-            Duration duration = Duration.FromHours(11);
+            var timeSpan = TimeSpan.FromHours(12);
+            var duration = Duration<double>.FromHours(11);
             Assert.True(timeSpan > duration, "timeSpan should be greater than duration");
         }
 
         [Fact]
         public static void DurationLessThanTimeSpanShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(11);
-            Duration duration = Duration.FromHours(10);
+            var timeSpan = TimeSpan.FromHours(11);
+            var duration = Duration<double>.FromHours(10);
             Assert.True(duration < timeSpan, "duration should be less than timeSpan");
         }
 
         [Fact]
         public static void DurationGreaterThanTimeSpanShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(11);
-            Duration duration = Duration.FromHours(12);
+            var timeSpan = TimeSpan.FromHours(11);
+            var duration = Duration<double>.FromHours(12);
             Assert.True(duration > timeSpan, "duration should be greater than timeSpan");
         }
 
         [Fact]
         public static void TimeSpanLessOrEqualThanDurationShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(10);
-            Duration duration = Duration.FromHours(11);
+            var timeSpan = TimeSpan.FromHours(10);
+            var duration = Duration<double>.FromHours(11);
             Assert.True(timeSpan <= duration, "timeSpan should be less than duration");
         }
 
         [Fact]
         public static void TimeSpanGreaterThanOrEqualDurationShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(12);
-            Duration duration = Duration.FromHours(11);
+            var timeSpan = TimeSpan.FromHours(12);
+            var duration = Duration<double>.FromHours(11);
             Assert.True(timeSpan >= duration, "timeSpan should be greater than duration");
         }
 
         [Fact]
         public static void DurationLessThanOrEqualTimeSpanShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(11);
-            Duration duration = Duration.FromHours(10);
+            var timeSpan = TimeSpan.FromHours(11);
+            var duration = Duration<double>.FromHours(10);
             Assert.True(duration <= timeSpan, "duration should be less than timeSpan");
         }
 
         [Fact]
         public static void DurationGreaterThanOrEqualTimeSpanShouldReturnCorrectly()
         {
-            TimeSpan timeSpan = TimeSpan.FromHours(11);
-            Duration duration = Duration.FromHours(12);
+            var timeSpan = TimeSpan.FromHours(11);
+            var duration = Duration<double>.FromHours(12);
             Assert.True(duration >= timeSpan, "duration should be greater than timeSpan");
         }
 
         [Fact]
         public void DurationTimesVolumeFlowEqualsVolume()
         {
-            Volume volume = Duration.FromSeconds(20) * VolumeFlow.FromCubicMetersPerSecond(2);
-            Assert.Equal(Volume.FromCubicMeters(40), volume);
+            var volume = Duration<double>.FromSeconds(20) * VolumeFlow<double>.FromCubicMetersPerSecond(2);
+            Assert.Equal(Volume<double>.FromCubicMeters(40), volume);
         }
 
         [Theory]
@@ -181,7 +181,7 @@ public void DurationFromStringUsingMultipleAbbreviationsParsedCorrectly(string t
         {
             var cultureInfo = culture == null ? null : new CultureInfo(culture);
 
-            AssertEx.EqualTolerance(expectedSeconds, Duration.Parse(textValue, cultureInfo).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(expectedSeconds, Duration<double>.Parse(textValue, cultureInfo).Seconds, SecondsTolerance);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs b/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs
index 73efb62140..d81da2a47e 100644
--- a/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs
+++ b/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs
@@ -24,8 +24,8 @@ public class DynamicViscosityTests : DynamicViscosityTestsBase
         [Fact]
         public static void DynamicViscosityDividedByDensityEqualsKinematicViscosity()
         {
-            KinematicViscosity kinematicViscosity = DynamicViscosity.FromNewtonSecondsPerMeterSquared(10) / Density.FromKilogramsPerCubicMeter(2);
-            Assert.Equal(kinematicViscosity, KinematicViscosity.FromSquareMetersPerSecond(5));
+            var kinematicViscosity = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(10) / Density<double>.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(kinematicViscosity, KinematicViscosity<double>.FromSquareMetersPerSecond(5));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/EnergyTests.cs b/UnitsNet.Tests/CustomCode/EnergyTests.cs
index ae058ba101..296b0cccae 100644
--- a/UnitsNet.Tests/CustomCode/EnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/EnergyTests.cs
@@ -84,21 +84,21 @@ public class EnergyTests : EnergyTestsBase
         [Fact]
         public void Constructor_UnitSystemSI_AssignsSIUnit()
         {
-            var energy = new Energy(1.0, UnitSystem.SI);
+            var energy = new Energy<double>(1.0, UnitSystem.SI);
             Assert.Equal(EnergyUnit.Joule, energy.Unit);
         }
 
         [Fact]
         public void As_GivenSIUnitSystem_ReturnsSIValue()
         {
-            var btus = new Energy(2.0, EnergyUnit.BritishThermalUnit);
+            var btus = new Energy<double>(2.0, EnergyUnit.BritishThermalUnit);
             Assert.Equal(2110.11170524, btus.As(UnitSystem.SI));
         }
 
         [Fact]
         public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         {
-            var btus = new Energy(2.0, EnergyUnit.BritishThermalUnit);
+            var btus = new Energy<double>(2.0, EnergyUnit.BritishThermalUnit);
 
             var inSI = btus.ToUnit(UnitSystem.SI);
 
diff --git a/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs b/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
index a9050dfeb8..2f5ade6296 100644
--- a/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
@@ -66,22 +66,22 @@ public class ForcePerLengthTests : ForcePerLengthTestsBase
         [Fact]
         public void ForcePerLengthDividedByLengthEqualsPressure()
         {
-            Pressure pressure = ForcePerLength.FromNewtonsPerMeter(90) / Length.FromMeters(9);
-            Assert.Equal(pressure, Pressure.FromNewtonsPerSquareMeter(10));
+            var pressure = ForcePerLength<double>.FromNewtonsPerMeter(90) / Length<double>.FromMeters(9);
+            Assert.Equal(pressure, Pressure<double>.FromNewtonsPerSquareMeter(10));
         }
 
         [Fact]
         public void ForceDividedByForcePerLengthEqualsLength()
         {
-            Length length = Force.FromNewtons(10) / ForcePerLength.FromNewtonsPerMeter(2);
-            Assert.Equal(length, Length.FromMeters(5));
+            var length = Force<double>.FromNewtons(10) / ForcePerLength<double>.FromNewtonsPerMeter(2);
+            Assert.Equal(length, Length<double>.FromMeters(5));
         }
 
         [Fact]
         public void ForcePerLengthTimesLengthEqualForce()
         {
-            Force force = ForcePerLength.FromNewtonsPerMeter(10) * Length.FromMeters(9);
-            Assert.Equal(force, Force.FromNewtons(90));
+            var force = ForcePerLength<double>.FromNewtonsPerMeter(10) * Length<double>.FromMeters(9);
+            Assert.Equal(force, Force<double>.FromNewtons(90));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs
index e87ed077c5..c074e4c7fa 100644
--- a/UnitsNet.Tests/CustomCode/ForceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceTests.cs
@@ -38,57 +38,57 @@ public class ForceTests : ForceTestsBase
         [Fact]
         public void ForceDividedByAreaEqualsPressure()
         {
-            Pressure pressure = Force.FromNewtons(90)/Area.FromSquareMeters(9);
-            Assert.Equal(pressure, Pressure.FromNewtonsPerSquareMeter(10));
+            var pressure = Force<double>.FromNewtons(90)/Area<double>.FromSquareMeters(9);
+            Assert.Equal(pressure, Pressure<double>.FromNewtonsPerSquareMeter(10));
         }
 
         [Fact]
         public void PressureByAreaEqualsForce()
         {
-            Force force = Force.FromPressureByArea(Pressure.FromNewtonsPerSquareMeter(5), Area.FromSquareMeters(7));
-            Assert.Equal(force, Force.FromNewtons(35));
+            var force = Force<double>.FromPressureByArea(Pressure<double>.FromNewtonsPerSquareMeter(5), Area<double>.FromSquareMeters(7));
+            Assert.Equal(force, Force<double>.FromNewtons(35));
         }
 
         [Fact]
         public void ForceDividedByMassEqualsAcceleration()
         {
-            Acceleration acceleration = Force.FromNewtons(27)/Mass.FromKilograms(9);
-            Assert.Equal(acceleration, Acceleration.FromMetersPerSecondSquared(3));
+            var acceleration = Force<double>.FromNewtons(27)/Mass<double>.FromKilograms(9);
+            Assert.Equal(acceleration, Acceleration<double>.FromMetersPerSecondSquared(3));
         }
 
         [Fact]
         public void ForceDividedByAccelerationEqualsMass()
         {
-          Mass acceleration = Force.FromNewtons(200)/Acceleration.FromMetersPerSecondSquared(50);
-          Assert.Equal(acceleration, Mass.FromKilograms(4));
+          var mass = Force<double>.FromNewtons(200)/Acceleration<double>.FromMetersPerSecondSquared(50);
+          Assert.Equal(mass, Mass<double>.FromKilograms(4));
         }
 
         [Fact]
         public void ForceDividedByLengthEqualsForcePerLength()
         {
-            ForcePerLength forcePerLength = Force.FromNewtons(200) / Length.FromMeters(50);
-            Assert.Equal(forcePerLength, ForcePerLength.FromNewtonsPerMeter(4));
+            var forcePerLength = Force<double>.FromNewtons(200) / Length<double>.FromMeters(50);
+            Assert.Equal(forcePerLength, ForcePerLength<double>.FromNewtonsPerMeter(4));
         }
 
         [Fact]
         public void MassByAccelerationEqualsForce()
         {
-            Force force = Force.FromMassByAcceleration(Mass.FromKilograms(85), Acceleration.FromMetersPerSecondSquared(-4));
-            Assert.Equal(force, Force.FromNewtons(-340));
+            var force = Force<double>.FromMassByAcceleration(Mass<double>.FromKilograms(85), Acceleration<double>.FromMetersPerSecondSquared(-4));
+            Assert.Equal(force, Force<double>.FromNewtons(-340));
         }
 
         [Fact]
         public void ForceTimesSpeedEqualsPower()
         {
-            Power power = Force.FromNewtons(27.0)*Speed.FromMetersPerSecond(10.0);
-            Assert.Equal(power, Power.FromWatts(270));
+            var power = Force<double>.FromNewtons(27.0)*Speed<double>.FromMetersPerSecond(10.0);
+            Assert.Equal(power, Power<double>.FromWatts(270));
         }
 
         [Fact]
         public void SpeedTimesForceEqualsPower()
         {
-            Power power = Speed.FromMetersPerSecond(10.0)*Force.FromNewtons(27.0);
-            Assert.Equal(power, Power.FromWatts(270));
+            var power = Speed<double>.FromMetersPerSecond(10.0)*Force<double>.FromNewtons(27.0);
+            Assert.Equal(power, Power<double>.FromWatts(270));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/HeatFluxTests.cs b/UnitsNet.Tests/CustomCode/HeatFluxTests.cs
index 0c9b742538..df2a30686c 100644
--- a/UnitsNet.Tests/CustomCode/HeatFluxTests.cs
+++ b/UnitsNet.Tests/CustomCode/HeatFluxTests.cs
@@ -51,22 +51,22 @@ public class HeatFluxTests : HeatFluxTestsBase
         [ Fact]
         public void PowerDividedByAreaEqualsHeatFlux()
         {
-           HeatFlux heatFlux = Power.FromWatts(12) / Area.FromSquareMeters(3);
-           Assert.Equal(heatFlux, HeatFlux.FromWattsPerSquareMeter(4));
+           var heatFlux = Power<double>.FromWatts(12) / Area<double>.FromSquareMeters(3);
+           Assert.Equal(heatFlux, HeatFlux<double>.FromWattsPerSquareMeter(4));
         }
 
         [Fact]
         public void HeatFluxTimesAreaEqualsPower()
         {
-            Power power = HeatFlux.FromWattsPerSquareMeter(3) * Area.FromSquareMeters(4);
-            Assert.Equal(power, Power.FromWatts(12));
+            var power = HeatFlux<double>.FromWattsPerSquareMeter(3) * Area<double>.FromSquareMeters(4);
+            Assert.Equal(power, Power<double>.FromWatts(12));
         }
 
         [Fact]
         public void PowerDividedByHeatFluxEqualsArea()
         {
-            Area area = Power.FromWatts(12) / HeatFlux.FromWattsPerSquareMeter(3);
-            Assert.Equal(area, Area.FromSquareMeters(4));
+            var area = Power<double>.FromWatts(12) / HeatFlux<double>.FromWattsPerSquareMeter(3);
+            Assert.Equal(area, Area<double>.FromSquareMeters(4));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/IQuantityTests.cs b/UnitsNet.Tests/CustomCode/IQuantityTests.cs
index 9eda6cd2e8..f934934b11 100644
--- a/UnitsNet.Tests/CustomCode/IQuantityTests.cs
+++ b/UnitsNet.Tests/CustomCode/IQuantityTests.cs
@@ -12,42 +12,42 @@ public partial class IQuantityTests
         [Fact]
         public void As_GivenWrongUnitType_ThrowsArgumentException()
         {
-            IQuantity length = Length.FromMeters(1.2345);
+            IQuantity length = Length<double>.FromMeters(1.2345);
             Assert.Throws<ArgumentException>(() => length.As(MassUnit.Kilogram));
         }
 
         [Fact]
         public void As_GivenNullUnitSystem_ThrowsArgumentNullException()
         {
-            IQuantity imperialLengthQuantity = new Length(2.0, LengthUnit.Inch);
+            IQuantity imperialLengthQuantity = new Length<double>(2.0, LengthUnit.Inch);
             Assert.Throws<ArgumentNullException>(() => imperialLengthQuantity.As((UnitSystem)null));
         }
 
         [Fact]
         public void As_GivenSIUnitSystem_ReturnsSIValue()
         {
-            IQuantity inches = new Length(2.0, LengthUnit.Inch);
+            IQuantity inches = new Length<double>(2.0, LengthUnit.Inch);
             Assert.Equal(0.0508, inches.As(UnitSystem.SI));
         }
 
         [Fact]
         public void ToUnit_GivenWrongUnitType_ThrowsArgumentException()
         {
-            IQuantity length = Length.FromMeters(1.2345);
+            IQuantity length = Length<double>.FromMeters(1.2345);
             Assert.Throws<ArgumentException>(() => length.ToUnit(MassUnit.Kilogram));
         }
 
         [Fact]
         public void ToUnit_GivenNullUnitSystem_ThrowsArgumentNullException()
         {
-            IQuantity imperialLengthQuantity = new Length(2.0, LengthUnit.Inch);
+            IQuantity imperialLengthQuantity = new Length<double>(2.0, LengthUnit.Inch);
             Assert.Throws<ArgumentNullException>(() => imperialLengthQuantity.ToUnit((UnitSystem)null));
         }
 
         [Fact]
         public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         {
-            IQuantity inches = new Length(2.0, LengthUnit.Inch);
+            IQuantity inches = new Length<double>(2.0, LengthUnit.Inch);
 
             IQuantity inSI = inches.ToUnit(UnitSystem.SI);
 
diff --git a/UnitsNet.Tests/CustomCode/InformationTests.cs b/UnitsNet.Tests/CustomCode/InformationTests.cs
index a65933ef4b..7d03c63f41 100644
--- a/UnitsNet.Tests/CustomCode/InformationTests.cs
+++ b/UnitsNet.Tests/CustomCode/InformationTests.cs
@@ -65,19 +65,19 @@ public class InformationTests : InformationTestsBase
         [Fact]
         public void OneKBHas1000Bytes()
         {
-            Assert.Equal(1000, Information.FromKilobytes(1).Bytes);
+            Assert.Equal(1000, Information<decimal>.FromKilobytes(1).Bytes);
         }
 
         [Fact]
         public void MaxValueIsCorrectForUnitWithBaseTypeDecimal()
         {
-            Assert.Equal((double) decimal.MaxValue, Information.MaxValue.Bits);
+            Assert.Equal((double) decimal.MaxValue, Information<decimal>.MaxValue.Bits);
         }
 
         [Fact]
         public void MinValueIsCorrectForUnitWithBaseTypeDecimal()
         {
-            Assert.Equal((double) decimal.MinValue, Information.MinValue.Bits);
+            Assert.Equal((double) decimal.MinValue, Information<decimal>.MinValue.Bits);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs b/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
index 601ac84bda..ef5864f7e2 100644
--- a/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
+++ b/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
@@ -29,43 +29,43 @@ public class KinematicViscosityTests : KinematicViscosityTestsBase
         [Fact]
         public static void DurationTimesKinematicViscosityEqualsArea()
         {
-            Area area = Duration.FromSeconds(2)*KinematicViscosity.FromSquareMetersPerSecond(4);
-            Assert.Equal(area, Area.FromSquareMeters(8));
+            var area = Duration<double>.FromSeconds(2)*KinematicViscosity<double>.FromSquareMetersPerSecond(4);
+            Assert.Equal(area, Area<double>.FromSquareMeters(8));
         }
 
         [Fact]
         public static void KinematicViscosityDividedByLengthEqualsSpeed()
         {
-            Speed speed = KinematicViscosity.FromSquareMetersPerSecond(4)/Length.FromMeters(2);
-            Assert.Equal(speed, Speed.FromMetersPerSecond(2));
+            var speed = KinematicViscosity<double>.FromSquareMetersPerSecond(4)/Length<double>.FromMeters(2);
+            Assert.Equal(speed, Speed<double>.FromMetersPerSecond(2));
         }
 
         [Fact]
         public static void KinematicViscosityTimesDurationEqualsArea()
         {
-            Area area = KinematicViscosity.FromSquareMetersPerSecond(4)*Duration.FromSeconds(2);
-            Assert.Equal(area, Area.FromSquareMeters(8));
+            var area = KinematicViscosity<double>.FromSquareMetersPerSecond(4)*Duration<double>.FromSeconds(2);
+            Assert.Equal(area, Area<double>.FromSquareMeters(8));
         }
 
         [Fact]
         public static void KinematicViscosityTimesTimeSpanEqualsArea()
         {
-            Area area = KinematicViscosity.FromSquareMetersPerSecond(4)*TimeSpan.FromSeconds(2);
-            Assert.Equal(area, Area.FromSquareMeters(8));
+            var area = KinematicViscosity<double>.FromSquareMetersPerSecond(4)*TimeSpan.FromSeconds(2);
+            Assert.Equal(area, Area<double>.FromSquareMeters(8));
         }
 
         [Fact]
         public static void TimeSpanTimesKinematicViscosityEqualsArea()
         {
-            Area area = TimeSpan.FromSeconds(2)*KinematicViscosity.FromSquareMetersPerSecond(4);
-            Assert.Equal(area, Area.FromSquareMeters(8));
+            var area = TimeSpan.FromSeconds(2)*KinematicViscosity<double>.FromSquareMetersPerSecond(4);
+            Assert.Equal(area, Area<double>.FromSquareMeters(8));
         }
 
         [Fact]
         public static void KinematicViscosityTimesDensityEqualsDynamicViscosity()
         {
-            DynamicViscosity dynamicViscosity = KinematicViscosity.FromSquareMetersPerSecond(10) * Density.FromKilogramsPerCubicMeter(2);
-            Assert.Equal(dynamicViscosity, DynamicViscosity.FromNewtonSecondsPerMeterSquared(20));
+            var dynamicViscosity = KinematicViscosity<double>.FromSquareMetersPerSecond(10) * Density<double>.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(dynamicViscosity, DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(20));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/LapseRateTests.cs b/UnitsNet.Tests/CustomCode/LapseRateTests.cs
index 7701f7309b..d9ddbb5374 100644
--- a/UnitsNet.Tests/CustomCode/LapseRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/LapseRateTests.cs
@@ -34,29 +34,29 @@ public class LapseRateTests : LapseRateTestsBase
         [Fact]
         public void TemperatureDeltaDividedByLapseRateEqualsLength()
         {
-            Length length = TemperatureDelta.FromDegreesCelsius(50) / LapseRate.FromDegreesCelciusPerKilometer(5);
-            Assert.Equal(length, Length.FromKilometers(10));
+            var length = TemperatureDelta<double>.FromDegreesCelsius(50) / LapseRate<double>.FromDegreesCelciusPerKilometer(5);
+            Assert.Equal(length, Length<double>.FromKilometers(10));
         }
 
         [Fact]
         public void TemperatureDeltaDividedByLengthEqualsLapseRate()
         {
-            LapseRate lapseRate = TemperatureDelta.FromDegreesCelsius(50) / Length.FromKilometers(10);
-            Assert.Equal(lapseRate, LapseRate.FromDegreesCelciusPerKilometer(5));
+            var lapseRate = TemperatureDelta<double>.FromDegreesCelsius(50) / Length<double>.FromKilometers(10);
+            Assert.Equal(lapseRate, LapseRate<double>.FromDegreesCelciusPerKilometer(5));
         }
 
         [Fact]
         public void LengthMultipliedByLapseRateEqualsTemperatureDelta()
         {
-            TemperatureDelta temperatureDelta = Length.FromKilometers(10) * LapseRate.FromDegreesCelciusPerKilometer(5);
-            Assert.Equal(temperatureDelta, TemperatureDelta.FromDegreesCelsius(50));
+            var temperatureDelta = Length<double>.FromKilometers(10) * LapseRate<double>.FromDegreesCelciusPerKilometer(5);
+            Assert.Equal(temperatureDelta, TemperatureDelta<double>.FromDegreesCelsius(50));
         }
 
         [Fact]
         public void LapseRateMultipliedByLengthEqualsTemperatureDelta()
         {
-            TemperatureDelta temperatureDelta = LapseRate.FromDegreesCelciusPerKilometer(5) * Length.FromKilometers(10);
-            Assert.Equal(temperatureDelta, TemperatureDelta.FromDegreesCelsius(50));
+            var temperatureDelta = LapseRate<double>.FromDegreesCelciusPerKilometer(5) * Length<double>.FromKilometers(10);
+            Assert.Equal(temperatureDelta, TemperatureDelta<double>.FromDegreesCelsius(50));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs b/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs
index 911b9119e6..281e674cf7 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs
@@ -17,7 +17,7 @@ public class FeetInchesTests
         [Fact]
         public void FeetInchesFrom()
         {
-            Length meter = Length.FromFeetInches(2, 3);
+            var meter = Length<double>.FromFeetInches(2, 3);
             double expectedMeters = 2/FeetInOneMeter + 3/InchesInOneMeter;
             AssertEx.EqualTolerance(expectedMeters, meter.Meters, FeetTolerance);
         }
@@ -25,7 +25,7 @@ public void FeetInchesFrom()
         [Fact]
         public void FeetInchesRoundTrip()
         {
-            Length meter = Length.FromFeetInches(2, 3);
+            var meter = Length<double>.FromFeetInches(2, 3);
             FeetInches feetInches = meter.FeetInches;
             AssertEx.EqualTolerance(2, feetInches.Feet, FeetTolerance);
             AssertEx.EqualTolerance(3, feetInches.Inches, InchesTolerance);
@@ -75,7 +75,7 @@ public void FeetInchesRoundTrip()
         [MemberData(nameof(ValidData))]
         public void TryParseFeetInches(string str, double expectedFeet, CultureInfo formatProvider)
         {
-            Assert.True(Length.TryParseFeetInches(str, out Length result, formatProvider));
+            Assert.True(Length<double>.TryParseFeetInches(str, out Length<double> result, formatProvider));
             AssertEx.EqualTolerance(expectedFeet, result.Feet, 1e-5);
         }
 
@@ -103,8 +103,8 @@ public void TryParseFeetInches(string str, double expectedFeet, CultureInfo form
         [MemberData(nameof(InvalidData))]
         public void TryParseFeetInches_GivenInvalidString_ReturnsFalseAndZeroOut(string str, CultureInfo formatProvider)
         {
-            Assert.False(Length.TryParseFeetInches(str, out Length result, formatProvider));
-            Assert.Equal(Length.Zero, result);
+            Assert.False(Length<double>.TryParseFeetInches(str, out Length<double> result, formatProvider));
+            Assert.Equal(Length<double>.Zero, result);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
index 0f8e85ac88..20da6231fe 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -79,63 +79,63 @@ public class LengthTests : LengthTestsBase
         [ Fact]
         public void AreaTimesLengthEqualsVolume()
         {
-            Volume volume = Area.FromSquareMeters(10)*Length.FromMeters(3);
-            Assert.Equal(volume, Volume.FromCubicMeters(30));
+            var volume = Area<double>.FromSquareMeters(10)*Length<double>.FromMeters(3);
+            Assert.Equal(volume, Volume<double>.FromCubicMeters(30));
         }
 
         [Fact]
         public void ForceTimesLengthEqualsTorque()
         {
-            Torque torque = Force.FromNewtons(1)*Length.FromMeters(3);
-            Assert.Equal(torque, Torque.FromNewtonMeters(3));
+            var torque = Force<double>.FromNewtons(1)*Length<double>.FromMeters(3);
+            Assert.Equal(torque, Torque<double>.FromNewtonMeters(3));
         }
 
         [Fact]
         public void LengthTimesAreaEqualsVolume()
         {
-            Volume volume = Length.FromMeters(3)*Area.FromSquareMeters(9);
-            Assert.Equal(volume, Volume.FromCubicMeters(27));
+            var volume = Length<double>.FromMeters(3)*Area<double>.FromSquareMeters(9);
+            Assert.Equal(volume, Volume<double>.FromCubicMeters(27));
         }
 
         [Fact]
         public void LengthTimesForceEqualsTorque()
         {
-            Torque torque = Length.FromMeters(3)*Force.FromNewtons(1);
-            Assert.Equal(torque, Torque.FromNewtonMeters(3));
+            var torque = Length<double>.FromMeters(3)*Force<double>.FromNewtons(1);
+            Assert.Equal(torque, Torque<double>.FromNewtonMeters(3));
         }
 
         [Fact]
         public void LengthTimesLengthEqualsArea()
         {
-            Area area = Length.FromMeters(10)*Length.FromMeters(2);
-            Assert.Equal(area, Area.FromSquareMeters(20));
+            var area = Length<double>.FromMeters(10)*Length<double>.FromMeters(2);
+            Assert.Equal(area, Area<double>.FromSquareMeters(20));
         }
 
         [Fact]
         public void LengthDividedBySpeedEqualsDuration()
         {
-            Duration duration = Length.FromMeters(20) / Speed.FromMetersPerSecond(2);
-            Assert.Equal(Duration.FromSeconds(10), duration);
+            var duration = Length<double>.FromMeters(20) / Speed<double>.FromMetersPerSecond(2);
+            Assert.Equal(Duration<double>.FromSeconds(10), duration);
         }
 
         [Fact]
         public void LengthTimesSpeedEqualsKinematicViscosity()
         {
-            KinematicViscosity kinematicViscosity = Length.FromMeters(20) * Speed.FromMetersPerSecond(2);
-            Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(40), kinematicViscosity);
+            var kinematicViscosity = Length<double>.FromMeters(20) * Speed<double>.FromMetersPerSecond(2);
+            Assert.Equal(KinematicViscosity<double>.FromSquareMetersPerSecond(40), kinematicViscosity);
         }
 
         [Fact]
         public void LengthTimesSpecificWeightEqualsPressure()
         {
-            Pressure pressure = Length.FromMeters(2) * SpecificWeight.FromNewtonsPerCubicMeter(10);
-            Assert.Equal(Pressure.FromPascals(20), pressure);
+            var pressure = Length<double>.FromMeters(2) * SpecificWeight<double>.FromNewtonsPerCubicMeter(10);
+            Assert.Equal(Pressure<double>.FromPascals(20), pressure);
         }
 
         [Fact]
         public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnitWhichIsMeter()
         {
-            var meter = Length.FromMeters(5);
+            var meter = Length<double>.FromMeters(5);
             string meterString = meter.ToString();
             Assert.Equal("5 m", meterString);
         }
@@ -143,7 +143,7 @@ public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnitWhichIsMeter()
         [Fact]
         public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit()
         {
-            var value = Length.From(2, LengthUnit.Centimeter);
+            var value = Length<double>.From(2, LengthUnit.Centimeter);
             string valueString = value.ToString();
             Assert.Equal("2 cm", valueString);
         }
@@ -151,25 +151,25 @@ public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit()
         [Fact]
         public void MaxValueIsCorrectForUnitWithBaseTypeDouble()
         {
-            Assert.Equal(double.MaxValue, Length.MaxValue.Meters);
+            Assert.Equal(double.MaxValue, Length<double>.MaxValue.Meters);
         }
 
         [Fact]
         public void MinValueIsCorrectForUnitWithBaseTypeDouble()
         {
-            Assert.Equal(double.MinValue, Length.MinValue.Meters);
+            Assert.Equal(double.MinValue, Length<double>.MinValue.Meters);
         }
 
         [Fact]
         public void NegativeLengthToStonePoundsReturnsCorrectValues()
         {
-            var negativeLength = Length.FromInches(-1.0);
+            var negativeLength = Length<double>.FromInches(-1.0);
             var feetInches = negativeLength.FeetInches;
 
             Assert.Equal(0, feetInches.Feet);
             Assert.Equal(-1.0, feetInches.Inches);
 
-            negativeLength = Length.FromInches(-25.0);
+            negativeLength = Length<double>.FromInches(-25.0);
             feetInches = negativeLength.FeetInches;
 
             Assert.Equal(-2.0, feetInches.Feet);
@@ -179,13 +179,13 @@ public void NegativeLengthToStonePoundsReturnsCorrectValues()
         [Fact]
         public void Constructor_UnitSystemNull_ThrowsArgumentNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => new Length(1.0, (UnitSystem)null));
+            Assert.Throws<ArgumentNullException>(() => new Length<double>(1.0, (UnitSystem)null));
         }
 
         [Fact]
         public void Constructor_UnitSystemSI_AssignsSIUnit()
         {
-            var length = new Length(1.0, UnitSystem.SI);
+            var length = new Length<double>(1.0, UnitSystem.SI);
             Assert.Equal(LengthUnit.Meter, length.Unit);
         }
 
@@ -193,20 +193,20 @@ public void Constructor_UnitSystemSI_AssignsSIUnit()
         public void Constructor_UnitSystemWithNoMatchingBaseUnits_ThrowsArgumentException()
         {
             // AmplitudeRatio is unitless. Can't have any matches :)
-            Assert.Throws<ArgumentException>(() => new AmplitudeRatio(1.0, UnitSystem.SI));
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>( 1.0, UnitSystem.SI));
         }
 
         [Fact]
         public void As_GivenSIUnitSystem_ReturnsSIValue()
         {
-            var inches = new Length(2.0, LengthUnit.Inch);
+            var inches = new Length<double>(2.0, LengthUnit.Inch);
             Assert.Equal(0.0508, inches.As(UnitSystem.SI));
         }
 
         [Fact]
         public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         {
-            var inches = new Length(2.0, LengthUnit.Inch);
+            var inches = new Length<double>(2.0, LengthUnit.Inch);
 
             var inSI = inches.ToUnit(UnitSystem.SI);
 
diff --git a/UnitsNet.Tests/CustomCode/LevelTests.cs b/UnitsNet.Tests/CustomCode/LevelTests.cs
index a3af30a00e..197732dcde 100644
--- a/UnitsNet.Tests/CustomCode/LevelTests.cs
+++ b/UnitsNet.Tests/CustomCode/LevelTests.cs
@@ -15,14 +15,14 @@ public class LevelTests : LevelTestsBase
 
         protected override void AssertLogarithmicAddition()
         {
-            Level v = Level.FromDecibels(40);
+            var v = Level<double>.FromDecibels(40);
             AssertEx.EqualTolerance(43.0102999566, (v + v).Decibels, DecibelsTolerance);
         }
 
         protected override void AssertLogarithmicSubtraction()
         {
-            Level v = Level.FromDecibels(40);
-            AssertEx.EqualTolerance(49.5424250944, (Level.FromDecibels(50) - v).Decibels, DecibelsTolerance);
+            var v = Level<double>.FromDecibels(40);
+            AssertEx.EqualTolerance(49.5424250944, (Level<double>.FromDecibels(50) - v).Decibels, DecibelsTolerance);
         }
 
         [Theory]
@@ -31,7 +31,7 @@ protected override void AssertLogarithmicSubtraction()
         public void InvalidQuantity_ExpectArgumentOutOfRangeException(double quantity, double reference)
         {
             // quantity can't be zero or less than zero if reference is positive.
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Level(quantity, reference));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new Level<double>(quantity, reference));
         }
 
         [Theory]
@@ -40,7 +40,7 @@ public void InvalidQuantity_ExpectArgumentOutOfRangeException(double quantity, d
         public void InvalidReference_ExpectArgumentOutOfRangeException(double quantity, double reference)
         {
             // reference can't be zero or less than zero if quantity is postive.
-            Assert.Throws<ArgumentOutOfRangeException>(() => new Level(quantity, reference));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new Level<double>(quantity, reference));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs b/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
index f5d8091b9d..9a5153855f 100644
--- a/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
@@ -29,7 +29,6 @@ namespace UnitsNet.Tests.CustomCode
     public class MassConcentrationTests : MassConcentrationTestsBase
     {
         protected override bool SupportsSIUnitSystem => false;
-
         #region Unit Conversion Coefficients
         protected override double PicogramsPerLiterInOneKilogramPerCubicMeter => 1e12;
         protected override double PicogramsPerMicroliterInOneKilogramPerCubicMeter => 1e6;
@@ -90,10 +89,10 @@ public void MolarityFromMassConcentrationAndMolarMass(
             double molarMassValue, MolarMassUnit molarMassUnit,
             double expectedMolarityValue, MolarityUnit expectedMolarityUnit, double tolerance = 1e-5)
         {
-            var massConcentration = new MassConcentration(massConcValue, massConcUnit);
-            var molarMass = new MolarMass(molarMassValue, molarMassUnit);
+            var massConcentration = new MassConcentration<double>( massConcValue, massConcUnit);
+            var molarMass = new MolarMass<double>( molarMassValue, molarMassUnit);
 
-            Molarity molarity = massConcentration.ToMolarity(molarMass);     // molarity / molarMass
+            var molarity = massConcentration.ToMolarity(molarMass);     // molarity / molarMass
 
             AssertEx.EqualTolerance(expectedMolarityValue, molarity.As(expectedMolarityUnit), tolerance);
         }
@@ -107,10 +106,10 @@ public void VolumeConcentrationFromMassConcentrationAndDensity(
             double massConcValue, MassConcentrationUnit masConcUnit,
             double expectedVolumeConcValue, VolumeConcentrationUnit expectedVolumeConcUnit, double tolerence = 1e-5)
         {
-            var density = new Density(componentDensityValue, componentDensityUnit);
-            var massConcentration = new MassConcentration(massConcValue, masConcUnit);
+            var density = new Density<double>(componentDensityValue, componentDensityUnit);
+            var massConcentration = new MassConcentration<double>( massConcValue, masConcUnit);
 
-            VolumeConcentration volumeConcentration = massConcentration.ToVolumeConcentration(density); // massConcentration / density;
+            var volumeConcentration = massConcentration.ToVolumeConcentration(density); // massConcentration / density;
 
             AssertEx.EqualTolerance(expectedVolumeConcValue, volumeConcentration.As(expectedVolumeConcUnit), tolerence);
         }
@@ -124,11 +123,11 @@ public static void ComponentMassFromMassConcentrationAndSolutionVolume(
             double volumeValue, VolumeUnit volumeUnit,
             double expectedMassValue, MassUnit expectedMassUnit, double tolerance = 1e-5)
         {
-            var massConcentration = new MassConcentration(massConcValue, massConcUnit);
-            var volume = new Volume(volumeValue, volumeUnit);
-
-            Mass massComponent = massConcentration * volume;
+            var massConcentration = new MassConcentration<double>( massConcValue, massConcUnit);
+            var volume = new Volume<double>( volumeValue, volumeUnit);
 
+            var massComponent = massConcentration * volume;
+            
             AssertEx.EqualTolerance(expectedMassValue, massComponent.As(expectedMassUnit), tolerance);
         }
 
@@ -136,7 +135,7 @@ public static void ComponentMassFromMassConcentrationAndSolutionVolume(
         [Fact(Skip = "No BaseUnit defined: see https://github.com/angularsen/UnitsNet/issues/651")]
         public void DefaultSIUnitIsKgPerCubicMeter()
         {
-            var massConcentration = new MassConcentration(1, UnitSystem.SI);
+            var massConcentration = new MassConcentration<double>( 1, UnitSystem.SI);
 
             Assert.Equal(MassConcentrationUnit.KilogramPerCubicMeter, massConcentration.Unit); // MassConcentration.BaseUnit = KilogramPerCubicMeter
         }
@@ -147,7 +146,7 @@ public void DefaultUnitTypeRespectedForCustomUnitSystem()
             UnitSystem customSystem = new UnitSystem(new BaseUnits(LengthUnit.Millimeter, MassUnit.Gram, DurationUnit.Millisecond,
                 ElectricCurrentUnit.Ampere, TemperatureUnit.DegreeCelsius, AmountOfSubstanceUnit.Mole, LuminousIntensityUnit.Candela));
 
-            var massConcentration = new MassConcentration(1, customSystem);
+            var massConcentration = new MassConcentration<double>( 1, customSystem);
 
             Assert.Equal(MassConcentrationUnit.GramPerCubicMillimeter, massConcentration.Unit);
         }
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
index e59fa41f18..433e3286d1 100644
--- a/UnitsNet.Tests/CustomCode/MassFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -80,77 +80,77 @@ public class MassFlowTests : MassFlowTestsBase
         [Fact]
         public void DurationTimesMassFlowEqualsMass()
         {
-            Mass mass = Duration.FromSeconds(4.0) * MassFlow.FromKilogramsPerSecond(20.0);
-            Assert.Equal(mass, Mass.FromKilograms(80.0));
+            var mass = Duration<double>.FromSeconds(4.0) * MassFlow<double>.FromKilogramsPerSecond(20.0);
+            Assert.Equal(mass, Mass<double>.FromKilograms(80.0));
         }
 
         [Fact]
         public void MassFlowTimesDurationEqualsMass()
         {
-            Mass mass = MassFlow.FromKilogramsPerSecond(20.0) * Duration.FromSeconds(4.0);
-            Assert.Equal(mass, Mass.FromKilograms(80.0));
+            var mass = MassFlow<double>.FromKilogramsPerSecond(20.0) * Duration<double>.FromSeconds(4.0);
+            Assert.Equal(mass, Mass<double>.FromKilograms(80.0));
         }
 
         [Fact]
         public void MassFlowTimesTimeSpanEqualsMass()
         {
-            Mass mass = MassFlow.FromKilogramsPerSecond(20.0) * TimeSpan.FromSeconds(4.0);
-            Assert.Equal(mass, Mass.FromKilograms(80.0));
+            var mass = MassFlow<double>.FromKilogramsPerSecond(20.0) * TimeSpan.FromSeconds(4.0);
+            Assert.Equal(mass, Mass<double>.FromKilograms(80.0));
         }
 
         [Fact]
         public void TimeSpanTimesMassFlowEqualsMass()
         {
-            Mass mass = TimeSpan.FromSeconds(4.0) * MassFlow.FromKilogramsPerSecond(20.0);
-            Assert.Equal(mass, Mass.FromKilograms(80.0));
+            var mass = TimeSpan.FromSeconds(4.0) * MassFlow<double>.FromKilogramsPerSecond(20.0);
+            Assert.Equal(mass, Mass<double>.FromKilograms(80.0));
         }
 
         [Fact]
         public void MassFlowDividedByBrakeSpecificFuelConsumptionEqualsPower()
         {
-            Power power = MassFlow.FromTonnesPerDay(20) / BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(180.0);
+            var power = MassFlow<double>.FromTonnesPerDay(20) / BrakeSpecificFuelConsumption<double>.FromGramsPerKiloWattHour(180.0);
             Assert.Equal(20.0 / 24.0 * 1e6 / 180.0, power.Kilowatts);
         }
 
         [Fact]
         public void MassFlowDividedByPowerEqualsBrakeSpecificFuelConsumption()
         {
-            BrakeSpecificFuelConsumption bsfc = MassFlow.FromTonnesPerDay(20) / Power.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0);
+            var bsfc = MassFlow<double>.FromTonnesPerDay(20) / Power<double>.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0);
             AssertEx.EqualTolerance(180.0, bsfc.GramsPerKiloWattHour, 1e-11);
         }
 
         [Fact]
         public void MassFlowTimesSpecificEnergyEqualsPower()
         {
-            Power power = MassFlow.FromKilogramsPerSecond(20.0) * SpecificEnergy.FromJoulesPerKilogram(10.0);
+            var power = MassFlow<double>.FromKilogramsPerSecond(20.0) * SpecificEnergy<double>.FromJoulesPerKilogram(10.0);
             Assert.Equal(200, power.Watts);
         }
 
         [Fact]
         public void MassFlowDividedByAreaEqualsMassFlux()
         {
-            MassFlux massFlux = MassFlow.FromKilogramsPerSecond(20) / Area.FromSquareMeters(2);
+            var massFlux = MassFlow<double>.FromKilogramsPerSecond(20) / Area<double>.FromSquareMeters(2);
             Assert.Equal(10, massFlux.KilogramsPerSecondPerSquareMeter);
         }
 
         [Fact]
         public void MassFlowDividedByMassFluxEqualsArea()
         {
-            Area area = MassFlow.FromKilogramsPerSecond(20) / MassFlux.FromKilogramsPerSecondPerSquareMeter(2);
+            var area = MassFlow<double>.FromKilogramsPerSecond(20) / MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
             Assert.Equal(10, area.SquareMeters);
         }
 
         [Fact]
         public void MassFlowDividedByVolumeFlowEqualsDensity()
         {
-            Density density = MassFlow.FromKilogramsPerSecond(12) / VolumeFlow.FromCubicMetersPerSecond(3);
+            var density = MassFlow<double>.FromKilogramsPerSecond(12) / VolumeFlow<double>.FromCubicMetersPerSecond(3);
             Assert.Equal(4, density.KilogramsPerCubicMeter);
         }
 
         [Fact]
         public void MassFlowDividedByDensityEqualsVolumeFlow()
         {
-            VolumeFlow volumeFlow = MassFlow.FromKilogramsPerSecond(20) / Density.FromKilogramsPerCubicMeter(4);
+            var volumeFlow = MassFlow<double>.FromKilogramsPerSecond(20) / Density<double>.FromKilogramsPerCubicMeter(4);
             Assert.Equal(5, volumeFlow.CubicMetersPerSecond);
         }
     }
diff --git a/UnitsNet.Tests/CustomCode/MassFluxTests.cs b/UnitsNet.Tests/CustomCode/MassFluxTests.cs
index 99be1f8e51..5e105e9fef 100644
--- a/UnitsNet.Tests/CustomCode/MassFluxTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFluxTests.cs
@@ -47,22 +47,22 @@ public class MassFluxTests : MassFluxTestsBase
         [Fact]
         public void MassFluxDividedBySpeedEqualsDensity()
         {
-            Density density = MassFlux.FromKilogramsPerSecondPerSquareMeter(20) / Speed.FromMetersPerSecond(2);
-            Assert.Equal(density, Density.FromKilogramsPerCubicMeter(10));
+            var density = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(20) / Speed<double>.FromMetersPerSecond(2);
+            Assert.Equal(density, Density<double>.FromKilogramsPerCubicMeter(10));
         }
 
         [Fact]
         public void MassFluxDividedByDensityEqualsSpeed()
         {
-            Speed speed = MassFlux.FromKilogramsPerSecondPerSquareMeter(20) / Density.FromKilogramsPerCubicMeter(2);
-            Assert.Equal(speed, Speed.FromMetersPerSecond(10));
+            var speed = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(20) / Density<double>.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(speed, Speed<double>.FromMetersPerSecond(10));
         }
 
         [Fact]
         public void MassFluxTimesAreaEqualsMassFlow()
         {
-            MassFlow massFlow = MassFlux.FromKilogramsPerSecondPerSquareMeter(20) * Area.FromSquareMeters(2);
-            Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(40));
+            var massFlow = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(20) * Area<double>.FromSquareMeters(2);
+            Assert.Equal(massFlow, MassFlow<double>.FromKilogramsPerSecond(40));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/MassFractionTests.cs b/UnitsNet.Tests/CustomCode/MassFractionTests.cs
index 39435e7243..555cf487b8 100644
--- a/UnitsNet.Tests/CustomCode/MassFractionTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFractionTests.cs
@@ -62,10 +62,10 @@ public class MassFractionTests : MassFractionTestsBase
         [Fact]
         public void MassFractionFromMassesConstructedCorrectly()
         {
-            var one_kg = Mass.FromKilograms(1);
-            var two_kg = Mass.FromKilograms(2);
+            var one_kg = Mass<double>.FromKilograms(1);
+            var two_kg = Mass<double>.FromKilograms(2);
 
-            var massFraction = MassFraction.FromMasses(one_kg, two_kg);
+            var massFraction = MassFraction<double>.FromMasses(one_kg, two_kg);
 
             AssertEx.EqualTolerance(50, massFraction.Percent, PercentTolerance);
         }
@@ -73,8 +73,8 @@ public void MassFractionFromMassesConstructedCorrectly()
         [Fact]
         public void TotalMassFromMassFraction()
         {
-            var componentMass = Mass.FromKilograms(1);
-            var massFraction = MassFraction.FromPercent(50);
+            var componentMass = Mass<double>.FromKilograms(1);
+            var massFraction = MassFraction<double>.FromPercent(50);
 
             var totalMass = massFraction.GetTotalMass(componentMass);
 
@@ -84,8 +84,8 @@ public void TotalMassFromMassFraction()
         [Fact]
         public void ComponentMassFromMassFraction()
         {
-            var totalMass = Mass.FromKilograms(2);
-            var massFraction = MassFraction.FromPercent(50);
+            var totalMass = Mass<double>.FromKilograms(2);
+            var massFraction = MassFraction<double>.FromPercent(50);
 
             var componentMass = massFraction.GetComponentMass(totalMass);
 
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
index decfa077cf..351ed53eba 100644
--- a/UnitsNet.Tests/CustomCode/MassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -68,48 +68,48 @@ public class MassTests : MassTestsBase
         [Fact]
         public void AccelerationTimesMassEqualsForce()
         {
-            Force force = Acceleration.FromMetersPerSecondSquared(3)*Mass.FromKilograms(18);
-            Assert.Equal(force, Force.FromNewtons(54));
+            var force = Acceleration<double>.FromMetersPerSecondSquared(3)*Mass<double>.FromKilograms(18);
+            Assert.Equal(force, Force<double>.FromNewtons(54));
         }
 
         [Fact]
         public void MassDividedByDurationEqualsMassFlow()
         {
-            MassFlow massFlow = Mass.FromKilograms(18.0)/Duration.FromSeconds(6);
-            Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
+            var massFlow = Mass<double>.FromKilograms(18.0)/Duration<double>.FromSeconds(6);
+            Assert.Equal(massFlow, MassFlow<double>.FromKilogramsPerSecond(3.0));
         }
 
         [Fact]
         public void MassDividedByTimeSpanEqualsMassFlow()
         {
-            MassFlow massFlow = Mass.FromKilograms(18.0)/TimeSpan.FromSeconds(6);
-            Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
+            var massFlow = Mass<double>.FromKilograms(18.0)/TimeSpan.FromSeconds(6);
+            Assert.Equal(massFlow, MassFlow<double>.FromKilogramsPerSecond(3.0));
         }
 
         [Fact]
         public void MassDividedByVolumeEqualsDensity()
         {
-            Density density = Mass.FromKilograms(18)/Volume.FromCubicMeters(3);
-            Assert.Equal(density, Density.FromKilogramsPerCubicMeter(6));
+            var density = Mass<double>.FromKilograms(18)/Volume<double>.FromCubicMeters(3);
+            Assert.Equal(density, Density<double>.FromKilogramsPerCubicMeter(6));
         }
 
         [Fact]
         public void MassTimesAccelerationEqualsForce()
         {
-            Force force = Mass.FromKilograms(18)*Acceleration.FromMetersPerSecondSquared(3);
-            Assert.Equal(force, Force.FromNewtons(54));
+            var force = Mass<double>.FromKilograms(18)*Acceleration<double>.FromMetersPerSecondSquared(3);
+            Assert.Equal(force, Force<double>.FromNewtons(54));
         }
 
         [Fact]
         public void NegativeMassToStonePoundsReturnsCorrectValues()
         {
-            var negativeMass = Mass.FromPounds(-1.0);
+            var negativeMass = Mass<double>.FromPounds(-1.0);
             var stonePounds = negativeMass.StonePounds;
 
             Assert.Equal(0, stonePounds.Stone);
             Assert.Equal(-1.0, stonePounds.Pounds);
 
-            negativeMass = Mass.FromPounds(-25.0);
+            negativeMass = Mass<double>.FromPounds(-25.0);
             stonePounds = negativeMass.StonePounds;
 
             Assert.Equal(-1.0, stonePounds.Stone);
@@ -125,10 +125,10 @@ public void AmountOfSubstanceFromMassAndMolarMass(
             double molarMassValue, MolarMassUnit molarMassUnit,
             double expectedAmountOfSubstanceValue, AmountOfSubstanceUnit expectedAmountOfSubstanceUnit, double tolerence = 1e-5)
         {
-            var mass = new Mass(massValue, massUnit);
-            var molarMass = new MolarMass(molarMassValue, molarMassUnit);
+            var mass = new Mass<double>(massValue, massUnit);
+            var molarMass = new MolarMass<double>(molarMassValue, molarMassUnit);
 
-            AmountOfSubstance amountOfSubstance = mass / molarMass;
+            var amountOfSubstance = mass / molarMass;
 
             AssertEx.EqualTolerance(expectedAmountOfSubstanceValue, amountOfSubstance.As(expectedAmountOfSubstanceUnit), tolerence);
         }
diff --git a/UnitsNet.Tests/CustomCode/MolarityTests.cs b/UnitsNet.Tests/CustomCode/MolarityTests.cs
index 04150f0dca..46311f5da6 100644
--- a/UnitsNet.Tests/CustomCode/MolarityTests.cs
+++ b/UnitsNet.Tests/CustomCode/MolarityTests.cs
@@ -53,11 +53,11 @@ public void VolumeConcentrationFromComponentDensityAndMolarity(
             double componentMolarMassValue, MolarMassUnit compontMolarMassUnit,
             double expectedVolumeConcValue, VolumeConcentrationUnit expectedVolumeConcUnit, double tolerence = 1e-5)
         {
-            var molarity = new Molarity(molarityValue, molarityUnit);
-            var componentDensity = new Density(componentDensityValue, componentDensityUnit);
-            var componentMolarMass = new MolarMass(componentMolarMassValue, compontMolarMassUnit);
+            var molarity = new Molarity<double>( molarityValue, molarityUnit);
+            var componentDensity = new Density<double>( componentDensityValue, componentDensityUnit);
+            var componentMolarMass = new MolarMass<double>( componentMolarMassValue, compontMolarMassUnit);
 
-            VolumeConcentration volumeConcentration = molarity.ToVolumeConcentration(componentDensity, componentMolarMass);
+            var volumeConcentration = molarity.ToVolumeConcentration(componentDensity, componentMolarMass);
 
             AssertEx.EqualTolerance(expectedVolumeConcValue, volumeConcentration.As(expectedVolumeConcUnit), tolerence);
         }
@@ -74,10 +74,10 @@ public void ExpectMolarityConvertedToMassConcentrationCorrectly(
             double componentMolarMassValue, MolarMassUnit compontMolarMassUnit,
             double expectedMassConcValue, MassConcentrationUnit expectedMassConcUnit, double tolerence = 1e-5)
         {
-            var molarity = new Molarity(molarityValue, molarityUnit);
-            var componentMolarMass = new MolarMass(componentMolarMassValue, compontMolarMassUnit);
+            var molarity = new Molarity<double>(molarityValue, molarityUnit);
+            var componentMolarMass = new MolarMass<double>( componentMolarMassValue, compontMolarMassUnit);
 
-            MassConcentration concentration = molarity.ToMassConcentration(componentMolarMass);  // molarity * molarMass
+            var concentration = molarity.ToMassConcentration(componentMolarMass);  // molarity * molarMass
 
             AssertEx.EqualTolerance(expectedMassConcValue, concentration.As(expectedMassConcUnit), tolerence);
         }
@@ -91,10 +91,10 @@ public void MolarityFromDilutedSolution(
             double newConcentration, VolumeConcentrationUnit newConcentrationUnit,
             double expectedMolarityValue, MolarityUnit expectedMolarityUnit, double tolerence = 1e-5)
         {
-            var startingMolarity = new Molarity(startingMolarityValue, startingMolarityUnit);
-            var newVolumeConc = new VolumeConcentration(newConcentration, newConcentrationUnit);
+            var startingMolarity = new Molarity<double>( startingMolarityValue, startingMolarityUnit);
+            var newVolumeConc = new VolumeConcentration<double>( newConcentration, newConcentrationUnit);
 
-            Molarity dilutedMolarity = startingMolarity * newVolumeConc;
+            var dilutedMolarity = startingMolarity * newVolumeConc;
 
             AssertEx.EqualTolerance(expectedMolarityValue, dilutedMolarity.As(expectedMolarityUnit), tolerence);
         }
@@ -102,13 +102,13 @@ public void MolarityFromDilutedSolution(
         [Fact]
         public void OneMolarFromStringParsedCorrectly()
         {
-            Assert.Equal(Molarity.Parse("1M"), Molarity.Parse("1 mol/L"));
+            Assert.Equal(Molarity<double>.Parse("1M"), Molarity<double>.Parse("1 mol/L"));
         }
 
         [Fact]
         public void OneMilliMolarFromStringParsedCorrectly()
         {
-            Assert.Equal(1, Molarity.Parse("1000 mM").MolesPerLiter);
+            Assert.Equal(1, Molarity<double>.Parse("1000 mM").MolesPerLiter);
         }
 
     }
diff --git a/UnitsNet.Tests/CustomCode/ParseTests.cs b/UnitsNet.Tests/CustomCode/ParseTests.cs
index 06a1f7cdc9..e8ecd830c0 100644
--- a/UnitsNet.Tests/CustomCode/ParseTests.cs
+++ b/UnitsNet.Tests/CustomCode/ParseTests.cs
@@ -28,7 +28,7 @@ public class ParseTests
         public void ParseLengthToMetersUsEnglish(string s, double expected)
         {
             CultureInfo usEnglish = new CultureInfo("en-US");
-            double actual = Length.Parse(s, usEnglish).Meters;
+            double actual = Length<double>.Parse(s, usEnglish).Meters;
             Assert.Equal(expected, actual);
         }
 
@@ -42,7 +42,7 @@ public void ParseLengthToMetersUsEnglish(string s, double expected)
         public void ParseLength_InvalidString_USEnglish_ThrowsException(string s, Type expectedExceptionType)
         {
             var usEnglish = new CultureInfo("en-US");
-            Assert.Throws(expectedExceptionType, () => Length.Parse(s, usEnglish));
+            Assert.Throws(expectedExceptionType, () => Length<double>.Parse(s, usEnglish));
         }
 
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
@@ -58,7 +58,7 @@ public void ParseWithCultureUsingSpaceAsThousandSeparators(string s, double expe
             numberFormat.NumberDecimalSeparator = ".";
             numberFormat.CurrencyDecimalSeparator = ".";
 
-            double actual = Length.Parse(s, numberFormat).Meters;
+            double actual = Length<double>.Parse(s, numberFormat).Meters;
             Assert.Equal(expected, actual);
         }
 
@@ -73,7 +73,7 @@ public void ParseWithCultureUsingSpaceAsThousandSeparators_ThrowsExceptionOnInva
             numberFormat.NumberDecimalSeparator = ".";
             numberFormat.CurrencyDecimalSeparator = ".";
 
-            Assert.Throws(expectedExceptionType, () => Length.Parse(s, numberFormat));
+            Assert.Throws(expectedExceptionType, () => Length<double>.Parse(s, numberFormat));
         }
 
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
@@ -89,15 +89,15 @@ public void ParseWithCultureUsingDotAsThousandSeparators(string s, double expect
             numberFormat.NumberDecimalSeparator = ",";
             numberFormat.CurrencyDecimalSeparator = ",";
 
-            double actual = Length.Parse(s, numberFormat).Meters;
+            double actual = Length<double>.Parse(s, numberFormat).Meters;
             Assert.Equal(expected, actual);
         }
 
         [Fact]
         public void ParseMultiWordAbbreviations()
         {
-            Assert.Equal(Mass.FromShortTons(333), Mass.Parse("333 short tn"));
-            Assert.Equal(Mass.FromLongTons(333), Mass.Parse("333 long tn"));
+            Assert.Equal(Mass<double>.FromShortTons(333), Mass<double>.Parse("333 short tn"));
+            Assert.Equal(Mass<double>.FromLongTons(333), Mass<double>.Parse("333 long tn"));
         }
 
         [Theory]
@@ -110,7 +110,7 @@ public void ParseWithCultureUsingDotAsThousandSeparators_ThrowsExceptionOnInvali
             numberFormat.NumberDecimalSeparator = ",";
             numberFormat.CurrencyDecimalSeparator = ",";
 
-            Assert.Throws(expectedExceptionType, () => Length.Parse(s, numberFormat));
+            Assert.Throws(expectedExceptionType, () => Length<double>.Parse(s, numberFormat));
         }
 
         [Theory]
@@ -118,7 +118,7 @@ public void ParseWithCultureUsingDotAsThousandSeparators_ThrowsExceptionOnInvali
         public void ParseLengthUnitUsEnglish(string s, LengthUnit expected)
         {
             CultureInfo usEnglish = new CultureInfo("en-US");
-            LengthUnit actual = Length.ParseUnit(s, usEnglish);
+            LengthUnit actual = Length<double>.ParseUnit(s, usEnglish);
             Assert.Equal(expected, actual);
         }
 
@@ -128,7 +128,7 @@ public void ParseLengthUnitUsEnglish(string s, LengthUnit expected)
         public void ParseLengthUnitUsEnglish_ThrowsExceptionOnInvalidString(string s, Type expectedExceptionType)
         {
             var usEnglish = new CultureInfo("en-US");
-            Assert.Throws(expectedExceptionType, () => Length.ParseUnit(s, usEnglish));
+            Assert.Throws(expectedExceptionType, () => Length<double>.ParseUnit(s, usEnglish));
         }
 
         [Theory]
@@ -140,7 +140,7 @@ public void ParseLengthUnitUsEnglish_ThrowsExceptionOnInvalidString(string s, Ty
         public void TryParseLengthUnitUsEnglish(string s, bool expected)
         {
             CultureInfo usEnglish = new CultureInfo("en-US");
-            bool actual = Length.TryParse(s, usEnglish, out Length _);
+            bool actual = Length<double>.TryParse(s, usEnglish, out Length<double> _ );
             Assert.Equal(expected, actual);
         }
 
@@ -153,7 +153,7 @@ public void TryParseLengthUnitUsEnglish(string s, bool expected)
         [InlineData("1 кг", "ru-RU", 1, MassUnit.Kilogram)]
         public void ParseMassWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expectedValue, Enum expectedUnit)
         {
-            var actual = Mass.Parse(str, new CultureInfo(cultureName));
+            var actual = Mass<double>.Parse(str, new CultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
             Assert.Equal(expectedValue, actual.Value);
@@ -168,7 +168,7 @@ public void ParseMassWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAnd
         [InlineData("1 км", "ru-RU", 1, LengthUnit.Kilometer)]
         public void ParseLengthWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expectedValue, Enum expectedUnit)
         {
-            var actual = Length.Parse(str, new CultureInfo(cultureName));
+            var actual = Length<double>.Parse(str, new CultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
             Assert.Equal(expectedValue, actual.Value);
@@ -183,7 +183,7 @@ public void ParseLengthWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitA
         [InlineData("1 кН", "ru-RU", 1, ForceUnit.Kilonewton)]
         public void ParseForceWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expectedValue, Enum expectedUnit)
         {
-            var actual = Force.Parse(str, new CultureInfo(cultureName));
+            var actual = Force<double>.Parse(str, new CultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
             Assert.Equal(expectedValue, actual.Value);
@@ -204,7 +204,7 @@ public void ParseForceWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAn
         [InlineData("1 MiB", "ru-RU", 1, InformationUnit.Mebibyte)]
         public void ParseInformationWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, decimal expectedValue, Enum expectedUnit)
         {
-            var actual = Information.Parse(str, new CultureInfo(cultureName));
+            var actual = Information<decimal>.Parse(str, new CultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
             Assert.Equal(expectedValue, actual.Value);
diff --git a/UnitsNet.Tests/CustomCode/PowerRatioTests.cs b/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
index e6820ea023..5bbee6f528 100644
--- a/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
@@ -15,14 +15,14 @@ public class PowerRatioTests : PowerRatioTestsBase
 
         protected override void AssertLogarithmicAddition()
         {
-            PowerRatio v = PowerRatio.FromDecibelWatts(40);
+            var v = PowerRatio<double>.FromDecibelWatts(40);
             AssertEx.EqualTolerance(43.0102999566, (v + v).DecibelWatts, DecibelWattsTolerance);
         }
 
         protected override void AssertLogarithmicSubtraction()
         {
-            PowerRatio v = PowerRatio.FromDecibelWatts(40);
-            AssertEx.EqualTolerance(49.5424250944, (PowerRatio.FromDecibelWatts(50) - v).DecibelWatts, DecibelWattsTolerance);
+            var v = PowerRatio<double>.FromDecibelWatts(40);
+            AssertEx.EqualTolerance(49.5424250944, (PowerRatio<double>.FromDecibelWatts(50) - v).DecibelWatts, DecibelWattsTolerance);
         }
 
         [Theory]
@@ -31,7 +31,7 @@ protected override void AssertLogarithmicSubtraction()
         [InlineData(-10)]
         public void InvalidPower_ExpectArgumentOutOfRangeException(double power)
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => PowerRatio.FromPower(Power.FromWatts(power)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => PowerRatio<double>.FromPower(Power<double>.FromWatts(power)));
         }
 
         [Theory]
@@ -40,8 +40,8 @@ public void InvalidPower_ExpectArgumentOutOfRangeException(double power)
         [InlineData(100, 20)]
         public void ExpectPowerConvertedCorrectly(double power, double expected)
         {
-            Power p = Power.FromWatts(power);
-            double actual = PowerRatio.FromPower(p).DecibelWatts;
+            var p = Power<double>.FromWatts(power);
+            double actual = PowerRatio<double>.FromPower(p).DecibelWatts;
             Assert.Equal(expected, actual);
         }
 
@@ -53,7 +53,7 @@ public void ExpectPowerConvertedCorrectly(double power, double expected)
         [InlineData(20, 100)]
         public void ExpectPowerRatioConvertedCorrectly(double powerRatio, double expected)
         {
-            PowerRatio pr = PowerRatio.FromDecibelWatts(powerRatio);
+            var pr = PowerRatio<double>.FromDecibelWatts(powerRatio);
             double actual = pr.ToPower().Watts;
             Assert.Equal(expected, actual);
         }
@@ -67,9 +67,9 @@ public void ExpectPowerRatioConvertedCorrectly(double powerRatio, double expecte
         [InlineData(-6.99, 40)]
         public void PowerRatioToAmplitudeRatio_50OhmImpedance(double dBmW, double expected)
         {
-            PowerRatio powerRatio = PowerRatio.FromDecibelMilliwatts(dBmW);
+            var powerRatio = PowerRatio<double>.FromDecibelMilliwatts(dBmW);
 
-            double actual = Math.Round(powerRatio.ToAmplitudeRatio(ElectricResistance.FromOhms(50)).DecibelMillivolts, 2);
+            double actual = Math.Round(powerRatio.ToAmplitudeRatio(ElectricResistance<double>.FromOhms(50)).DecibelMillivolts, 2);
             Assert.Equal(expected, actual);
         }
 
@@ -80,9 +80,9 @@ public void PowerRatioToAmplitudeRatio_50OhmImpedance(double dBmW, double expect
         [InlineData(-8.75, 40)]
         public void PowerRatioToAmplitudeRatio_75OhmImpedance(double dBmW, double expected)
         {
-            PowerRatio powerRatio = PowerRatio.FromDecibelMilliwatts(dBmW);
+            var powerRatio = PowerRatio<double>.FromDecibelMilliwatts(dBmW);
 
-            double actual = Math.Round(powerRatio.ToAmplitudeRatio(ElectricResistance.FromOhms(75)).DecibelMillivolts, 2);
+            double actual = Math.Round(powerRatio.ToAmplitudeRatio(ElectricResistance<double>.FromOhms(75)).DecibelMillivolts, 2);
             Assert.Equal(expected, actual);
         }
     }
diff --git a/UnitsNet.Tests/CustomCode/PowerTests.cs b/UnitsNet.Tests/CustomCode/PowerTests.cs
index 5214d7a432..9d6b2176ca 100644
--- a/UnitsNet.Tests/CustomCode/PowerTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerTests.cs
@@ -62,71 +62,71 @@ public class PowerTests : PowerTestsBase
         [Fact]
         public void DurationTimesPowerEqualsEnergy()
         {
-            Energy energy = Duration.FromSeconds(8.0) * Power.FromWatts(5.0);
-            Assert.Equal(energy, Energy.FromJoules(40.0));
+            var energy = Duration<double>.FromSeconds(8.0) * Power<double>.FromWatts(5.0);
+            Assert.Equal(energy, Energy<double>.FromJoules(40.0));
         }
 
         [Fact]
         public void PowerDividedByRotationalSpeedEqualsForce()
         {
-            Torque torque = Power.FromWatts(15.0) / RotationalSpeed.FromRadiansPerSecond(3);
-            Assert.Equal(torque, Torque.FromNewtonMeters(5));
+            var torque = Power<double>.FromWatts(15.0) / RotationalSpeed<double>.FromRadiansPerSecond(3);
+            Assert.Equal(torque, Torque<double>.FromNewtonMeters(5));
         }
 
         [Fact]
         public void PowerDividedBySpeedEqualsForce()
         {
-            Force force = Power.FromWatts(15.0) / Speed.FromMetersPerSecond(3);
-            Assert.Equal(force, Force.FromNewtons(5));
+            var force = Power<double>.FromWatts(15.0) / Speed<double>.FromMetersPerSecond(3);
+            Assert.Equal(force, Force<double>.FromNewtons(5));
         }
 
         [Fact]
         public void PowerDividedByTorqueEqualsRotationalSpeed()
         {
-            RotationalSpeed rotationalSpeed = Power.FromWatts(15.0) / Torque.FromNewtonMeters(3);
-            Assert.Equal(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(5));
+            var rotationalSpeed = Power<double>.FromWatts(15.0) / Torque<double>.FromNewtonMeters(3);
+            Assert.Equal(rotationalSpeed, RotationalSpeed<double>.FromRadiansPerSecond(5));
         }
 
         [Fact]
         public void PowerTimesDurationEqualsEnergy()
         {
-            Energy energy = Power.FromWatts(5.0) * Duration.FromSeconds(8.0);
-            Assert.Equal(energy, Energy.FromJoules(40.0));
+            var energy = Power<double>.FromWatts(5.0) * Duration<double>.FromSeconds(8.0);
+            Assert.Equal(energy, Energy<double>.FromJoules(40.0));
         }
 
         [Fact]
         public void PowerTimesTimeSpanEqualsEnergy()
         {
-            Energy energy = Power.FromWatts(5.0) * TimeSpan.FromSeconds(8.0);
-            Assert.Equal(energy, Energy.FromJoules(40.0));
+            var energy = Power<double>.FromWatts(5.0) * TimeSpan.FromSeconds(8.0);
+            Assert.Equal(energy, Energy<double>.FromJoules(40.0));
         }
 
         [Fact]
         public void TimeSpanTimesPowerEqualsEnergy()
         {
-            Energy energy = TimeSpan.FromSeconds(8.0) * Power.FromWatts(5.0);
-            Assert.Equal(energy, Energy.FromJoules(40.0));
+            var energy = TimeSpan.FromSeconds(8.0) * Power<double>.FromWatts(5.0);
+            Assert.Equal(energy, Energy<double>.FromJoules(40.0));
         }
 
         [Fact]
         public void PowerTimesBrakeSpecificFuelConsumptionEqualsMassFlow()
         {
-            MassFlow massFlow = Power.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0) * BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(180.0);
+            var massFlow = Power<double>.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0) * BrakeSpecificFuelConsumption<double>.FromGramsPerKiloWattHour(180.0);
             AssertEx.EqualTolerance(massFlow.TonnesPerDay, 20.0, 1e-11);
         }
 
         [Fact]
         public void PowerDividedByMassFlowEqualsSpecificEnergy()
         {
-            SpecificEnergy specificEnergy = Power.FromWatts(15.0) / MassFlow.FromKilogramsPerSecond(3);
-            Assert.Equal(specificEnergy, SpecificEnergy.FromJoulesPerKilogram(5));
+            var specificEnergy = Power<double>.FromWatts(15.0) / MassFlow<double>.FromKilogramsPerSecond(3);
+            Assert.Equal(specificEnergy, SpecificEnergy<double>.FromJoulesPerKilogram(5));
         }
 
         [Fact]
         public void PowerDividedBySpecificEnergyEqualsMassFlow()
         {
-            MassFlow massFlow = Power.FromWatts(15.0) / SpecificEnergy.FromJoulesPerKilogram(3);
-            Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(5));
+            var massFlow = Power<double>.FromWatts(15.0) / SpecificEnergy<double>.FromJoulesPerKilogram(3);
+            Assert.Equal(massFlow, MassFlow<double>.FromKilogramsPerSecond(5));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs
index 9e8f73f4d1..173d4c7bd8 100644
--- a/UnitsNet.Tests/CustomCode/PressureTests.cs
+++ b/UnitsNet.Tests/CustomCode/PressureTests.cs
@@ -11,7 +11,7 @@ namespace UnitsNet.Tests.CustomCode
     public class PressureTests : PressureTestsBase
     {
         protected override bool SupportsSIUnitSystem => true;
-        protected override double AtmospheresInOnePascal => 9.8692 * 1E-6;
+        protected override double AtmospheresInOnePascal => 9.8692*1E-6;
 
         protected override double BarsInOnePascal => 1E-5;
 
@@ -51,7 +51,7 @@ public class PressureTests : PressureTestsBase
 
         protected override double PoundsForcePerSquareInchInOnePascal => 1.450377377302092e-4;
 
-        protected override double TechnicalAtmospheresInOnePascal => 1.0197 * 1E-5;
+        protected override double TechnicalAtmospheresInOnePascal => 1.0197*1E-5;
 
         protected override double TonnesForcePerSquareCentimeterInOnePascal => 1.019716212977928e-8;
 
@@ -59,7 +59,7 @@ public class PressureTests : PressureTestsBase
 
         protected override double TonnesForcePerSquareMillimeterInOnePascal => 1.019716212977928e-10;
 
-        protected override double TorrsInOnePascal => 7.5006 * 1E-3;
+        protected override double TorrsInOnePascal => 7.5006*1E-3;
 
         protected override double CentibarsInOnePascal => 1e-3;
 
@@ -146,8 +146,8 @@ public void Absolute_WithVacuumPressureReference_ThrowsArgumentOutOfRangeExcepti
         [Fact]
         public void AreaTimesPressureEqualsForce()
         {
-            var force = Area.FromSquareMeters(3) * Pressure.FromPascals(20);
-            Assert.Equal(force, Force.FromNewtons(60));
+            var force = Area<double>.FromSquareMeters(3) * Pressure<double>.FromPascals(20);
+            Assert.Equal(force, Force<double>.FromNewtons(60));
         }
 
         [Fact]
@@ -181,22 +181,22 @@ public void Gauge_WithVacuumPressureReference_ThrowsArgumentOutOfRangeException(
         [Fact]
         public void PressureDividedByLengthEqualsSpecificWeight()
         {
-            var specificWeight = Pressure.FromPascals(20) / Length.FromMeters(2);
-            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(10), specificWeight);
+            var specificWeight = Pressure<double>.FromPascals(20) / Length<double>.FromMeters(2);
+            Assert.Equal(SpecificWeight<double>.FromNewtonsPerCubicMeter(10), specificWeight);
         }
 
         [Fact]
         public void PressureDividedBySpecificWeightEqualsLength()
         {
-            var length = Pressure.FromPascals(20) / SpecificWeight.FromNewtonsPerCubicMeter(2);
-            Assert.Equal(Length.FromMeters(10), length);
+            var length = Pressure<double>.FromPascals(20) / SpecificWeight<double>.FromNewtonsPerCubicMeter(2);
+            Assert.Equal(Length<double>.FromMeters(10), length);
         }
 
         [Fact]
         public void PressureTimesAreaEqualsForce()
         {
-            var force = Pressure.FromPascals(20) * Area.FromSquareMeters(3);
-            Assert.Equal(force, Force.FromNewtons(60));
+            var force = Pressure<double>.FromPascals(20) * Area<double>.FromSquareMeters(3);
+            Assert.Equal(force, Force<double>.FromNewtons(60));
         }
 
         // Pressure Measurement References
diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
index d06ba83b0d..088ed97dc0 100644
--- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
@@ -38,29 +38,29 @@ public class RotationalSpeedTests : RotationalSpeedTestsBase
         [Fact]
         public void DurationTimesRotationalSpeedEqualsAngle()
         {
-            Angle angle = Duration.FromSeconds(9.0)*RotationalSpeed.FromRadiansPerSecond(10.0);
-            Assert.Equal(angle, Angle.FromRadians(90.0));
+            var angle = Duration<double>.FromSeconds(9.0)*RotationalSpeed<double>.FromRadiansPerSecond(10.0);
+            Assert.Equal(angle, Angle<double>.FromRadians(90.0));
         }
 
         [Fact]
         public void RotationalSpeedTimesDurationEqualsAngle()
         {
-            Angle angle = RotationalSpeed.FromRadiansPerSecond(10.0)*Duration.FromSeconds(9.0);
-            Assert.Equal(angle, Angle.FromRadians(90.0));
+            var angle = RotationalSpeed<double>.FromRadiansPerSecond(10.0)*Duration<double>.FromSeconds(9.0);
+            Assert.Equal(angle, Angle<double>.FromRadians(90.0));
         }
 
         [Fact]
         public void RotationalSpeedTimesTimeSpanEqualsAngle()
         {
-            Angle angle = RotationalSpeed.FromRadiansPerSecond(10.0)*TimeSpan.FromSeconds(9.0);
-            Assert.Equal(angle, Angle.FromRadians(90.0));
+            var angle = RotationalSpeed<double>.FromRadiansPerSecond(10.0)*TimeSpan.FromSeconds(9.0);
+            Assert.Equal(angle, Angle<double>.FromRadians(90.0));
         }
 
         [Fact]
         public void TimeSpanTimesRotationalSpeedEqualsAngle()
         {
-            Angle angle = TimeSpan.FromSeconds(9.0)*RotationalSpeed.FromRadiansPerSecond(10.0);
-            Assert.Equal(angle, Angle.FromRadians(90.0));
+            var angle = TimeSpan.FromSeconds(9.0)*RotationalSpeed<double>.FromRadiansPerSecond(10.0);
+            Assert.Equal(angle, Angle<double>.FromRadians(90.0));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
index d0e073042e..67c9e21906 100644
--- a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
@@ -44,35 +44,35 @@ public class SpecificEnergyTests : SpecificEnergyTestsBase
         [Fact]
         public void MassTimesSpecificEnergyEqualsEnergy()
         {
-            Energy energy = Mass.FromKilograms(20.0)*SpecificEnergy.FromJoulesPerKilogram(10.0);
+            var energy = Mass<double>.FromKilograms(20.0)*SpecificEnergy<double>.FromJoulesPerKilogram(10.0);
             Assert.Equal(200d, energy.Joules);
         }
 
         [Fact]
         public void SpecificEnergyTimesMassEqualsEnergy()
         {
-            Energy energy = SpecificEnergy.FromJoulesPerKilogram(10.0)*Mass.FromKilograms(20.0);
+            var energy = SpecificEnergy<double>.FromJoulesPerKilogram(10.0)*Mass<double>.FromKilograms(20.0);
             Assert.Equal(200d, energy.Joules);
         }
 
         [Fact]
         public void DoubleDividedBySpecificEnergyEqualsBrakeSpecificFuelConsumption()
         {
-            BrakeSpecificFuelConsumption bsfc = 2.0 / SpecificEnergy.FromJoulesPerKilogram(4.0);
-            Assert.Equal(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(0.5), bsfc);
+            var bsfc = 2.0 / SpecificEnergy<double>.FromJoulesPerKilogram(4.0);
+            Assert.Equal(BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(0.5), bsfc);
         }
 
         [Fact]
         public void SpecificEnergyTimesMassFlowEqualsPower()
         {
-            Power power = SpecificEnergy.FromJoulesPerKilogram(10.0) * MassFlow.FromKilogramsPerSecond(20.0);
+            var power = SpecificEnergy<double>.FromJoulesPerKilogram(10.0) * MassFlow<double>.FromKilogramsPerSecond(20.0);
             Assert.Equal(200d, power.Watts);
         }
 
         [Fact]
         public void SpecificEnergyTimesBrakeSpecificFuelConsumptionEqualsEnergy()
         {
-            double value = SpecificEnergy.FromJoulesPerKilogram(10.0) * BrakeSpecificFuelConsumption.FromKilogramsPerJoule(20.0);
+            double value = SpecificEnergy<double>.FromJoulesPerKilogram(10.0) * BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(20.0);
             Assert.Equal(200d, value);
         }
     }
diff --git a/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs b/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs
index 11fd0a396d..9f09326271 100644
--- a/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs
@@ -36,15 +36,15 @@ public class SpecificVolumeTests : SpecificVolumeTestsBase
         [Fact]
         public static void SpecificVolumeTimesMassEqualsVolume()
         {
-            Volume volume = SpecificVolume.FromCubicMetersPerKilogram(5) * Mass.FromKilograms(10);
-            Assert.Equal(volume, Volume.FromCubicMeters(50));
+            var volume = SpecificVolume<double>.FromCubicMetersPerKilogram(5) * Mass<double>.FromKilograms(10);
+            Assert.Equal(volume, Volume<double>.FromCubicMeters(50));
         }
 
         [Fact]
         public static void ConstantOverSpecificVolumeEqualsDensity()
         {
-            Density density = 5 / SpecificVolume.FromCubicMetersPerKilogram(20);
-            Assert.Equal(density, Density.FromKilogramsPerCubicMeter(0.25));
+            var density = 5 / SpecificVolume<double>.FromCubicMetersPerKilogram(20);
+            Assert.Equal(density, Density<double>.FromKilogramsPerCubicMeter(0.25));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs b/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
index 6a4a4ceecc..56a8335f96 100644
--- a/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
@@ -45,22 +45,22 @@ public class SpecificWeightTests : SpecificWeightTestsBase
         [Fact]
         public void SpecificWeightTimesLengthEqualsPressure()
         {
-            Pressure pressure = SpecificWeight.FromNewtonsPerCubicMeter(10) * Length.FromMeters(2);
-            Assert.Equal(Pressure.FromPascals(20), pressure);
+            var pressure = SpecificWeight<double>.FromNewtonsPerCubicMeter(10) * Length<double>.FromMeters(2);
+            Assert.Equal(Pressure<double>.FromPascals(20), pressure);
         }
 
         [Fact]
         public void SpecificWeightDividedByDensityEqualsAcceleration()
         {
-            Acceleration acceleration = SpecificWeight.FromNewtonsPerCubicMeter(40) / Density.FromKilogramsPerCubicMeter(4);
-            Assert.Equal(Acceleration.FromMetersPerSecondSquared(10), acceleration);
+            var acceleration = SpecificWeight<double>.FromNewtonsPerCubicMeter(40) / Density<double>.FromKilogramsPerCubicMeter(4);
+            Assert.Equal(Acceleration<double>.FromMetersPerSecondSquared(10), acceleration);
         }
 
         [Fact]
         public void SpecificWeightDividedByAccelerationEqualsDensity()
         {
-            Density density = SpecificWeight.FromNewtonsPerCubicMeter(20) / Acceleration.FromMetersPerSecondSquared(2);
-            Assert.Equal(Density.FromKilogramsPerCubicMeter(10), density);
+            var density = SpecificWeight<double>.FromNewtonsPerCubicMeter(20) / Acceleration<double>.FromMetersPerSecondSquared(2);
+            Assert.Equal(Density<double>.FromKilogramsPerCubicMeter(10), density);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index f47618c4e5..7c785e92c1 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -76,86 +76,86 @@ public class SpeedTests : SpeedTestsBase
         [Fact]
         public void DurationSpeedTimesEqualsLength()
         {
-            Length length = Duration.FromSeconds(2)*Speed.FromMetersPerSecond(20);
-            Assert.Equal(length, Length.FromMeters(40));
+            var length = Duration<double>.FromSeconds(2)*Speed<double>.FromMetersPerSecond(20);
+            Assert.Equal(length, Length<double>.FromMeters(40));
         }
 
         [Fact]
         public void LengthDividedByDurationEqualsSpeed()
         {
-            Speed speed = Length.FromMeters(20)/Duration.FromSeconds(2);
-            Assert.Equal(speed, Speed.FromMetersPerSecond(10));
+            var speed = Length<double>.FromMeters(20)/Duration<double>.FromSeconds(2);
+            Assert.Equal(speed, Speed<double>.FromMetersPerSecond(10));
         }
 
         [Fact]
         public void LengthDividedByTimeSpanEqualsSpeed()
         {
-            Speed speed = Length.FromMeters(20)/TimeSpan.FromSeconds(2);
-            Assert.Equal(speed, Speed.FromMetersPerSecond(10));
+            var speed = Length<double>.FromMeters(20)/TimeSpan.FromSeconds(2);
+            Assert.Equal(speed, Speed<double>.FromMetersPerSecond(10));
         }
 
         [Fact]
         public void SpeedDividedByDurationEqualsAcceleration()
         {
-            Acceleration acceleration = Speed.FromMetersPerSecond(20)/Duration.FromSeconds(2);
-            Assert.Equal(acceleration, Acceleration.FromMetersPerSecondSquared(10));
+            var acceleration = Speed<double>.FromMetersPerSecond(20)/Duration<double>.FromSeconds(2);
+            Assert.Equal(acceleration, Acceleration<double>.FromMetersPerSecondSquared(10));
         }
 
         [Fact]
         public void SpeedDividedByTimeSpanEqualsAcceleration()
         {
-            Acceleration acceleration = Speed.FromMetersPerSecond(20)/TimeSpan.FromSeconds(2);
-            Assert.Equal(acceleration, Acceleration.FromMetersPerSecondSquared(10));
+            var acceleration = Speed<double>.FromMetersPerSecond(20)/TimeSpan.FromSeconds(2);
+            Assert.Equal(acceleration, Acceleration<double>.FromMetersPerSecondSquared(10));
         }
 
         [Fact]
         public void SpeedTimesDurationEqualsLength()
         {
-            Length length = Speed.FromMetersPerSecond(20)*Duration.FromSeconds(2);
-            Assert.Equal(length, Length.FromMeters(40));
+            var length = Speed<double>.FromMetersPerSecond(20)*Duration<double>.FromSeconds(2);
+            Assert.Equal(length, Length<double>.FromMeters(40));
         }
 
         [Fact]
         public void SpeedTimesTimeSpanEqualsLength()
         {
-            Length length = Speed.FromMetersPerSecond(20)*TimeSpan.FromSeconds(2);
-            Assert.Equal(length, Length.FromMeters(40));
+            var length = Speed<double>.FromMetersPerSecond(20)*TimeSpan.FromSeconds(2);
+            Assert.Equal(length, Length<double>.FromMeters(40));
         }
 
         [Fact]
         public void TimeSpanTimesSpeedEqualsLength()
         {
-            Length length = TimeSpan.FromSeconds(2)*Speed.FromMetersPerSecond(20);
-            Assert.Equal(length, Length.FromMeters(40));
+            var length = TimeSpan.FromSeconds(2)*Speed<double>.FromMetersPerSecond(20);
+            Assert.Equal(length, Length<double>.FromMeters(40));
         }
 
         [Fact]
         public void SpeedTimesLengthEqualsKinematicViscosity()
         {
-            KinematicViscosity kinematicViscosity = Length.FromMeters(20) * Speed.FromMetersPerSecond(2);
-            Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(40), kinematicViscosity);
+            var kinematicViscosity = Length<double>.FromMeters(20) * Speed<double>.FromMetersPerSecond(2);
+            Assert.Equal(KinematicViscosity<double>.FromSquareMetersPerSecond(40), kinematicViscosity);
         }
 
         [Fact]
         public void SpeedTimesSpeedEqualsSpecificEnergy()
         {
             //m^2/s^2 = kg*m*m/(s^2*kg) = J/kg
-            SpecificEnergy length = Speed.FromMetersPerSecond(2) * Speed.FromMetersPerSecond(20);
-            Assert.Equal(length, SpecificEnergy.FromJoulesPerKilogram(40));
+            var length = Speed<double>.FromMetersPerSecond(2) * Speed<double>.FromMetersPerSecond(20);
+            Assert.Equal(length, SpecificEnergy<double>.FromJoulesPerKilogram(40));
         }
 
         [Fact]
         public void SpeedTimesDensityEqualsMassFlux()
         {
-            MassFlux massFlux = Speed.FromMetersPerSecond(20) * Density.FromKilogramsPerCubicMeter(2);
-            Assert.Equal(massFlux, MassFlux.FromKilogramsPerSecondPerSquareMeter(40));
+            var massFlux = Speed<double>.FromMetersPerSecond(20) * Density<double>.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(massFlux, MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(40));
         }
 
         [Fact]
         public void SpeedTimesAreaEqualsVolumeFlow()
         {
-            VolumeFlow volumeFlow = Speed.FromMetersPerSecond(2) * Area.FromSquareMeters(20);
-            Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(40), volumeFlow);
+            var volumeFlow = Speed<double>.FromMetersPerSecond(2) * Area<double>.FromSquareMeters(20);
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerSecond(40), volumeFlow);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/StonePoundsTests.cs b/UnitsNet.Tests/CustomCode/StonePoundsTests.cs
index b8cafbb920..f5dddb96bd 100644
--- a/UnitsNet.Tests/CustomCode/StonePoundsTests.cs
+++ b/UnitsNet.Tests/CustomCode/StonePoundsTests.cs
@@ -16,7 +16,7 @@ public class StonePoundsTests
         [Fact]
         public void StonePoundsFrom()
         {
-            Mass m = Mass.FromStonePounds(2, 3);
+            var m = Mass<double>.FromStonePounds(2, 3);
             double expectedKg = 2/StoneInOneKilogram + 3/PoundsInOneKilogram;
             AssertEx.EqualTolerance(expectedKg, m.Kilograms, StoneTolerance);
         }
@@ -24,7 +24,7 @@ public void StonePoundsFrom()
         [Fact]
         public void StonePoundsRoundTrip()
         {
-            Mass m = Mass.FromStonePounds(2, 3);
+            var m = Mass<double>.FromStonePounds(2, 3);
             StonePounds stonePounds = m.StonePounds;
             AssertEx.EqualTolerance(2, stonePounds.Stone, StoneTolerance);
             AssertEx.EqualTolerance(3, stonePounds.Pounds, PoundsTolerance);
@@ -33,7 +33,7 @@ public void StonePoundsRoundTrip()
         [Fact]
         public void StonePoundsToString_FormatsNumberInDefaultCulture()
         {
-            Mass m = Mass.FromStonePounds(3500, 1);
+            var m = Mass<double>.FromStonePounds(3500, 1);
             StonePounds stonePounds = m.StonePounds;
             string numberInCurrentCulture =  3500.ToString("n0", CultureInfo.CurrentUICulture); // Varies between machines, can't hard code it
 
@@ -47,7 +47,7 @@ public void StonePoundsToString_FormatsNumberInDefaultCulture()
         public void StonePoundsToString_GivenCultureWithThinSpaceDigitGroup_ReturnsNumberWithThinSpaceDigitGroup(string cultureName)
         {
             var formatProvider = new CultureInfo(cultureName);
-            Mass m = Mass.FromStonePounds(3500, 1);
+            var m = Mass<double>.FromStonePounds(3500, 1);
             StonePounds stonePounds = m.StonePounds;
 
             Assert.Equal("3 500 st 1 lb", stonePounds.ToString(formatProvider));
diff --git a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs
index 1efbdffbac..64074bf03f 100644
--- a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs
+++ b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs
@@ -40,8 +40,8 @@ public class TemperatureDeltaTests : TemperatureDeltaTestsBase
         [Fact]
         public void TemperatureDeltaTimesSpecificEntropyEqualsSpecificEnergy()
         {
-            SpecificEnergy specificEnergy =  SpecificEntropy.FromJoulesPerKilogramKelvin(10) * TemperatureDelta.FromKelvins(6);
-            Assert.Equal(specificEnergy, SpecificEnergy.FromJoulesPerKilogram(60));
+            var specificEnergy =  SpecificEntropy<double>.FromJoulesPerKilogramKelvin(10) * TemperatureDelta<double>.FromKelvins(6);
+            Assert.Equal(specificEnergy, SpecificEnergy<double>.FromJoulesPerKilogram(60));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/TemperatureTests.cs b/UnitsNet.Tests/CustomCode/TemperatureTests.cs
index 441ce154ae..16c0c5d827 100644
--- a/UnitsNet.Tests/CustomCode/TemperatureTests.cs
+++ b/UnitsNet.Tests/CustomCode/TemperatureTests.cs
@@ -33,101 +33,101 @@ public class TemperatureTests : TemperatureTestsBase
         public static IEnumerable<object[]> DividedByTemperatureDeltaEqualsTemperatureData { get; } =
             new List<object[]>
             {
-                new object[] { Temperature.FromDegreesCelsius(10), 1, Temperature.FromDegreesCelsius(10) },
-                new object[] { Temperature.FromDegreesCelsius(10), 5, Temperature.FromDegreesCelsius(2) },
-                new object[] { Temperature.FromDegreesCelsius(10), -10, Temperature.FromDegreesCelsius(-1) },
-                new object[] { Temperature.FromDegreesFahrenheit(10), 1, Temperature.FromDegreesFahrenheit(10) },
-                new object[] { Temperature.FromDegreesFahrenheit(10), 5, Temperature.FromDegreesFahrenheit(2) },
-                new object[] { Temperature.FromDegreesFahrenheit(10), -10, Temperature.FromDegreesFahrenheit(-1) }
+                new object[] { Temperature<double>.FromDegreesCelsius(10), 1, Temperature<double>.FromDegreesCelsius(10) },
+                new object[] { Temperature<double>.FromDegreesCelsius(10), 5, Temperature<double>.FromDegreesCelsius(2) },
+                new object[] { Temperature<double>.FromDegreesCelsius(10), -10, Temperature<double>.FromDegreesCelsius(-1) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(10), 1, Temperature<double>.FromDegreesFahrenheit(10) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(10), 5, Temperature<double>.FromDegreesFahrenheit(2) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(10), -10, Temperature<double>.FromDegreesFahrenheit(-1) }
             };
 
         [SuppressMessage("ReSharper", "ImpureMethodCallOnReadonlyValueField",
             Justification = "R# incorrectly identifies method as impure, due to internal method calls.")]
         [Theory]
         [MemberData(nameof(DividedByTemperatureDeltaEqualsTemperatureData))]
-        public void DividedByTemperatureDeltaEqualsTemperature(Temperature temperature, int divisor, Temperature expected)
+        public void DividedByTemperatureDeltaEqualsTemperature(Temperature<double> temperature, int divisor, Temperature<double> expected )
         {
-            Temperature resultTemp = temperature.Divide(divisor, temperature.Unit);
+            Temperature<double> resultTemp = temperature.Divide(divisor, temperature.Unit);
             Assert.True(expected.Equals(resultTemp, 1e-5, ComparisonType.Absolute));
         }
 
         public static IEnumerable<object[]> MultiplyByTemperatureDeltaEqualsTemperatureData { get; } =
             new List<object[]>
             {
-                new object[] { Temperature.FromDegreesCelsius(10), 0, Temperature.FromDegreesCelsius(0) },
-                new object[] { Temperature.FromDegreesCelsius(10), 5, Temperature.FromDegreesCelsius(50) },
-                new object[] { Temperature.FromDegreesCelsius(10), -5, Temperature.FromDegreesCelsius(-50) },
-                new object[] { Temperature.FromDegreesFahrenheit(10), 0, Temperature.FromDegreesFahrenheit(0) },
-                new object[] { Temperature.FromDegreesFahrenheit(10), 5, Temperature.FromDegreesFahrenheit(50) },
-                new object[] { Temperature.FromDegreesFahrenheit(10), -5, Temperature.FromDegreesFahrenheit(-50) }
+                new object[] { Temperature<double>.FromDegreesCelsius(10), 0, Temperature<double>.FromDegreesCelsius(0) },
+                new object[] { Temperature<double>.FromDegreesCelsius(10), 5, Temperature<double>.FromDegreesCelsius(50) },
+                new object[] { Temperature<double>.FromDegreesCelsius(10), -5, Temperature<double>.FromDegreesCelsius(-50) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(10), 0, Temperature<double>.FromDegreesFahrenheit(0) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(10), 5, Temperature<double>.FromDegreesFahrenheit(50) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(10), -5, Temperature<double>.FromDegreesFahrenheit(-50) }
             };
 
         [SuppressMessage("ReSharper", "ImpureMethodCallOnReadonlyValueField",
             Justification = "R# incorrectly identifies method as impure, due to internal method calls.")]
         [Theory]
         [MemberData(nameof(MultiplyByTemperatureDeltaEqualsTemperatureData))]
-        public void MultiplyByTemperatureDeltaEqualsTemperature(Temperature temperature, int factor, Temperature expected)
+        public void MultiplyByTemperatureDeltaEqualsTemperature(Temperature<double> temperature, int factor, Temperature<double> expected )
         {
-            Temperature resultTemp = temperature.Multiply(factor, temperature.Unit);
+            Temperature<double> resultTemp = temperature.Multiply(factor, temperature.Unit);
             Assert.True(expected.Equals(resultTemp, 1e-5, ComparisonType.Absolute));
         }
 
         public static IEnumerable<object[]> TemperatureDeltaPlusTemperatureEqualsTemperatureData { get; } =
             new List<object[]>
             {
-                new object[] { Temperature.FromDegreesCelsius(-10), TemperatureDelta.FromDegreesCelsius(0), Temperature.FromDegreesCelsius(-10) },
-                new object[] { Temperature.FromDegreesCelsius(-10), TemperatureDelta.FromDegreesCelsius(10), Temperature.FromDegreesCelsius(0) },
-                new object[] { Temperature.FromDegreesCelsius(-10), TemperatureDelta.FromDegreesCelsius(20), Temperature.FromDegreesCelsius(10) },
-                new object[] { Temperature.FromDegreesFahrenheit(-10), TemperatureDelta.FromDegreesFahrenheit(0), Temperature.FromDegreesFahrenheit(-10) },
-                new object[] { Temperature.FromDegreesFahrenheit(-10), TemperatureDelta.FromDegreesFahrenheit(10), Temperature.FromDegreesFahrenheit(0) },
-                new object[] { Temperature.FromDegreesFahrenheit(-10), TemperatureDelta.FromDegreesFahrenheit(20), Temperature.FromDegreesFahrenheit(10) }
+                new object[] { Temperature<double>.FromDegreesCelsius(-10), TemperatureDelta<double>.FromDegreesCelsius(0), Temperature<double>.FromDegreesCelsius(-10) },
+                new object[] { Temperature<double>.FromDegreesCelsius(-10), TemperatureDelta<double>.FromDegreesCelsius(10), Temperature<double>.FromDegreesCelsius(0) },
+                new object[] { Temperature<double>.FromDegreesCelsius(-10), TemperatureDelta<double>.FromDegreesCelsius(20), Temperature<double>.FromDegreesCelsius(10) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(-10), TemperatureDelta<double>.FromDegreesFahrenheit(0), Temperature<double>.FromDegreesFahrenheit(-10) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(-10), TemperatureDelta<double>.FromDegreesFahrenheit(10), Temperature<double>.FromDegreesFahrenheit(0) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(-10), TemperatureDelta<double>.FromDegreesFahrenheit(20), Temperature<double>.FromDegreesFahrenheit(10) }
             };
 
         [Theory]
         [MemberData(nameof(TemperatureDeltaPlusTemperatureEqualsTemperatureData))]
-        public void TemperatureDeltaPlusTemperatureEqualsTemperature(Temperature temperature, TemperatureDelta delta, Temperature expected)
+        public void TemperatureDeltaPlusTemperatureEqualsTemperature(Temperature<double> temperature, TemperatureDelta<double> delta, Temperature<double> expected )
         {
-            Temperature resultTemp = delta + temperature;
+            var resultTemp = delta + temperature;
             Assert.True(expected.Equals(resultTemp, 1e-5, ComparisonType.Absolute));
         }
 
         public static IEnumerable<object[]> TemperatureMinusTemperatureDeltaEqualsTemperatureData { get; } =
             new List<object[]>
             {
-                new object[] { Temperature.FromDegreesCelsius(20), TemperatureDelta.FromDegreesCelsius(10), Temperature.FromDegreesCelsius(10) },
-                new object[] { Temperature.FromDegreesCelsius(20), TemperatureDelta.FromDegreesCelsius(20), Temperature.FromDegreesCelsius(0) },
-                new object[] { Temperature.FromDegreesCelsius(20), TemperatureDelta.FromDegreesCelsius(30), Temperature.FromDegreesCelsius(-10) },
-                new object[] { Temperature.FromDegreesFahrenheit(20), TemperatureDelta.FromDegreesFahrenheit(10), Temperature.FromDegreesFahrenheit(10) },
-                new object[] { Temperature.FromDegreesFahrenheit(20), TemperatureDelta.FromDegreesFahrenheit(20), Temperature.FromDegreesFahrenheit(0) },
-                new object[] { Temperature.FromDegreesFahrenheit(20), TemperatureDelta.FromDegreesFahrenheit(30), Temperature.FromDegreesFahrenheit(-10) }
+                new object[] { Temperature<double>.FromDegreesCelsius(20), TemperatureDelta<double>.FromDegreesCelsius(10), Temperature<double>.FromDegreesCelsius(10) },
+                new object[] { Temperature<double>.FromDegreesCelsius(20), TemperatureDelta<double>.FromDegreesCelsius(20), Temperature<double>.FromDegreesCelsius(0) },
+                new object[] { Temperature<double>.FromDegreesCelsius(20), TemperatureDelta<double>.FromDegreesCelsius(30), Temperature<double>.FromDegreesCelsius(-10) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(20), TemperatureDelta<double>.FromDegreesFahrenheit(10), Temperature<double>.FromDegreesFahrenheit(10) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(20), TemperatureDelta<double>.FromDegreesFahrenheit(20), Temperature<double>.FromDegreesFahrenheit(0) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(20), TemperatureDelta<double>.FromDegreesFahrenheit(30), Temperature<double>.FromDegreesFahrenheit(-10) }
             };
 
         [Theory]
         [MemberData(nameof(TemperatureMinusTemperatureDeltaEqualsTemperatureData))]
-        public void TemperatureMinusTemperatureDeltaEqualsTemperature(Temperature temperature, TemperatureDelta delta, Temperature expected)
+        public void TemperatureMinusTemperatureDeltaEqualsTemperature(Temperature<double> temperature, TemperatureDelta<double> delta, Temperature<double> expected )
         {
-            Temperature resultTemp = temperature - delta;
+            var resultTemp = temperature - delta;
             Assert.True(expected.Equals(resultTemp, 1e-5, ComparisonType.Absolute));
         }
 
         public static IEnumerable<object[]> TemperaturePlusTemperatureDeltaEqualsTemperatureData { get; } =
             new List<object[]>
             {
-                new object[] { Temperature.FromDegreesCelsius(-10), TemperatureDelta.FromDegreesCelsius(0), Temperature.FromDegreesCelsius(-10) },
-                new object[] { Temperature.FromDegreesCelsius(-10), TemperatureDelta.FromDegreesCelsius(10), Temperature.FromDegreesCelsius(0) },
-                new object[] { Temperature.FromDegreesCelsius(-10), TemperatureDelta.FromDegreesCelsius(20), Temperature.FromDegreesCelsius(10) },
-                new object[] { Temperature.FromDegreesFahrenheit(-10), TemperatureDelta.FromDegreesFahrenheit(0), Temperature.FromDegreesFahrenheit(-10) },
-                new object[] { Temperature.FromDegreesFahrenheit(-10), TemperatureDelta.FromDegreesFahrenheit(10), Temperature.FromDegreesFahrenheit(0) },
-                new object[] { Temperature.FromDegreesFahrenheit(-10), TemperatureDelta.FromDegreesFahrenheit(20), Temperature.FromDegreesFahrenheit(10) }
+                new object[] { Temperature<double>.FromDegreesCelsius(-10), TemperatureDelta<double>.FromDegreesCelsius(0), Temperature<double>.FromDegreesCelsius(-10) },
+                new object[] { Temperature<double>.FromDegreesCelsius(-10), TemperatureDelta<double>.FromDegreesCelsius(10), Temperature<double>.FromDegreesCelsius(0) },
+                new object[] { Temperature<double>.FromDegreesCelsius(-10), TemperatureDelta<double>.FromDegreesCelsius(20), Temperature<double>.FromDegreesCelsius(10) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(-10), TemperatureDelta<double>.FromDegreesFahrenheit(0), Temperature<double>.FromDegreesFahrenheit(-10) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(-10), TemperatureDelta<double>.FromDegreesFahrenheit(10), Temperature<double>.FromDegreesFahrenheit(0) },
+                new object[] { Temperature<double>.FromDegreesFahrenheit(-10), TemperatureDelta<double>.FromDegreesFahrenheit(20), Temperature<double>.FromDegreesFahrenheit(10) }
             };
 
 
 
         [Theory]
         [MemberData(nameof(TemperaturePlusTemperatureDeltaEqualsTemperatureData))]
-        public void TemperaturePlusTemperatureDeltaEqualsTemperature(Temperature temperature, TemperatureDelta delta, Temperature expected)
+        public void TemperaturePlusTemperatureDeltaEqualsTemperature(Temperature<double> temperature, TemperatureDelta<double> delta, Temperature<double> expected )
         {
-            Temperature resultTemp = temperature + delta;
+            var resultTemp = temperature + delta;
             Assert.True(expected.Equals(resultTemp, 1e-5, ComparisonType.Absolute));
         }
     }
diff --git a/UnitsNet.Tests/CustomCode/TorqueTests.cs b/UnitsNet.Tests/CustomCode/TorqueTests.cs
index 97e22c7d27..0cfe87697e 100644
--- a/UnitsNet.Tests/CustomCode/TorqueTests.cs
+++ b/UnitsNet.Tests/CustomCode/TorqueTests.cs
@@ -55,15 +55,15 @@ public class TorqueTests : TorqueTestsBase
         [Fact]
         public void TorqueDividedByForceEqualsLength()
         {
-            Length length = Torque.FromNewtonMeters(4)/Force.FromNewtons(2);
-            Assert.Equal(length, Length.FromMeters(2));
+            var length = Torque<double>.FromNewtonMeters(4)/Force<double>.FromNewtons(2);
+            Assert.Equal(length, Length<double>.FromMeters(2));
         }
 
         [Fact]
         public void TorqueDividedByLengthEqualsForce()
         {
-            Force force = Torque.FromNewtonMeters(4)/Length.FromMeters(2);
-            Assert.Equal(force, Force.FromNewtons(2));
+            var force = Torque<double>.FromNewtonMeters(4)/Length<double>.FromMeters(2);
+            Assert.Equal(force, Force<double>.FromNewtons(2));
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs
index 92a8ab8406..2e985739d1 100644
--- a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs
@@ -69,10 +69,10 @@ public void MassConcentrationFromVolumeConcentrationAndComponentDensity(
             double expectedMassConcValue, MassConcentrationUnit expectedMassConcUnit,
             double tolerence = 1e-5)
         {
-            var volumeConcentration = new VolumeConcentration(volumeConcValue, volumeConcUnit);
-            var componentDensity = new Density(componentDensityValue, componentDensityUnit);
+            var volumeConcentration = new VolumeConcentration<double>(volumeConcValue, volumeConcUnit);
+            var componentDensity = new Density<double>( componentDensityValue, componentDensityUnit);
 
-            MassConcentration massConcentration = volumeConcentration.ToMassConcentration(componentDensity); // volumeConcentration * density
+            var massConcentration = volumeConcentration.ToMassConcentration(componentDensity); // volumeConcentration * density
 
             AssertEx.EqualTolerance(expectedMassConcValue, massConcentration.As(expectedMassConcUnit), tolerence);
         }
@@ -88,14 +88,13 @@ public void MolarityFromVolumeConcentrationAndComponentDensityAndMolarMass(
             double componentMolarMassValue, MolarMassUnit componentMolarMassUnit,
             double expectedMolarityValue, MolarityUnit expectedMolarityUnit, double tolerence = 1e-5)
         {
-            var volumeConcentration = new VolumeConcentration(volumeConcValue, volumeConcUnit);
-            var componentDensity = new Density(componentDensityValue, componetDensityUnit);
-            var componentMolarMass = new MolarMass(componentMolarMassValue, componentMolarMassUnit);
+            var volumeConcentration = new VolumeConcentration<double>( volumeConcValue, volumeConcUnit);
+            var componentDensity = new Density<double>( componentDensityValue, componetDensityUnit);
+            var componentMolarMass = new MolarMass<double>( componentMolarMassValue, componentMolarMassUnit);
 
-            Molarity molarity = volumeConcentration.ToMolarity(componentDensity, componentMolarMass); // volumeConcentration * density / molarMass
+            var molarity = volumeConcentration.ToMolarity(componentDensity, componentMolarMass); // volumeConcentration * density / molarMass
 
             AssertEx.EqualTolerance(expectedMolarityValue, molarity.As(expectedMolarityUnit), tolerence);
         }
-
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs b/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs
index 01cf18134e..1442d3032c 100644
--- a/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs
@@ -138,43 +138,43 @@ public class VolumeFlowTests : VolumeFlowTestsBase
         [InlineData(20, 62, 1240)]
         public void VolumeFlowTimesTimeSpanEqualsVolume(double cubicMetersPerSecond, double seconds, double expectedCubicMeters)
         {
-            Volume volume = VolumeFlow.FromCubicMetersPerSecond(cubicMetersPerSecond) * TimeSpan.FromSeconds(seconds);
-            Assert.Equal(Volume.FromCubicMeters(expectedCubicMeters), volume);
+            var volume = VolumeFlow<double>.FromCubicMetersPerSecond(cubicMetersPerSecond) * TimeSpan.FromSeconds(seconds);
+            Assert.Equal(Volume<double>.FromCubicMeters(expectedCubicMeters), volume);
         }
 
         [Fact]
         public void VolumeFlowTimesDurationEqualsVolume()
         {
-            Volume volume = VolumeFlow.FromCubicMetersPerSecond(20) * Duration.FromSeconds(2);
-            Assert.Equal(Volume.FromCubicMeters(40), volume);
+            var volume = VolumeFlow<double>.FromCubicMetersPerSecond(20) * Duration<double>.FromSeconds(2);
+            Assert.Equal(Volume<double>.FromCubicMeters(40), volume);
         }
 
         [Fact]
         public void VolumeFlowDividedByAreaEqualsSpeed()
         {
-            Speed speed = VolumeFlow.FromCubicMetersPerSecond(40) / Area.FromSquareMeters(20);
-            Assert.Equal(Speed.FromMetersPerSecond(2), speed);
+            var speed = VolumeFlow<double>.FromCubicMetersPerSecond(40) / Area<double>.FromSquareMeters(20);
+            Assert.Equal(Speed<double>.FromMetersPerSecond(2), speed);
         }
 
         [Fact]
         public void VolumeFlowDividedBySpeedEqualsArea()
         {
-            Area area = VolumeFlow.FromCubicMetersPerSecond(40) / Speed.FromMetersPerSecond(20);
-            Assert.Equal(Area.FromSquareMeters(2), area);
+            var area = VolumeFlow<double>.FromCubicMetersPerSecond(40) / Speed<double>.FromMetersPerSecond(20);
+            Assert.Equal(Area<double>.FromSquareMeters(2), area);
         }
 
         [Fact]
         public void VolumeFlowTimesDensityEqualsMassFlow()
         {
-            MassFlow massFlow = VolumeFlow.FromCubicMetersPerSecond(2) * Density.FromKilogramsPerCubicMeter(3);
-            Assert.Equal(MassFlow.FromKilogramsPerSecond(6), massFlow);
+            var massFlow = VolumeFlow<double>.FromCubicMetersPerSecond(2) * Density<double>.FromKilogramsPerCubicMeter(3);
+            Assert.Equal(MassFlow<double>.FromKilogramsPerSecond(6), massFlow);
         }
 
         [Fact]
         public void DensityTimesVolumeFlowEqualsMassFlow()
         {
-            MassFlow massFlow = Density.FromKilogramsPerCubicMeter(3) * VolumeFlow.FromCubicMetersPerSecond(7);
-            Assert.Equal(MassFlow.FromKilogramsPerSecond(21), massFlow);
+            var massFlow = Density<double>.FromKilogramsPerCubicMeter(3) * VolumeFlow<double>.FromCubicMetersPerSecond(7);
+            Assert.Equal(MassFlow<double>.FromKilogramsPerSecond(21), massFlow);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs
index 59413e5435..3015293465 100644
--- a/UnitsNet.Tests/CustomCode/VolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs
@@ -105,22 +105,22 @@ public class VolumeTests : VolumeTestsBase
         [Fact]
         public void VolumeDividedByAreaEqualsLength()
         {
-            Length length = Volume.FromCubicMeters(15)/Area.FromSquareMeters(5);
-            Assert.Equal(length, Length.FromMeters(3));
+            var length = Volume<double>.FromCubicMeters(15)/Area<double>.FromSquareMeters(5);
+            Assert.Equal(length, Length<double>.FromMeters(3));
         }
 
         [Fact]
         public void VolumeDividedByLengthEqualsArea()
         {
-            Area area = Volume.FromCubicMeters(15)/Length.FromMeters(5);
-            Assert.Equal(area, Area.FromSquareMeters(3));
+            var area = Volume<double>.FromCubicMeters(15)/Length<double>.FromMeters(5);
+            Assert.Equal(area, Area<double>.FromSquareMeters(3));
         }
 
         [Fact]
         public void VolumeTimesDensityEqualsMass()
         {
-            Mass mass = Volume.FromCubicMeters(2)*Density.FromKilogramsPerCubicMeter(3);
-            Assert.Equal(mass, Mass.FromKilograms(6));
+            var mass = Volume<double>.FromCubicMeters(2)*Density<double>.FromKilogramsPerCubicMeter(3);
+            Assert.Equal(mass, Mass<double>.FromKilograms(6));
         }
 
         [Theory]
@@ -128,21 +128,21 @@ public void VolumeTimesDensityEqualsMass()
         [InlineData(20, 80, 0.25)]
         public void VolumeDividedByTimeSpanEqualsVolumeFlow(double cubicMeters, double seconds, double expectedCubicMetersPerSecond)
         {
-            VolumeFlow volumeFlow = Volume.FromCubicMeters(cubicMeters) / TimeSpan.FromSeconds(seconds);
-            Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(expectedCubicMetersPerSecond), volumeFlow);
+            var volumeFlow = Volume<double>.FromCubicMeters(cubicMeters) / TimeSpan.FromSeconds(seconds);
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerSecond(expectedCubicMetersPerSecond), volumeFlow);
         }
 
         [Fact]
         public void VolumeDividedByDurationEqualsVolumeFlow()
         {
-            VolumeFlow volumeFlow = Volume.FromCubicMeters(20) / Duration.FromSeconds(2);
-            Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(10), volumeFlow);
+            var volumeFlow = Volume<double>.FromCubicMeters(20) / Duration<double>.FromSeconds(2);
+            Assert.Equal(VolumeFlow<double>.FromCubicMetersPerSecond(10), volumeFlow);
         }
 
         [Fact]
         public void VolumeDividedByVolumeFlowEqualsTimeSpan()
         {
-            TimeSpan timeSpan = Volume.FromCubicMeters(20) / VolumeFlow.FromCubicMetersPerSecond(2);
+            var timeSpan = Volume<double>.FromCubicMeters(20) / VolumeFlow<double>.FromCubicMetersPerSecond(2);
             Assert.Equal(TimeSpan.FromSeconds(10), timeSpan);
         }
     }
diff --git a/UnitsNet.Tests/DecimalOverloadTests.cs b/UnitsNet.Tests/DecimalOverloadTests.cs
index 841c9b162b..d70c90d2bd 100644
--- a/UnitsNet.Tests/DecimalOverloadTests.cs
+++ b/UnitsNet.Tests/DecimalOverloadTests.cs
@@ -10,14 +10,14 @@ public class DecimalOverloadTests
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromDecimalReturnsCorrectValue()
         {
-            Acceleration acceleration = Acceleration.FromMetersPerSecondSquared(1m);
+            var acceleration = Acceleration<double>.FromMetersPerSecondSquared(1m);
             Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDecimalBackingFieldFromDecimalReturnsCorrectValue()
         {
-            Power power = Power.FromWatts(1m);
+            var power = Power<double>.FromWatts(1m);
             Assert.Equal(1.0, power.Watts);
         }
     }
diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs
new file mode 100644
index 0000000000..a321a780bc
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs
@@ -0,0 +1,277 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of AmplitudeRatio.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class AmplitudeRatioTestsBase
+    {
+        protected abstract double DecibelMicrovoltsInOneDecibelVolt { get; }
+        protected abstract double DecibelMillivoltsInOneDecibelVolt { get; }
+        protected abstract double DecibelsUnloadedInOneDecibelVolt { get; }
+        protected abstract double DecibelVoltsInOneDecibelVolt { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DecibelMicrovoltsTolerance { get { return 1e-5; } }
+        protected virtual double DecibelMillivoltsTolerance { get { return 1e-5; } }
+        protected virtual double DecibelsUnloadedTolerance { get { return 1e-5; } }
+        protected virtual double DecibelVoltsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>((double)0.0, AmplitudeRatioUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>(double.PositiveInfinity, AmplitudeRatioUnit.DecibelVolt));
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>(double.NegativeInfinity, AmplitudeRatioUnit.DecibelVolt));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>(double.NaN, AmplitudeRatioUnit.DecibelVolt));
+        }
+
+        [Fact]
+        public void DecibelVoltToAmplitudeRatioUnits()
+        {
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            AssertEx.EqualTolerance(DecibelMicrovoltsInOneDecibelVolt, decibelvolt.DecibelMicrovolts, DecibelMicrovoltsTolerance);
+            AssertEx.EqualTolerance(DecibelMillivoltsInOneDecibelVolt, decibelvolt.DecibelMillivolts, DecibelMillivoltsTolerance);
+            AssertEx.EqualTolerance(DecibelsUnloadedInOneDecibelVolt, decibelvolt.DecibelsUnloaded, DecibelsUnloadedTolerance);
+            AssertEx.EqualTolerance(DecibelVoltsInOneDecibelVolt, decibelvolt.DecibelVolts, DecibelVoltsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelMicrovolt).DecibelMicrovolts, DecibelMicrovoltsTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelMillivolt).DecibelMillivolts, DecibelMillivoltsTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelUnloaded).DecibelsUnloaded, DecibelsUnloadedTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelVolt).DecibelVolts, DecibelVoltsTolerance);
+        }
+
+        [Fact]
+        public void FromDecibelVolts_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => AmplitudeRatio<double>.FromDecibelVolts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => AmplitudeRatio<double>.FromDecibelVolts(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromDecibelVolts_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => AmplitudeRatio<double>.FromDecibelVolts(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            AssertEx.EqualTolerance(DecibelMicrovoltsInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelMicrovolt), DecibelMicrovoltsTolerance);
+            AssertEx.EqualTolerance(DecibelMillivoltsInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelMillivolt), DecibelMillivoltsTolerance);
+            AssertEx.EqualTolerance(DecibelsUnloadedInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelUnloaded), DecibelsUnloadedTolerance);
+            AssertEx.EqualTolerance(DecibelVoltsInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelVolt), DecibelVoltsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+
+            var decibelmicrovoltQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelMicrovolt);
+            AssertEx.EqualTolerance(DecibelMicrovoltsInOneDecibelVolt, (double)decibelmicrovoltQuantity.Value, DecibelMicrovoltsTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelMicrovolt, decibelmicrovoltQuantity.Unit);
+
+            var decibelmillivoltQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelMillivolt);
+            AssertEx.EqualTolerance(DecibelMillivoltsInOneDecibelVolt, (double)decibelmillivoltQuantity.Value, DecibelMillivoltsTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelMillivolt, decibelmillivoltQuantity.Unit);
+
+            var decibelunloadedQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelUnloaded);
+            AssertEx.EqualTolerance(DecibelsUnloadedInOneDecibelVolt, (double)decibelunloadedQuantity.Value, DecibelsUnloadedTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelUnloaded, decibelunloadedQuantity.Unit);
+
+            var decibelvoltQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelVolt);
+            AssertEx.EqualTolerance(DecibelVoltsInOneDecibelVolt, (double)decibelvoltQuantity.Value, DecibelVoltsTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelVolt, decibelvoltQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelMicrovolts(decibelvolt.DecibelMicrovolts).DecibelVolts, DecibelMicrovoltsTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelMillivolts(decibelvolt.DecibelMillivolts).DecibelVolts, DecibelMillivoltsTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelsUnloaded(decibelvolt.DecibelsUnloaded).DecibelVolts, DecibelsUnloadedTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelVolts(decibelvolt.DecibelVolts).DecibelVolts, DecibelVoltsTolerance);
+        }
+
+        [Fact]
+        public void LogarithmicArithmeticOperators()
+        {
+            AmplitudeRatio<double> v = AmplitudeRatio<double>.FromDecibelVolts(40);
+            AssertEx.EqualTolerance(-40, -v.DecibelVolts, DecibelVoltsTolerance);
+            AssertLogarithmicAddition();
+            AssertLogarithmicSubtraction();
+            AssertEx.EqualTolerance(50, (v*10).DecibelVolts, DecibelVoltsTolerance);
+            AssertEx.EqualTolerance(50, (10*v).DecibelVolts, DecibelVoltsTolerance);
+            AssertEx.EqualTolerance(35, (v/5).DecibelVolts, DecibelVoltsTolerance);
+            AssertEx.EqualTolerance(35, v/AmplitudeRatio<double>.FromDecibelVolts(5), DecibelVoltsTolerance);
+        }
+
+        protected abstract void AssertLogarithmicAddition();
+
+        protected abstract void AssertLogarithmicSubtraction();
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            AmplitudeRatio<double> oneDecibelVolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            AmplitudeRatio<double> twoDecibelVolts = AmplitudeRatio<double>.FromDecibelVolts(2);
+
+            Assert.True(oneDecibelVolt < twoDecibelVolts);
+            Assert.True(oneDecibelVolt <= twoDecibelVolts);
+            Assert.True(twoDecibelVolts > oneDecibelVolt);
+            Assert.True(twoDecibelVolts >= oneDecibelVolt);
+
+            Assert.False(oneDecibelVolt > twoDecibelVolts);
+            Assert.False(oneDecibelVolt >= twoDecibelVolts);
+            Assert.False(twoDecibelVolts < oneDecibelVolt);
+            Assert.False(twoDecibelVolts <= oneDecibelVolt);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            Assert.Equal(0, decibelvolt.CompareTo(decibelvolt));
+            Assert.True(decibelvolt.CompareTo(AmplitudeRatio<double>.Zero) > 0);
+            Assert.True(AmplitudeRatio<double>.Zero.CompareTo(decibelvolt) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            Assert.Throws<ArgumentException>(() => decibelvolt.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            Assert.Throws<ArgumentNullException>(() => decibelvolt.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = AmplitudeRatio<double>.FromDecibelVolts(1);
+            var b = AmplitudeRatio<double>.FromDecibelVolts(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = AmplitudeRatio<double>.FromDecibelVolts(1);
+            var b = AmplitudeRatio<double>.FromDecibelVolts(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = AmplitudeRatio<double>.FromDecibelVolts(1);
+            Assert.True(v.Equals(AmplitudeRatio<double>.FromDecibelVolts(1), DecibelVoltsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(AmplitudeRatio<double>.Zero, DecibelVoltsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            Assert.False(decibelvolt.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            Assert.False(decibelvolt.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(AmplitudeRatioUnit.Undefined, AmplitudeRatio<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(AmplitudeRatioUnit)).Cast<AmplitudeRatioUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == AmplitudeRatioUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(AmplitudeRatio<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ApparentEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ApparentEnergyTestsBase.g.cs
new file mode 100644
index 0000000000..1817f18e1b
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ApparentEnergyTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ApparentEnergy.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ApparentEnergyTestsBase
+    {
+        protected abstract double KilovoltampereHoursInOneVoltampereHour { get; }
+        protected abstract double MegavoltampereHoursInOneVoltampereHour { get; }
+        protected abstract double VoltampereHoursInOneVoltampereHour { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilovoltampereHoursTolerance { get { return 1e-5; } }
+        protected virtual double MegavoltampereHoursTolerance { get { return 1e-5; } }
+        protected virtual double VoltampereHoursTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>((double)0.0, ApparentEnergyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>(double.PositiveInfinity, ApparentEnergyUnit.VoltampereHour));
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>(double.NegativeInfinity, ApparentEnergyUnit.VoltampereHour));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>(double.NaN, ApparentEnergyUnit.VoltampereHour));
+        }
+
+        [Fact]
+        public void VoltampereHourToApparentEnergyUnits()
+        {
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, voltamperehour.KilovoltampereHours, KilovoltampereHoursTolerance);
+            AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, voltamperehour.MegavoltampereHours, MegavoltampereHoursTolerance);
+            AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, voltamperehour.VoltampereHours, VoltampereHoursTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.From(1, ApparentEnergyUnit.KilovoltampereHour).KilovoltampereHours, KilovoltampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.From(1, ApparentEnergyUnit.MegavoltampereHour).MegavoltampereHours, MegavoltampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.From(1, ApparentEnergyUnit.VoltampereHour).VoltampereHours, VoltampereHoursTolerance);
+        }
+
+        [Fact]
+        public void FromVoltampereHours_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ApparentEnergy<double>.FromVoltampereHours(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ApparentEnergy<double>.FromVoltampereHours(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVoltampereHours_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ApparentEnergy<double>.FromVoltampereHours(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.KilovoltampereHour), KilovoltampereHoursTolerance);
+            AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.MegavoltampereHour), MegavoltampereHoursTolerance);
+            AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.VoltampereHour), VoltampereHoursTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+
+            var kilovoltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.KilovoltampereHour);
+            AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, (double)kilovoltamperehourQuantity.Value, KilovoltampereHoursTolerance);
+            Assert.Equal(ApparentEnergyUnit.KilovoltampereHour, kilovoltamperehourQuantity.Unit);
+
+            var megavoltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.MegavoltampereHour);
+            AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, (double)megavoltamperehourQuantity.Value, MegavoltampereHoursTolerance);
+            Assert.Equal(ApparentEnergyUnit.MegavoltampereHour, megavoltamperehourQuantity.Unit);
+
+            var voltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.VoltampereHour);
+            AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, (double)voltamperehourQuantity.Value, VoltampereHoursTolerance);
+            Assert.Equal(ApparentEnergyUnit.VoltampereHour, voltamperehourQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.FromKilovoltampereHours(voltamperehour.KilovoltampereHours).VoltampereHours, KilovoltampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.FromMegavoltampereHours(voltamperehour.MegavoltampereHours).VoltampereHours, MegavoltampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.FromVoltampereHours(voltamperehour.VoltampereHours).VoltampereHours, VoltampereHoursTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ApparentEnergy<double> v = ApparentEnergy<double>.FromVoltampereHours(1);
+            AssertEx.EqualTolerance(-1, -v.VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(2, (ApparentEnergy<double>.FromVoltampereHours(3)-v).VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(2, (v + v).VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(10, (v*10).VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(10, (10*v).VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(2, (ApparentEnergy<double>.FromVoltampereHours(10)/5).VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(2, ApparentEnergy<double>.FromVoltampereHours(10)/ApparentEnergy<double>.FromVoltampereHours(5), VoltampereHoursTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ApparentEnergy<double> oneVoltampereHour = ApparentEnergy<double>.FromVoltampereHours(1);
+            ApparentEnergy<double> twoVoltampereHours = ApparentEnergy<double>.FromVoltampereHours(2);
+
+            Assert.True(oneVoltampereHour < twoVoltampereHours);
+            Assert.True(oneVoltampereHour <= twoVoltampereHours);
+            Assert.True(twoVoltampereHours > oneVoltampereHour);
+            Assert.True(twoVoltampereHours >= oneVoltampereHour);
+
+            Assert.False(oneVoltampereHour > twoVoltampereHours);
+            Assert.False(oneVoltampereHour >= twoVoltampereHours);
+            Assert.False(twoVoltampereHours < oneVoltampereHour);
+            Assert.False(twoVoltampereHours <= oneVoltampereHour);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            Assert.Equal(0, voltamperehour.CompareTo(voltamperehour));
+            Assert.True(voltamperehour.CompareTo(ApparentEnergy<double>.Zero) > 0);
+            Assert.True(ApparentEnergy<double>.Zero.CompareTo(voltamperehour) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            Assert.Throws<ArgumentException>(() => voltamperehour.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            Assert.Throws<ArgumentNullException>(() => voltamperehour.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ApparentEnergy<double>.FromVoltampereHours(1);
+            var b = ApparentEnergy<double>.FromVoltampereHours(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ApparentEnergy<double>.FromVoltampereHours(1);
+            var b = ApparentEnergy<double>.FromVoltampereHours(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ApparentEnergy<double>.FromVoltampereHours(1);
+            Assert.True(v.Equals(ApparentEnergy<double>.FromVoltampereHours(1), VoltampereHoursTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ApparentEnergy<double>.Zero, VoltampereHoursTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            Assert.False(voltamperehour.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            Assert.False(voltamperehour.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ApparentEnergyUnit.Undefined, ApparentEnergy<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ApparentEnergyUnit)).Cast<ApparentEnergyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ApparentEnergyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ApparentEnergy<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs
new file mode 100644
index 0000000000..a9ced1863e
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ApparentPower.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ApparentPowerTestsBase
+    {
+        protected abstract double GigavoltamperesInOneVoltampere { get; }
+        protected abstract double KilovoltamperesInOneVoltampere { get; }
+        protected abstract double MegavoltamperesInOneVoltampere { get; }
+        protected abstract double VoltamperesInOneVoltampere { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double GigavoltamperesTolerance { get { return 1e-5; } }
+        protected virtual double KilovoltamperesTolerance { get { return 1e-5; } }
+        protected virtual double MegavoltamperesTolerance { get { return 1e-5; } }
+        protected virtual double VoltamperesTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>((double)0.0, ApparentPowerUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>(double.PositiveInfinity, ApparentPowerUnit.Voltampere));
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>(double.NegativeInfinity, ApparentPowerUnit.Voltampere));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>(double.NaN, ApparentPowerUnit.Voltampere));
+        }
+
+        [Fact]
+        public void VoltampereToApparentPowerUnits()
+        {
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            AssertEx.EqualTolerance(GigavoltamperesInOneVoltampere, voltampere.Gigavoltamperes, GigavoltamperesTolerance);
+            AssertEx.EqualTolerance(KilovoltamperesInOneVoltampere, voltampere.Kilovoltamperes, KilovoltamperesTolerance);
+            AssertEx.EqualTolerance(MegavoltamperesInOneVoltampere, voltampere.Megavoltamperes, MegavoltamperesTolerance);
+            AssertEx.EqualTolerance(VoltamperesInOneVoltampere, voltampere.Voltamperes, VoltamperesTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ApparentPower<double>.From(1, ApparentPowerUnit.Gigavoltampere).Gigavoltamperes, GigavoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.From(1, ApparentPowerUnit.Kilovoltampere).Kilovoltamperes, KilovoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.From(1, ApparentPowerUnit.Megavoltampere).Megavoltamperes, MegavoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.From(1, ApparentPowerUnit.Voltampere).Voltamperes, VoltamperesTolerance);
+        }
+
+        [Fact]
+        public void FromVoltamperes_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ApparentPower<double>.FromVoltamperes(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ApparentPower<double>.FromVoltamperes(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVoltamperes_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ApparentPower<double>.FromVoltamperes(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var voltampere = ApparentPower<double>.FromVoltamperes(1);
+            AssertEx.EqualTolerance(GigavoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Gigavoltampere), GigavoltamperesTolerance);
+            AssertEx.EqualTolerance(KilovoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Kilovoltampere), KilovoltamperesTolerance);
+            AssertEx.EqualTolerance(MegavoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Megavoltampere), MegavoltamperesTolerance);
+            AssertEx.EqualTolerance(VoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Voltampere), VoltamperesTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var voltampere = ApparentPower<double>.FromVoltamperes(1);
+
+            var gigavoltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Gigavoltampere);
+            AssertEx.EqualTolerance(GigavoltamperesInOneVoltampere, (double)gigavoltampereQuantity.Value, GigavoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Gigavoltampere, gigavoltampereQuantity.Unit);
+
+            var kilovoltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Kilovoltampere);
+            AssertEx.EqualTolerance(KilovoltamperesInOneVoltampere, (double)kilovoltampereQuantity.Value, KilovoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Kilovoltampere, kilovoltampereQuantity.Unit);
+
+            var megavoltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Megavoltampere);
+            AssertEx.EqualTolerance(MegavoltamperesInOneVoltampere, (double)megavoltampereQuantity.Value, MegavoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Megavoltampere, megavoltampereQuantity.Unit);
+
+            var voltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Voltampere);
+            AssertEx.EqualTolerance(VoltamperesInOneVoltampere, (double)voltampereQuantity.Value, VoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Voltampere, voltampereQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromGigavoltamperes(voltampere.Gigavoltamperes).Voltamperes, GigavoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromKilovoltamperes(voltampere.Kilovoltamperes).Voltamperes, KilovoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromMegavoltamperes(voltampere.Megavoltamperes).Voltamperes, MegavoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromVoltamperes(voltampere.Voltamperes).Voltamperes, VoltamperesTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ApparentPower<double> v = ApparentPower<double>.FromVoltamperes(1);
+            AssertEx.EqualTolerance(-1, -v.Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(2, (ApparentPower<double>.FromVoltamperes(3)-v).Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(2, (ApparentPower<double>.FromVoltamperes(10)/5).Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(2, ApparentPower<double>.FromVoltamperes(10)/ApparentPower<double>.FromVoltamperes(5), VoltamperesTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ApparentPower<double> oneVoltampere = ApparentPower<double>.FromVoltamperes(1);
+            ApparentPower<double> twoVoltamperes = ApparentPower<double>.FromVoltamperes(2);
+
+            Assert.True(oneVoltampere < twoVoltamperes);
+            Assert.True(oneVoltampere <= twoVoltamperes);
+            Assert.True(twoVoltamperes > oneVoltampere);
+            Assert.True(twoVoltamperes >= oneVoltampere);
+
+            Assert.False(oneVoltampere > twoVoltamperes);
+            Assert.False(oneVoltampere >= twoVoltamperes);
+            Assert.False(twoVoltamperes < oneVoltampere);
+            Assert.False(twoVoltamperes <= oneVoltampere);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            Assert.Equal(0, voltampere.CompareTo(voltampere));
+            Assert.True(voltampere.CompareTo(ApparentPower<double>.Zero) > 0);
+            Assert.True(ApparentPower<double>.Zero.CompareTo(voltampere) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            Assert.Throws<ArgumentException>(() => voltampere.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            Assert.Throws<ArgumentNullException>(() => voltampere.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ApparentPower<double>.FromVoltamperes(1);
+            var b = ApparentPower<double>.FromVoltamperes(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ApparentPower<double>.FromVoltamperes(1);
+            var b = ApparentPower<double>.FromVoltamperes(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ApparentPower<double>.FromVoltamperes(1);
+            Assert.True(v.Equals(ApparentPower<double>.FromVoltamperes(1), VoltamperesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ApparentPower<double>.Zero, VoltamperesTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            Assert.False(voltampere.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            Assert.False(voltampere.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ApparentPowerUnit.Undefined, ApparentPower<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ApparentPowerUnit)).Cast<ApparentPowerUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ApparentPowerUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ApparentPower<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/AreaDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaDensityTestsBase.g.cs
new file mode 100644
index 0000000000..6de1e152f9
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/AreaDensityTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of AreaDensity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class AreaDensityTestsBase
+    {
+        protected abstract double KilogramsPerSquareMeterInOneKilogramPerSquareMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilogramsPerSquareMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>((double)0.0, AreaDensityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>(double.PositiveInfinity, AreaDensityUnit.KilogramPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>(double.NegativeInfinity, AreaDensityUnit.KilogramPerSquareMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>(double.NaN, AreaDensityUnit.KilogramPerSquareMeter));
+        }
+
+        [Fact]
+        public void KilogramPerSquareMeterToAreaDensityUnits()
+        {
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, AreaDensity<double>.From(1, AreaDensityUnit.KilogramPerSquareMeter).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromKilogramsPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => AreaDensity<double>.FromKilogramsPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => AreaDensity<double>.FromKilogramsPerSquareMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromKilogramsPerSquareMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => AreaDensity<double>.FromKilogramsPerSquareMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.KilogramPerSquareMeter), KilogramsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+
+            var kilogrampersquaremeterQuantity = kilogrampersquaremeter.ToUnit(AreaDensityUnit.KilogramPerSquareMeter);
+            AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, (double)kilogrampersquaremeterQuantity.Value, KilogramsPerSquareMeterTolerance);
+            Assert.Equal(AreaDensityUnit.KilogramPerSquareMeter, kilogrampersquaremeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, AreaDensity<double>.FromKilogramsPerSquareMeter(kilogrampersquaremeter.KilogramsPerSquareMeter).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            AreaDensity<double> v = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            AssertEx.EqualTolerance(-1, -v.KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (AreaDensity<double>.FromKilogramsPerSquareMeter(3)-v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (AreaDensity<double>.FromKilogramsPerSquareMeter(10)/5).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, AreaDensity<double>.FromKilogramsPerSquareMeter(10)/AreaDensity<double>.FromKilogramsPerSquareMeter(5), KilogramsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            AreaDensity<double> oneKilogramPerSquareMeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> twoKilogramsPerSquareMeter = AreaDensity<double>.FromKilogramsPerSquareMeter(2);
+
+            Assert.True(oneKilogramPerSquareMeter < twoKilogramsPerSquareMeter);
+            Assert.True(oneKilogramPerSquareMeter <= twoKilogramsPerSquareMeter);
+            Assert.True(twoKilogramsPerSquareMeter > oneKilogramPerSquareMeter);
+            Assert.True(twoKilogramsPerSquareMeter >= oneKilogramPerSquareMeter);
+
+            Assert.False(oneKilogramPerSquareMeter > twoKilogramsPerSquareMeter);
+            Assert.False(oneKilogramPerSquareMeter >= twoKilogramsPerSquareMeter);
+            Assert.False(twoKilogramsPerSquareMeter < oneKilogramPerSquareMeter);
+            Assert.False(twoKilogramsPerSquareMeter <= oneKilogramPerSquareMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            Assert.Equal(0, kilogrampersquaremeter.CompareTo(kilogrampersquaremeter));
+            Assert.True(kilogrampersquaremeter.CompareTo(AreaDensity<double>.Zero) > 0);
+            Assert.True(AreaDensity<double>.Zero.CompareTo(kilogrampersquaremeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            Assert.Throws<ArgumentException>(() => kilogrampersquaremeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            Assert.Throws<ArgumentNullException>(() => kilogrampersquaremeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            var b = AreaDensity<double>.FromKilogramsPerSquareMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            var b = AreaDensity<double>.FromKilogramsPerSquareMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            Assert.True(v.Equals(AreaDensity<double>.FromKilogramsPerSquareMeter(1), KilogramsPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(AreaDensity<double>.Zero, KilogramsPerSquareMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            Assert.False(kilogrampersquaremeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            Assert.False(kilogrampersquaremeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(AreaDensityUnit.Undefined, AreaDensity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(AreaDensityUnit)).Cast<AreaDensityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == AreaDensityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(AreaDensity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/AreaMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaMomentOfInertiaTestsBase.g.cs
new file mode 100644
index 0000000000..5a08937c96
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/AreaMomentOfInertiaTestsBase.g.cs
@@ -0,0 +1,293 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of AreaMomentOfInertia.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class AreaMomentOfInertiaTestsBase
+    {
+        protected abstract double CentimetersToTheFourthInOneMeterToTheFourth { get; }
+        protected abstract double DecimetersToTheFourthInOneMeterToTheFourth { get; }
+        protected abstract double FeetToTheFourthInOneMeterToTheFourth { get; }
+        protected abstract double InchesToTheFourthInOneMeterToTheFourth { get; }
+        protected abstract double MetersToTheFourthInOneMeterToTheFourth { get; }
+        protected abstract double MillimetersToTheFourthInOneMeterToTheFourth { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CentimetersToTheFourthTolerance { get { return 1e-5; } }
+        protected virtual double DecimetersToTheFourthTolerance { get { return 1e-5; } }
+        protected virtual double FeetToTheFourthTolerance { get { return 1e-5; } }
+        protected virtual double InchesToTheFourthTolerance { get { return 1e-5; } }
+        protected virtual double MetersToTheFourthTolerance { get { return 1e-5; } }
+        protected virtual double MillimetersToTheFourthTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>((double)0.0, AreaMomentOfInertiaUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>(double.PositiveInfinity, AreaMomentOfInertiaUnit.MeterToTheFourth));
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>(double.NegativeInfinity, AreaMomentOfInertiaUnit.MeterToTheFourth));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>(double.NaN, AreaMomentOfInertiaUnit.MeterToTheFourth));
+        }
+
+        [Fact]
+        public void MeterToTheFourthToAreaMomentOfInertiaUnits()
+        {
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            AssertEx.EqualTolerance(CentimetersToTheFourthInOneMeterToTheFourth, metertothefourth.CentimetersToTheFourth, CentimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(DecimetersToTheFourthInOneMeterToTheFourth, metertothefourth.DecimetersToTheFourth, DecimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(FeetToTheFourthInOneMeterToTheFourth, metertothefourth.FeetToTheFourth, FeetToTheFourthTolerance);
+            AssertEx.EqualTolerance(InchesToTheFourthInOneMeterToTheFourth, metertothefourth.InchesToTheFourth, InchesToTheFourthTolerance);
+            AssertEx.EqualTolerance(MetersToTheFourthInOneMeterToTheFourth, metertothefourth.MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(MillimetersToTheFourthInOneMeterToTheFourth, metertothefourth.MillimetersToTheFourth, MillimetersToTheFourthTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.CentimeterToTheFourth).CentimetersToTheFourth, CentimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.DecimeterToTheFourth).DecimetersToTheFourth, DecimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.FootToTheFourth).FeetToTheFourth, FeetToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.InchToTheFourth).InchesToTheFourth, InchesToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.MeterToTheFourth).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.MillimeterToTheFourth).MillimetersToTheFourth, MillimetersToTheFourthTolerance);
+        }
+
+        [Fact]
+        public void FromMetersToTheFourth_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia<double>.FromMetersToTheFourth(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia<double>.FromMetersToTheFourth(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromMetersToTheFourth_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia<double>.FromMetersToTheFourth(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            AssertEx.EqualTolerance(CentimetersToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.CentimeterToTheFourth), CentimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(DecimetersToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.DecimeterToTheFourth), DecimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(FeetToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.FootToTheFourth), FeetToTheFourthTolerance);
+            AssertEx.EqualTolerance(InchesToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.InchToTheFourth), InchesToTheFourthTolerance);
+            AssertEx.EqualTolerance(MetersToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.MeterToTheFourth), MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(MillimetersToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.MillimeterToTheFourth), MillimetersToTheFourthTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+
+            var centimetertothefourthQuantity = metertothefourth.ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth);
+            AssertEx.EqualTolerance(CentimetersToTheFourthInOneMeterToTheFourth, (double)centimetertothefourthQuantity.Value, CentimetersToTheFourthTolerance);
+            Assert.Equal(AreaMomentOfInertiaUnit.CentimeterToTheFourth, centimetertothefourthQuantity.Unit);
+
+            var decimetertothefourthQuantity = metertothefourth.ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth);
+            AssertEx.EqualTolerance(DecimetersToTheFourthInOneMeterToTheFourth, (double)decimetertothefourthQuantity.Value, DecimetersToTheFourthTolerance);
+            Assert.Equal(AreaMomentOfInertiaUnit.DecimeterToTheFourth, decimetertothefourthQuantity.Unit);
+
+            var foottothefourthQuantity = metertothefourth.ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth);
+            AssertEx.EqualTolerance(FeetToTheFourthInOneMeterToTheFourth, (double)foottothefourthQuantity.Value, FeetToTheFourthTolerance);
+            Assert.Equal(AreaMomentOfInertiaUnit.FootToTheFourth, foottothefourthQuantity.Unit);
+
+            var inchtothefourthQuantity = metertothefourth.ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth);
+            AssertEx.EqualTolerance(InchesToTheFourthInOneMeterToTheFourth, (double)inchtothefourthQuantity.Value, InchesToTheFourthTolerance);
+            Assert.Equal(AreaMomentOfInertiaUnit.InchToTheFourth, inchtothefourthQuantity.Unit);
+
+            var metertothefourthQuantity = metertothefourth.ToUnit(AreaMomentOfInertiaUnit.MeterToTheFourth);
+            AssertEx.EqualTolerance(MetersToTheFourthInOneMeterToTheFourth, (double)metertothefourthQuantity.Value, MetersToTheFourthTolerance);
+            Assert.Equal(AreaMomentOfInertiaUnit.MeterToTheFourth, metertothefourthQuantity.Unit);
+
+            var millimetertothefourthQuantity = metertothefourth.ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth);
+            AssertEx.EqualTolerance(MillimetersToTheFourthInOneMeterToTheFourth, (double)millimetertothefourthQuantity.Value, MillimetersToTheFourthTolerance);
+            Assert.Equal(AreaMomentOfInertiaUnit.MillimeterToTheFourth, millimetertothefourthQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromCentimetersToTheFourth(metertothefourth.CentimetersToTheFourth).MetersToTheFourth, CentimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromDecimetersToTheFourth(metertothefourth.DecimetersToTheFourth).MetersToTheFourth, DecimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromFeetToTheFourth(metertothefourth.FeetToTheFourth).MetersToTheFourth, FeetToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromInchesToTheFourth(metertothefourth.InchesToTheFourth).MetersToTheFourth, InchesToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromMetersToTheFourth(metertothefourth.MetersToTheFourth).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromMillimetersToTheFourth(metertothefourth.MillimetersToTheFourth).MetersToTheFourth, MillimetersToTheFourthTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            AreaMomentOfInertia<double> v = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            AssertEx.EqualTolerance(-1, -v.MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(2, (AreaMomentOfInertia<double>.FromMetersToTheFourth(3)-v).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(2, (v + v).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(10, (v*10).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(10, (10*v).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(2, (AreaMomentOfInertia<double>.FromMetersToTheFourth(10)/5).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(2, AreaMomentOfInertia<double>.FromMetersToTheFourth(10)/AreaMomentOfInertia<double>.FromMetersToTheFourth(5), MetersToTheFourthTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            AreaMomentOfInertia<double> oneMeterToTheFourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> twoMetersToTheFourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(2);
+
+            Assert.True(oneMeterToTheFourth < twoMetersToTheFourth);
+            Assert.True(oneMeterToTheFourth <= twoMetersToTheFourth);
+            Assert.True(twoMetersToTheFourth > oneMeterToTheFourth);
+            Assert.True(twoMetersToTheFourth >= oneMeterToTheFourth);
+
+            Assert.False(oneMeterToTheFourth > twoMetersToTheFourth);
+            Assert.False(oneMeterToTheFourth >= twoMetersToTheFourth);
+            Assert.False(twoMetersToTheFourth < oneMeterToTheFourth);
+            Assert.False(twoMetersToTheFourth <= oneMeterToTheFourth);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            Assert.Equal(0, metertothefourth.CompareTo(metertothefourth));
+            Assert.True(metertothefourth.CompareTo(AreaMomentOfInertia<double>.Zero) > 0);
+            Assert.True(AreaMomentOfInertia<double>.Zero.CompareTo(metertothefourth) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            Assert.Throws<ArgumentException>(() => metertothefourth.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            Assert.Throws<ArgumentNullException>(() => metertothefourth.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            var b = AreaMomentOfInertia<double>.FromMetersToTheFourth(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            var b = AreaMomentOfInertia<double>.FromMetersToTheFourth(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            Assert.True(v.Equals(AreaMomentOfInertia<double>.FromMetersToTheFourth(1), MetersToTheFourthTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(AreaMomentOfInertia<double>.Zero, MetersToTheFourthTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            Assert.False(metertothefourth.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            Assert.False(metertothefourth.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(AreaMomentOfInertiaUnit.Undefined, AreaMomentOfInertia<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(AreaMomentOfInertiaUnit)).Cast<AreaMomentOfInertiaUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == AreaMomentOfInertiaUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(AreaMomentOfInertia<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/BrakeSpecificFuelConsumptionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/BrakeSpecificFuelConsumptionTestsBase.g.cs
new file mode 100644
index 0000000000..4a7ad6f695
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/BrakeSpecificFuelConsumptionTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of BrakeSpecificFuelConsumption.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class BrakeSpecificFuelConsumptionTestsBase
+    {
+        protected abstract double GramsPerKiloWattHourInOneKilogramPerJoule { get; }
+        protected abstract double KilogramsPerJouleInOneKilogramPerJoule { get; }
+        protected abstract double PoundsPerMechanicalHorsepowerHourInOneKilogramPerJoule { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double GramsPerKiloWattHourTolerance { get { return 1e-5; } }
+        protected virtual double KilogramsPerJouleTolerance { get { return 1e-5; } }
+        protected virtual double PoundsPerMechanicalHorsepowerHourTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>((double)0.0, BrakeSpecificFuelConsumptionUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>(double.PositiveInfinity, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>(double.NegativeInfinity, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>(double.NaN, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
+        }
+
+        [Fact]
+        public void KilogramPerJouleToBrakeSpecificFuelConsumptionUnits()
+        {
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            AssertEx.EqualTolerance(GramsPerKiloWattHourInOneKilogramPerJoule, kilogramperjoule.GramsPerKiloWattHour, GramsPerKiloWattHourTolerance);
+            AssertEx.EqualTolerance(KilogramsPerJouleInOneKilogramPerJoule, kilogramperjoule.KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(PoundsPerMechanicalHorsepowerHourInOneKilogramPerJoule, kilogramperjoule.PoundsPerMechanicalHorsepowerHour, PoundsPerMechanicalHorsepowerHourTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.From(1, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour).GramsPerKiloWattHour, GramsPerKiloWattHourTolerance);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.From(1, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.From(1, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour).PoundsPerMechanicalHorsepowerHour, PoundsPerMechanicalHorsepowerHourTolerance);
+        }
+
+        [Fact]
+        public void FromKilogramsPerJoule_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromKilogramsPerJoule_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            AssertEx.EqualTolerance(GramsPerKiloWattHourInOneKilogramPerJoule, kilogramperjoule.As(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour), GramsPerKiloWattHourTolerance);
+            AssertEx.EqualTolerance(KilogramsPerJouleInOneKilogramPerJoule, kilogramperjoule.As(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule), KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(PoundsPerMechanicalHorsepowerHourInOneKilogramPerJoule, kilogramperjoule.As(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour), PoundsPerMechanicalHorsepowerHourTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+
+            var gramperkilowatthourQuantity = kilogramperjoule.ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
+            AssertEx.EqualTolerance(GramsPerKiloWattHourInOneKilogramPerJoule, (double)gramperkilowatthourQuantity.Value, GramsPerKiloWattHourTolerance);
+            Assert.Equal(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, gramperkilowatthourQuantity.Unit);
+
+            var kilogramperjouleQuantity = kilogramperjoule.ToUnit(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
+            AssertEx.EqualTolerance(KilogramsPerJouleInOneKilogramPerJoule, (double)kilogramperjouleQuantity.Value, KilogramsPerJouleTolerance);
+            Assert.Equal(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, kilogramperjouleQuantity.Unit);
+
+            var poundpermechanicalhorsepowerhourQuantity = kilogramperjoule.ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
+            AssertEx.EqualTolerance(PoundsPerMechanicalHorsepowerHourInOneKilogramPerJoule, (double)poundpermechanicalhorsepowerhourQuantity.Value, PoundsPerMechanicalHorsepowerHourTolerance);
+            Assert.Equal(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, poundpermechanicalhorsepowerhourQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.FromGramsPerKiloWattHour(kilogramperjoule.GramsPerKiloWattHour).KilogramsPerJoule, GramsPerKiloWattHourTolerance);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(kilogramperjoule.KilogramsPerJoule).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.FromPoundsPerMechanicalHorsepowerHour(kilogramperjoule.PoundsPerMechanicalHorsepowerHour).KilogramsPerJoule, PoundsPerMechanicalHorsepowerHourTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            BrakeSpecificFuelConsumption<double> v = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            AssertEx.EqualTolerance(-1, -v.KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(3)-v).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(2, (v + v).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(10, (v*10).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(10, (10*v).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(10)/5).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(2, BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(10)/BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(5), KilogramsPerJouleTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            BrakeSpecificFuelConsumption<double> oneKilogramPerJoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> twoKilogramsPerJoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(2);
+
+            Assert.True(oneKilogramPerJoule < twoKilogramsPerJoule);
+            Assert.True(oneKilogramPerJoule <= twoKilogramsPerJoule);
+            Assert.True(twoKilogramsPerJoule > oneKilogramPerJoule);
+            Assert.True(twoKilogramsPerJoule >= oneKilogramPerJoule);
+
+            Assert.False(oneKilogramPerJoule > twoKilogramsPerJoule);
+            Assert.False(oneKilogramPerJoule >= twoKilogramsPerJoule);
+            Assert.False(twoKilogramsPerJoule < oneKilogramPerJoule);
+            Assert.False(twoKilogramsPerJoule <= oneKilogramPerJoule);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            Assert.Equal(0, kilogramperjoule.CompareTo(kilogramperjoule));
+            Assert.True(kilogramperjoule.CompareTo(BrakeSpecificFuelConsumption<double>.Zero) > 0);
+            Assert.True(BrakeSpecificFuelConsumption<double>.Zero.CompareTo(kilogramperjoule) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            Assert.Throws<ArgumentException>(() => kilogramperjoule.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            Assert.Throws<ArgumentNullException>(() => kilogramperjoule.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            var b = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            var b = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            Assert.True(v.Equals(BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1), KilogramsPerJouleTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(BrakeSpecificFuelConsumption<double>.Zero, KilogramsPerJouleTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            Assert.False(kilogramperjoule.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            Assert.False(kilogramperjoule.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(BrakeSpecificFuelConsumptionUnit.Undefined, BrakeSpecificFuelConsumption<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(BrakeSpecificFuelConsumptionUnit)).Cast<BrakeSpecificFuelConsumptionUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == BrakeSpecificFuelConsumptionUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(BrakeSpecificFuelConsumption<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/CapacitanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/CapacitanceTestsBase.g.cs
new file mode 100644
index 0000000000..da71fa5223
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/CapacitanceTestsBase.g.cs
@@ -0,0 +1,303 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Capacitance.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class CapacitanceTestsBase
+    {
+        protected abstract double FaradsInOneFarad { get; }
+        protected abstract double KilofaradsInOneFarad { get; }
+        protected abstract double MegafaradsInOneFarad { get; }
+        protected abstract double MicrofaradsInOneFarad { get; }
+        protected abstract double MillifaradsInOneFarad { get; }
+        protected abstract double NanofaradsInOneFarad { get; }
+        protected abstract double PicofaradsInOneFarad { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double FaradsTolerance { get { return 1e-5; } }
+        protected virtual double KilofaradsTolerance { get { return 1e-5; } }
+        protected virtual double MegafaradsTolerance { get { return 1e-5; } }
+        protected virtual double MicrofaradsTolerance { get { return 1e-5; } }
+        protected virtual double MillifaradsTolerance { get { return 1e-5; } }
+        protected virtual double NanofaradsTolerance { get { return 1e-5; } }
+        protected virtual double PicofaradsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>((double)0.0, CapacitanceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>(double.PositiveInfinity, CapacitanceUnit.Farad));
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>(double.NegativeInfinity, CapacitanceUnit.Farad));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>(double.NaN, CapacitanceUnit.Farad));
+        }
+
+        [Fact]
+        public void FaradToCapacitanceUnits()
+        {
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            AssertEx.EqualTolerance(FaradsInOneFarad, farad.Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(KilofaradsInOneFarad, farad.Kilofarads, KilofaradsTolerance);
+            AssertEx.EqualTolerance(MegafaradsInOneFarad, farad.Megafarads, MegafaradsTolerance);
+            AssertEx.EqualTolerance(MicrofaradsInOneFarad, farad.Microfarads, MicrofaradsTolerance);
+            AssertEx.EqualTolerance(MillifaradsInOneFarad, farad.Millifarads, MillifaradsTolerance);
+            AssertEx.EqualTolerance(NanofaradsInOneFarad, farad.Nanofarads, NanofaradsTolerance);
+            AssertEx.EqualTolerance(PicofaradsInOneFarad, farad.Picofarads, PicofaradsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Capacitance<double>.From(1, CapacitanceUnit.Farad).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.From(1, CapacitanceUnit.Kilofarad).Kilofarads, KilofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.From(1, CapacitanceUnit.Megafarad).Megafarads, MegafaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.From(1, CapacitanceUnit.Microfarad).Microfarads, MicrofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.From(1, CapacitanceUnit.Millifarad).Millifarads, MillifaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.From(1, CapacitanceUnit.Nanofarad).Nanofarads, NanofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.From(1, CapacitanceUnit.Picofarad).Picofarads, PicofaradsTolerance);
+        }
+
+        [Fact]
+        public void FromFarads_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Capacitance<double>.FromFarads(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Capacitance<double>.FromFarads(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromFarads_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Capacitance<double>.FromFarads(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var farad = Capacitance<double>.FromFarads(1);
+            AssertEx.EqualTolerance(FaradsInOneFarad, farad.As(CapacitanceUnit.Farad), FaradsTolerance);
+            AssertEx.EqualTolerance(KilofaradsInOneFarad, farad.As(CapacitanceUnit.Kilofarad), KilofaradsTolerance);
+            AssertEx.EqualTolerance(MegafaradsInOneFarad, farad.As(CapacitanceUnit.Megafarad), MegafaradsTolerance);
+            AssertEx.EqualTolerance(MicrofaradsInOneFarad, farad.As(CapacitanceUnit.Microfarad), MicrofaradsTolerance);
+            AssertEx.EqualTolerance(MillifaradsInOneFarad, farad.As(CapacitanceUnit.Millifarad), MillifaradsTolerance);
+            AssertEx.EqualTolerance(NanofaradsInOneFarad, farad.As(CapacitanceUnit.Nanofarad), NanofaradsTolerance);
+            AssertEx.EqualTolerance(PicofaradsInOneFarad, farad.As(CapacitanceUnit.Picofarad), PicofaradsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var farad = Capacitance<double>.FromFarads(1);
+
+            var faradQuantity = farad.ToUnit(CapacitanceUnit.Farad);
+            AssertEx.EqualTolerance(FaradsInOneFarad, (double)faradQuantity.Value, FaradsTolerance);
+            Assert.Equal(CapacitanceUnit.Farad, faradQuantity.Unit);
+
+            var kilofaradQuantity = farad.ToUnit(CapacitanceUnit.Kilofarad);
+            AssertEx.EqualTolerance(KilofaradsInOneFarad, (double)kilofaradQuantity.Value, KilofaradsTolerance);
+            Assert.Equal(CapacitanceUnit.Kilofarad, kilofaradQuantity.Unit);
+
+            var megafaradQuantity = farad.ToUnit(CapacitanceUnit.Megafarad);
+            AssertEx.EqualTolerance(MegafaradsInOneFarad, (double)megafaradQuantity.Value, MegafaradsTolerance);
+            Assert.Equal(CapacitanceUnit.Megafarad, megafaradQuantity.Unit);
+
+            var microfaradQuantity = farad.ToUnit(CapacitanceUnit.Microfarad);
+            AssertEx.EqualTolerance(MicrofaradsInOneFarad, (double)microfaradQuantity.Value, MicrofaradsTolerance);
+            Assert.Equal(CapacitanceUnit.Microfarad, microfaradQuantity.Unit);
+
+            var millifaradQuantity = farad.ToUnit(CapacitanceUnit.Millifarad);
+            AssertEx.EqualTolerance(MillifaradsInOneFarad, (double)millifaradQuantity.Value, MillifaradsTolerance);
+            Assert.Equal(CapacitanceUnit.Millifarad, millifaradQuantity.Unit);
+
+            var nanofaradQuantity = farad.ToUnit(CapacitanceUnit.Nanofarad);
+            AssertEx.EqualTolerance(NanofaradsInOneFarad, (double)nanofaradQuantity.Value, NanofaradsTolerance);
+            Assert.Equal(CapacitanceUnit.Nanofarad, nanofaradQuantity.Unit);
+
+            var picofaradQuantity = farad.ToUnit(CapacitanceUnit.Picofarad);
+            AssertEx.EqualTolerance(PicofaradsInOneFarad, (double)picofaradQuantity.Value, PicofaradsTolerance);
+            Assert.Equal(CapacitanceUnit.Picofarad, picofaradQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromFarads(farad.Farads).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromKilofarads(farad.Kilofarads).Farads, KilofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromMegafarads(farad.Megafarads).Farads, MegafaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromMicrofarads(farad.Microfarads).Farads, MicrofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromMillifarads(farad.Millifarads).Farads, MillifaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromNanofarads(farad.Nanofarads).Farads, NanofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromPicofarads(farad.Picofarads).Farads, PicofaradsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Capacitance<double> v = Capacitance<double>.FromFarads(1);
+            AssertEx.EqualTolerance(-1, -v.Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(2, (Capacitance<double>.FromFarads(3)-v).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(2, (Capacitance<double>.FromFarads(10)/5).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(2, Capacitance<double>.FromFarads(10)/Capacitance<double>.FromFarads(5), FaradsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Capacitance<double> oneFarad = Capacitance<double>.FromFarads(1);
+            Capacitance<double> twoFarads = Capacitance<double>.FromFarads(2);
+
+            Assert.True(oneFarad < twoFarads);
+            Assert.True(oneFarad <= twoFarads);
+            Assert.True(twoFarads > oneFarad);
+            Assert.True(twoFarads >= oneFarad);
+
+            Assert.False(oneFarad > twoFarads);
+            Assert.False(oneFarad >= twoFarads);
+            Assert.False(twoFarads < oneFarad);
+            Assert.False(twoFarads <= oneFarad);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            Assert.Equal(0, farad.CompareTo(farad));
+            Assert.True(farad.CompareTo(Capacitance<double>.Zero) > 0);
+            Assert.True(Capacitance<double>.Zero.CompareTo(farad) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            Assert.Throws<ArgumentException>(() => farad.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            Assert.Throws<ArgumentNullException>(() => farad.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Capacitance<double>.FromFarads(1);
+            var b = Capacitance<double>.FromFarads(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Capacitance<double>.FromFarads(1);
+            var b = Capacitance<double>.FromFarads(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Capacitance<double>.FromFarads(1);
+            Assert.True(v.Equals(Capacitance<double>.FromFarads(1), FaradsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Capacitance<double>.Zero, FaradsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            Assert.False(farad.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            Assert.False(farad.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(CapacitanceUnit.Undefined, Capacitance<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(CapacitanceUnit)).Cast<CapacitanceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == CapacitanceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Capacitance<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/CoefficientOfThermalExpansionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/CoefficientOfThermalExpansionTestsBase.g.cs
new file mode 100644
index 0000000000..ff51c828e2
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/CoefficientOfThermalExpansionTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of CoefficientOfThermalExpansion.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class CoefficientOfThermalExpansionTestsBase
+    {
+        protected abstract double InverseDegreeCelsiusInOneInverseKelvin { get; }
+        protected abstract double InverseDegreeFahrenheitInOneInverseKelvin { get; }
+        protected abstract double InverseKelvinInOneInverseKelvin { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double InverseDegreeCelsiusTolerance { get { return 1e-5; } }
+        protected virtual double InverseDegreeFahrenheitTolerance { get { return 1e-5; } }
+        protected virtual double InverseKelvinTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>((double)0.0, CoefficientOfThermalExpansionUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>(double.PositiveInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin));
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>(double.NegativeInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>(double.NaN, CoefficientOfThermalExpansionUnit.InverseKelvin));
+        }
+
+        [Fact]
+        public void InverseKelvinToCoefficientOfThermalExpansionUnits()
+        {
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, inversekelvin.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, inversekelvin.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, inversekelvin.InverseKelvin, InverseKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius).InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit).InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.From(1, CoefficientOfThermalExpansionUnit.InverseKelvin).InverseKelvin, InverseKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromInverseKelvin_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion<double>.FromInverseKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion<double>.FromInverseKelvin(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromInverseKelvin_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion<double>.FromInverseKelvin(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius), InverseDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit), InverseDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseKelvin), InverseKelvinTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+
+            var inversedegreecelsiusQuantity = inversekelvin.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
+            AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, (double)inversedegreecelsiusQuantity.Value, InverseDegreeCelsiusTolerance);
+            Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, inversedegreecelsiusQuantity.Unit);
+
+            var inversedegreefahrenheitQuantity = inversekelvin.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
+            AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, (double)inversedegreefahrenheitQuantity.Value, InverseDegreeFahrenheitTolerance);
+            Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, inversedegreefahrenheitQuantity.Unit);
+
+            var inversekelvinQuantity = inversekelvin.ToUnit(CoefficientOfThermalExpansionUnit.InverseKelvin);
+            AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, (double)inversekelvinQuantity.Value, InverseKelvinTolerance);
+            Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, inversekelvinQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.FromInverseDegreeCelsius(inversekelvin.InverseDegreeCelsius).InverseKelvin, InverseDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.FromInverseDegreeFahrenheit(inversekelvin.InverseDegreeFahrenheit).InverseKelvin, InverseDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.FromInverseKelvin(inversekelvin.InverseKelvin).InverseKelvin, InverseKelvinTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            CoefficientOfThermalExpansion<double> v = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            AssertEx.EqualTolerance(-1, -v.InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion<double>.FromInverseKelvin(3)-v).InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(2, (v + v).InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(10, (v*10).InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(10, (10*v).InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion<double>.FromInverseKelvin(10)/5).InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(2, CoefficientOfThermalExpansion<double>.FromInverseKelvin(10)/CoefficientOfThermalExpansion<double>.FromInverseKelvin(5), InverseKelvinTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            CoefficientOfThermalExpansion<double> oneInverseKelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> twoInverseKelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(2);
+
+            Assert.True(oneInverseKelvin < twoInverseKelvin);
+            Assert.True(oneInverseKelvin <= twoInverseKelvin);
+            Assert.True(twoInverseKelvin > oneInverseKelvin);
+            Assert.True(twoInverseKelvin >= oneInverseKelvin);
+
+            Assert.False(oneInverseKelvin > twoInverseKelvin);
+            Assert.False(oneInverseKelvin >= twoInverseKelvin);
+            Assert.False(twoInverseKelvin < oneInverseKelvin);
+            Assert.False(twoInverseKelvin <= oneInverseKelvin);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            Assert.Equal(0, inversekelvin.CompareTo(inversekelvin));
+            Assert.True(inversekelvin.CompareTo(CoefficientOfThermalExpansion<double>.Zero) > 0);
+            Assert.True(CoefficientOfThermalExpansion<double>.Zero.CompareTo(inversekelvin) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            Assert.Throws<ArgumentException>(() => inversekelvin.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            Assert.Throws<ArgumentNullException>(() => inversekelvin.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            var b = CoefficientOfThermalExpansion<double>.FromInverseKelvin(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            var b = CoefficientOfThermalExpansion<double>.FromInverseKelvin(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            Assert.True(v.Equals(CoefficientOfThermalExpansion<double>.FromInverseKelvin(1), InverseKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(CoefficientOfThermalExpansion<double>.Zero, InverseKelvinTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            Assert.False(inversekelvin.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            Assert.False(inversekelvin.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(CoefficientOfThermalExpansionUnit.Undefined, CoefficientOfThermalExpansion<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(CoefficientOfThermalExpansionUnit)).Cast<CoefficientOfThermalExpansionUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == CoefficientOfThermalExpansionUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(CoefficientOfThermalExpansion<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs
new file mode 100644
index 0000000000..08e111ca92
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs
@@ -0,0 +1,333 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Duration.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class DurationTestsBase
+    {
+        protected abstract double DaysInOneSecond { get; }
+        protected abstract double HoursInOneSecond { get; }
+        protected abstract double MicrosecondsInOneSecond { get; }
+        protected abstract double MillisecondsInOneSecond { get; }
+        protected abstract double MinutesInOneSecond { get; }
+        protected abstract double Months30InOneSecond { get; }
+        protected abstract double NanosecondsInOneSecond { get; }
+        protected abstract double SecondsInOneSecond { get; }
+        protected abstract double WeeksInOneSecond { get; }
+        protected abstract double Years365InOneSecond { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DaysTolerance { get { return 1e-5; } }
+        protected virtual double HoursTolerance { get { return 1e-5; } }
+        protected virtual double MicrosecondsTolerance { get { return 1e-5; } }
+        protected virtual double MillisecondsTolerance { get { return 1e-5; } }
+        protected virtual double MinutesTolerance { get { return 1e-5; } }
+        protected virtual double Months30Tolerance { get { return 1e-5; } }
+        protected virtual double NanosecondsTolerance { get { return 1e-5; } }
+        protected virtual double SecondsTolerance { get { return 1e-5; } }
+        protected virtual double WeeksTolerance { get { return 1e-5; } }
+        protected virtual double Years365Tolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Duration<double>((double)0.0, DurationUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Duration<double>(double.PositiveInfinity, DurationUnit.Second));
+            Assert.Throws<ArgumentException>(() => new Duration<double>(double.NegativeInfinity, DurationUnit.Second));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Duration<double>(double.NaN, DurationUnit.Second));
+        }
+
+        [Fact]
+        public void SecondToDurationUnits()
+        {
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            AssertEx.EqualTolerance(DaysInOneSecond, second.Days, DaysTolerance);
+            AssertEx.EqualTolerance(HoursInOneSecond, second.Hours, HoursTolerance);
+            AssertEx.EqualTolerance(MicrosecondsInOneSecond, second.Microseconds, MicrosecondsTolerance);
+            AssertEx.EqualTolerance(MillisecondsInOneSecond, second.Milliseconds, MillisecondsTolerance);
+            AssertEx.EqualTolerance(MinutesInOneSecond, second.Minutes, MinutesTolerance);
+            AssertEx.EqualTolerance(Months30InOneSecond, second.Months30, Months30Tolerance);
+            AssertEx.EqualTolerance(NanosecondsInOneSecond, second.Nanoseconds, NanosecondsTolerance);
+            AssertEx.EqualTolerance(SecondsInOneSecond, second.Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(WeeksInOneSecond, second.Weeks, WeeksTolerance);
+            AssertEx.EqualTolerance(Years365InOneSecond, second.Years365, Years365Tolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Day).Days, DaysTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Hour).Hours, HoursTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Microsecond).Microseconds, MicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Millisecond).Milliseconds, MillisecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Minute).Minutes, MinutesTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Month30).Months30, Months30Tolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Nanosecond).Nanoseconds, NanosecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Second).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Week).Weeks, WeeksTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.From(1, DurationUnit.Year365).Years365, Years365Tolerance);
+        }
+
+        [Fact]
+        public void FromSeconds_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Duration<double>.FromSeconds(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Duration<double>.FromSeconds(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromSeconds_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Duration<double>.FromSeconds(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var second = Duration<double>.FromSeconds(1);
+            AssertEx.EqualTolerance(DaysInOneSecond, second.As(DurationUnit.Day), DaysTolerance);
+            AssertEx.EqualTolerance(HoursInOneSecond, second.As(DurationUnit.Hour), HoursTolerance);
+            AssertEx.EqualTolerance(MicrosecondsInOneSecond, second.As(DurationUnit.Microsecond), MicrosecondsTolerance);
+            AssertEx.EqualTolerance(MillisecondsInOneSecond, second.As(DurationUnit.Millisecond), MillisecondsTolerance);
+            AssertEx.EqualTolerance(MinutesInOneSecond, second.As(DurationUnit.Minute), MinutesTolerance);
+            AssertEx.EqualTolerance(Months30InOneSecond, second.As(DurationUnit.Month30), Months30Tolerance);
+            AssertEx.EqualTolerance(NanosecondsInOneSecond, second.As(DurationUnit.Nanosecond), NanosecondsTolerance);
+            AssertEx.EqualTolerance(SecondsInOneSecond, second.As(DurationUnit.Second), SecondsTolerance);
+            AssertEx.EqualTolerance(WeeksInOneSecond, second.As(DurationUnit.Week), WeeksTolerance);
+            AssertEx.EqualTolerance(Years365InOneSecond, second.As(DurationUnit.Year365), Years365Tolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var second = Duration<double>.FromSeconds(1);
+
+            var dayQuantity = second.ToUnit(DurationUnit.Day);
+            AssertEx.EqualTolerance(DaysInOneSecond, (double)dayQuantity.Value, DaysTolerance);
+            Assert.Equal(DurationUnit.Day, dayQuantity.Unit);
+
+            var hourQuantity = second.ToUnit(DurationUnit.Hour);
+            AssertEx.EqualTolerance(HoursInOneSecond, (double)hourQuantity.Value, HoursTolerance);
+            Assert.Equal(DurationUnit.Hour, hourQuantity.Unit);
+
+            var microsecondQuantity = second.ToUnit(DurationUnit.Microsecond);
+            AssertEx.EqualTolerance(MicrosecondsInOneSecond, (double)microsecondQuantity.Value, MicrosecondsTolerance);
+            Assert.Equal(DurationUnit.Microsecond, microsecondQuantity.Unit);
+
+            var millisecondQuantity = second.ToUnit(DurationUnit.Millisecond);
+            AssertEx.EqualTolerance(MillisecondsInOneSecond, (double)millisecondQuantity.Value, MillisecondsTolerance);
+            Assert.Equal(DurationUnit.Millisecond, millisecondQuantity.Unit);
+
+            var minuteQuantity = second.ToUnit(DurationUnit.Minute);
+            AssertEx.EqualTolerance(MinutesInOneSecond, (double)minuteQuantity.Value, MinutesTolerance);
+            Assert.Equal(DurationUnit.Minute, minuteQuantity.Unit);
+
+            var month30Quantity = second.ToUnit(DurationUnit.Month30);
+            AssertEx.EqualTolerance(Months30InOneSecond, (double)month30Quantity.Value, Months30Tolerance);
+            Assert.Equal(DurationUnit.Month30, month30Quantity.Unit);
+
+            var nanosecondQuantity = second.ToUnit(DurationUnit.Nanosecond);
+            AssertEx.EqualTolerance(NanosecondsInOneSecond, (double)nanosecondQuantity.Value, NanosecondsTolerance);
+            Assert.Equal(DurationUnit.Nanosecond, nanosecondQuantity.Unit);
+
+            var secondQuantity = second.ToUnit(DurationUnit.Second);
+            AssertEx.EqualTolerance(SecondsInOneSecond, (double)secondQuantity.Value, SecondsTolerance);
+            Assert.Equal(DurationUnit.Second, secondQuantity.Unit);
+
+            var weekQuantity = second.ToUnit(DurationUnit.Week);
+            AssertEx.EqualTolerance(WeeksInOneSecond, (double)weekQuantity.Value, WeeksTolerance);
+            Assert.Equal(DurationUnit.Week, weekQuantity.Unit);
+
+            var year365Quantity = second.ToUnit(DurationUnit.Year365);
+            AssertEx.EqualTolerance(Years365InOneSecond, (double)year365Quantity.Value, Years365Tolerance);
+            Assert.Equal(DurationUnit.Year365, year365Quantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            AssertEx.EqualTolerance(1, Duration<double>.FromDays(second.Days).Seconds, DaysTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromHours(second.Hours).Seconds, HoursTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMicroseconds(second.Microseconds).Seconds, MicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMilliseconds(second.Milliseconds).Seconds, MillisecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMinutes(second.Minutes).Seconds, MinutesTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMonths30(second.Months30).Seconds, Months30Tolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromNanoseconds(second.Nanoseconds).Seconds, NanosecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromSeconds(second.Seconds).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromWeeks(second.Weeks).Seconds, WeeksTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromYears365(second.Years365).Seconds, Years365Tolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Duration<double> v = Duration<double>.FromSeconds(1);
+            AssertEx.EqualTolerance(-1, -v.Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(2, (Duration<double>.FromSeconds(3)-v).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(2, (Duration<double>.FromSeconds(10)/5).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(2, Duration<double>.FromSeconds(10)/Duration<double>.FromSeconds(5), SecondsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Duration<double> oneSecond = Duration<double>.FromSeconds(1);
+            Duration<double> twoSeconds = Duration<double>.FromSeconds(2);
+
+            Assert.True(oneSecond < twoSeconds);
+            Assert.True(oneSecond <= twoSeconds);
+            Assert.True(twoSeconds > oneSecond);
+            Assert.True(twoSeconds >= oneSecond);
+
+            Assert.False(oneSecond > twoSeconds);
+            Assert.False(oneSecond >= twoSeconds);
+            Assert.False(twoSeconds < oneSecond);
+            Assert.False(twoSeconds <= oneSecond);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            Assert.Equal(0, second.CompareTo(second));
+            Assert.True(second.CompareTo(Duration<double>.Zero) > 0);
+            Assert.True(Duration<double>.Zero.CompareTo(second) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            Assert.Throws<ArgumentException>(() => second.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            Assert.Throws<ArgumentNullException>(() => second.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Duration<double>.FromSeconds(1);
+            var b = Duration<double>.FromSeconds(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Duration<double>.FromSeconds(1);
+            var b = Duration<double>.FromSeconds(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Duration<double>.FromSeconds(1);
+            Assert.True(v.Equals(Duration<double>.FromSeconds(1), SecondsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Duration<double>.Zero, SecondsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            Assert.False(second.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            Assert.False(second.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(DurationUnit.Undefined, Duration<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(DurationUnit)).Cast<DurationUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == DurationUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Duration<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/DynamicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DynamicViscosityTestsBase.g.cs
new file mode 100644
index 0000000000..db8d0c5af3
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/DynamicViscosityTestsBase.g.cs
@@ -0,0 +1,323 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of DynamicViscosity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class DynamicViscosityTestsBase
+    {
+        protected abstract double CentipoiseInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double MicropascalSecondsInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double MillipascalSecondsInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double NewtonSecondsPerMeterSquaredInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double PascalSecondsInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double PoiseInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double PoundsForceSecondPerSquareFootInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double PoundsForceSecondPerSquareInchInOneNewtonSecondPerMeterSquared { get; }
+        protected abstract double ReynsInOneNewtonSecondPerMeterSquared { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CentipoiseTolerance { get { return 1e-5; } }
+        protected virtual double MicropascalSecondsTolerance { get { return 1e-5; } }
+        protected virtual double MillipascalSecondsTolerance { get { return 1e-5; } }
+        protected virtual double NewtonSecondsPerMeterSquaredTolerance { get { return 1e-5; } }
+        protected virtual double PascalSecondsTolerance { get { return 1e-5; } }
+        protected virtual double PoiseTolerance { get { return 1e-5; } }
+        protected virtual double PoundsForceSecondPerSquareFootTolerance { get { return 1e-5; } }
+        protected virtual double PoundsForceSecondPerSquareInchTolerance { get { return 1e-5; } }
+        protected virtual double ReynsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>((double)0.0, DynamicViscosityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>(double.PositiveInfinity, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>(double.NegativeInfinity, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>(double.NaN, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
+        }
+
+        [Fact]
+        public void NewtonSecondPerMeterSquaredToDynamicViscosityUnits()
+        {
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            AssertEx.EqualTolerance(CentipoiseInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.Centipoise, CentipoiseTolerance);
+            AssertEx.EqualTolerance(MicropascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.MicropascalSeconds, MicropascalSecondsTolerance);
+            AssertEx.EqualTolerance(MillipascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.MillipascalSeconds, MillipascalSecondsTolerance);
+            AssertEx.EqualTolerance(NewtonSecondsPerMeterSquaredInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(PascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.PascalSeconds, PascalSecondsTolerance);
+            AssertEx.EqualTolerance(PoiseInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.Poise, PoiseTolerance);
+            AssertEx.EqualTolerance(PoundsForceSecondPerSquareFootInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.PoundsForceSecondPerSquareFoot, PoundsForceSecondPerSquareFootTolerance);
+            AssertEx.EqualTolerance(PoundsForceSecondPerSquareInchInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.PoundsForceSecondPerSquareInch, PoundsForceSecondPerSquareInchTolerance);
+            AssertEx.EqualTolerance(ReynsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.Reyns, ReynsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.Centipoise).Centipoise, CentipoiseTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.MicropascalSecond).MicropascalSeconds, MicropascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.MillipascalSecond).MillipascalSeconds, MillipascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.NewtonSecondPerMeterSquared).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.PascalSecond).PascalSeconds, PascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.Poise).Poise, PoiseTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.PoundForceSecondPerSquareFoot).PoundsForceSecondPerSquareFoot, PoundsForceSecondPerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.PoundForceSecondPerSquareInch).PoundsForceSecondPerSquareInch, PoundsForceSecondPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.From(1, DynamicViscosityUnit.Reyn).Reyns, ReynsTolerance);
+        }
+
+        [Fact]
+        public void FromNewtonSecondsPerMeterSquared_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromNewtonSecondsPerMeterSquared_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            AssertEx.EqualTolerance(CentipoiseInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.Centipoise), CentipoiseTolerance);
+            AssertEx.EqualTolerance(MicropascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.MicropascalSecond), MicropascalSecondsTolerance);
+            AssertEx.EqualTolerance(MillipascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.MillipascalSecond), MillipascalSecondsTolerance);
+            AssertEx.EqualTolerance(NewtonSecondsPerMeterSquaredInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.NewtonSecondPerMeterSquared), NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(PascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.PascalSecond), PascalSecondsTolerance);
+            AssertEx.EqualTolerance(PoiseInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.Poise), PoiseTolerance);
+            AssertEx.EqualTolerance(PoundsForceSecondPerSquareFootInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.PoundForceSecondPerSquareFoot), PoundsForceSecondPerSquareFootTolerance);
+            AssertEx.EqualTolerance(PoundsForceSecondPerSquareInchInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.PoundForceSecondPerSquareInch), PoundsForceSecondPerSquareInchTolerance);
+            AssertEx.EqualTolerance(ReynsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.Reyn), ReynsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+
+            var centipoiseQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.Centipoise);
+            AssertEx.EqualTolerance(CentipoiseInOneNewtonSecondPerMeterSquared, (double)centipoiseQuantity.Value, CentipoiseTolerance);
+            Assert.Equal(DynamicViscosityUnit.Centipoise, centipoiseQuantity.Unit);
+
+            var micropascalsecondQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.MicropascalSecond);
+            AssertEx.EqualTolerance(MicropascalSecondsInOneNewtonSecondPerMeterSquared, (double)micropascalsecondQuantity.Value, MicropascalSecondsTolerance);
+            Assert.Equal(DynamicViscosityUnit.MicropascalSecond, micropascalsecondQuantity.Unit);
+
+            var millipascalsecondQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.MillipascalSecond);
+            AssertEx.EqualTolerance(MillipascalSecondsInOneNewtonSecondPerMeterSquared, (double)millipascalsecondQuantity.Value, MillipascalSecondsTolerance);
+            Assert.Equal(DynamicViscosityUnit.MillipascalSecond, millipascalsecondQuantity.Unit);
+
+            var newtonsecondpermetersquaredQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared);
+            AssertEx.EqualTolerance(NewtonSecondsPerMeterSquaredInOneNewtonSecondPerMeterSquared, (double)newtonsecondpermetersquaredQuantity.Value, NewtonSecondsPerMeterSquaredTolerance);
+            Assert.Equal(DynamicViscosityUnit.NewtonSecondPerMeterSquared, newtonsecondpermetersquaredQuantity.Unit);
+
+            var pascalsecondQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.PascalSecond);
+            AssertEx.EqualTolerance(PascalSecondsInOneNewtonSecondPerMeterSquared, (double)pascalsecondQuantity.Value, PascalSecondsTolerance);
+            Assert.Equal(DynamicViscosityUnit.PascalSecond, pascalsecondQuantity.Unit);
+
+            var poiseQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.Poise);
+            AssertEx.EqualTolerance(PoiseInOneNewtonSecondPerMeterSquared, (double)poiseQuantity.Value, PoiseTolerance);
+            Assert.Equal(DynamicViscosityUnit.Poise, poiseQuantity.Unit);
+
+            var poundforcesecondpersquarefootQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
+            AssertEx.EqualTolerance(PoundsForceSecondPerSquareFootInOneNewtonSecondPerMeterSquared, (double)poundforcesecondpersquarefootQuantity.Value, PoundsForceSecondPerSquareFootTolerance);
+            Assert.Equal(DynamicViscosityUnit.PoundForceSecondPerSquareFoot, poundforcesecondpersquarefootQuantity.Unit);
+
+            var poundforcesecondpersquareinchQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareInch);
+            AssertEx.EqualTolerance(PoundsForceSecondPerSquareInchInOneNewtonSecondPerMeterSquared, (double)poundforcesecondpersquareinchQuantity.Value, PoundsForceSecondPerSquareInchTolerance);
+            Assert.Equal(DynamicViscosityUnit.PoundForceSecondPerSquareInch, poundforcesecondpersquareinchQuantity.Unit);
+
+            var reynQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.Reyn);
+            AssertEx.EqualTolerance(ReynsInOneNewtonSecondPerMeterSquared, (double)reynQuantity.Value, ReynsTolerance);
+            Assert.Equal(DynamicViscosityUnit.Reyn, reynQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromCentipoise(newtonsecondpermetersquared.Centipoise).NewtonSecondsPerMeterSquared, CentipoiseTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromMicropascalSeconds(newtonsecondpermetersquared.MicropascalSeconds).NewtonSecondsPerMeterSquared, MicropascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromMillipascalSeconds(newtonsecondpermetersquared.MillipascalSeconds).NewtonSecondsPerMeterSquared, MillipascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(newtonsecondpermetersquared.NewtonSecondsPerMeterSquared).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPascalSeconds(newtonsecondpermetersquared.PascalSeconds).NewtonSecondsPerMeterSquared, PascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPoise(newtonsecondpermetersquared.Poise).NewtonSecondsPerMeterSquared, PoiseTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPoundsForceSecondPerSquareFoot(newtonsecondpermetersquared.PoundsForceSecondPerSquareFoot).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPoundsForceSecondPerSquareInch(newtonsecondpermetersquared.PoundsForceSecondPerSquareInch).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromReyns(newtonsecondpermetersquared.Reyns).NewtonSecondsPerMeterSquared, ReynsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            DynamicViscosity<double> v = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            AssertEx.EqualTolerance(-1, -v.NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(2, (DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(3)-v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(2, (v + v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(10, (v*10).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(10, (10*v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(2, (DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(10)/5).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(2, DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(10)/DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(5), NewtonSecondsPerMeterSquaredTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            DynamicViscosity<double> oneNewtonSecondPerMeterSquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> twoNewtonSecondsPerMeterSquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(2);
+
+            Assert.True(oneNewtonSecondPerMeterSquared < twoNewtonSecondsPerMeterSquared);
+            Assert.True(oneNewtonSecondPerMeterSquared <= twoNewtonSecondsPerMeterSquared);
+            Assert.True(twoNewtonSecondsPerMeterSquared > oneNewtonSecondPerMeterSquared);
+            Assert.True(twoNewtonSecondsPerMeterSquared >= oneNewtonSecondPerMeterSquared);
+
+            Assert.False(oneNewtonSecondPerMeterSquared > twoNewtonSecondsPerMeterSquared);
+            Assert.False(oneNewtonSecondPerMeterSquared >= twoNewtonSecondsPerMeterSquared);
+            Assert.False(twoNewtonSecondsPerMeterSquared < oneNewtonSecondPerMeterSquared);
+            Assert.False(twoNewtonSecondsPerMeterSquared <= oneNewtonSecondPerMeterSquared);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            Assert.Equal(0, newtonsecondpermetersquared.CompareTo(newtonsecondpermetersquared));
+            Assert.True(newtonsecondpermetersquared.CompareTo(DynamicViscosity<double>.Zero) > 0);
+            Assert.True(DynamicViscosity<double>.Zero.CompareTo(newtonsecondpermetersquared) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            Assert.Throws<ArgumentException>(() => newtonsecondpermetersquared.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            Assert.Throws<ArgumentNullException>(() => newtonsecondpermetersquared.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            var b = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            var b = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            Assert.True(v.Equals(DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1), NewtonSecondsPerMeterSquaredTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(DynamicViscosity<double>.Zero, NewtonSecondsPerMeterSquaredTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            Assert.False(newtonsecondpermetersquared.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            Assert.False(newtonsecondpermetersquared.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(DynamicViscosityUnit.Undefined, DynamicViscosity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(DynamicViscosityUnit)).Cast<DynamicViscosityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == DynamicViscosityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(DynamicViscosity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricAdmittanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricAdmittanceTestsBase.g.cs
new file mode 100644
index 0000000000..647c58f719
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricAdmittanceTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricAdmittance.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricAdmittanceTestsBase
+    {
+        protected abstract double MicrosiemensInOneSiemens { get; }
+        protected abstract double MillisiemensInOneSiemens { get; }
+        protected abstract double NanosiemensInOneSiemens { get; }
+        protected abstract double SiemensInOneSiemens { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double MicrosiemensTolerance { get { return 1e-5; } }
+        protected virtual double MillisiemensTolerance { get { return 1e-5; } }
+        protected virtual double NanosiemensTolerance { get { return 1e-5; } }
+        protected virtual double SiemensTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>((double)0.0, ElectricAdmittanceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>(double.PositiveInfinity, ElectricAdmittanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>(double.NegativeInfinity, ElectricAdmittanceUnit.Siemens));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>(double.NaN, ElectricAdmittanceUnit.Siemens));
+        }
+
+        [Fact]
+        public void SiemensToElectricAdmittanceUnits()
+        {
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.Microsiemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.Millisiemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(NanosiemensInOneSiemens, siemens.Nanosiemens, NanosiemensTolerance);
+            AssertEx.EqualTolerance(SiemensInOneSiemens, siemens.Siemens, SiemensTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Microsiemens).Microsiemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Millisiemens).Millisiemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Nanosiemens).Nanosiemens, NanosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Siemens).Siemens, SiemensTolerance);
+        }
+
+        [Fact]
+        public void FromSiemens_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricAdmittance<double>.FromSiemens(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricAdmittance<double>.FromSiemens(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromSiemens_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricAdmittance<double>.FromSiemens(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var siemens = ElectricAdmittance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.As(ElectricAdmittanceUnit.Microsiemens), MicrosiemensTolerance);
+            AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.As(ElectricAdmittanceUnit.Millisiemens), MillisiemensTolerance);
+            AssertEx.EqualTolerance(NanosiemensInOneSiemens, siemens.As(ElectricAdmittanceUnit.Nanosiemens), NanosiemensTolerance);
+            AssertEx.EqualTolerance(SiemensInOneSiemens, siemens.As(ElectricAdmittanceUnit.Siemens), SiemensTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var siemens = ElectricAdmittance<double>.FromSiemens(1);
+
+            var microsiemensQuantity = siemens.ToUnit(ElectricAdmittanceUnit.Microsiemens);
+            AssertEx.EqualTolerance(MicrosiemensInOneSiemens, (double)microsiemensQuantity.Value, MicrosiemensTolerance);
+            Assert.Equal(ElectricAdmittanceUnit.Microsiemens, microsiemensQuantity.Unit);
+
+            var millisiemensQuantity = siemens.ToUnit(ElectricAdmittanceUnit.Millisiemens);
+            AssertEx.EqualTolerance(MillisiemensInOneSiemens, (double)millisiemensQuantity.Value, MillisiemensTolerance);
+            Assert.Equal(ElectricAdmittanceUnit.Millisiemens, millisiemensQuantity.Unit);
+
+            var nanosiemensQuantity = siemens.ToUnit(ElectricAdmittanceUnit.Nanosiemens);
+            AssertEx.EqualTolerance(NanosiemensInOneSiemens, (double)nanosiemensQuantity.Value, NanosiemensTolerance);
+            Assert.Equal(ElectricAdmittanceUnit.Nanosiemens, nanosiemensQuantity.Unit);
+
+            var siemensQuantity = siemens.ToUnit(ElectricAdmittanceUnit.Siemens);
+            AssertEx.EqualTolerance(SiemensInOneSiemens, (double)siemensQuantity.Value, SiemensTolerance);
+            Assert.Equal(ElectricAdmittanceUnit.Siemens, siemensQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromNanosiemens(siemens.Nanosiemens).Siemens, NanosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricAdmittance<double> v = ElectricAdmittance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(-1, -v.Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricAdmittance<double>.FromSiemens(3)-v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricAdmittance<double>.FromSiemens(10)/5).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, ElectricAdmittance<double>.FromSiemens(10)/ElectricAdmittance<double>.FromSiemens(5), SiemensTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricAdmittance<double> oneSiemens = ElectricAdmittance<double>.FromSiemens(1);
+            ElectricAdmittance<double> twoSiemens = ElectricAdmittance<double>.FromSiemens(2);
+
+            Assert.True(oneSiemens < twoSiemens);
+            Assert.True(oneSiemens <= twoSiemens);
+            Assert.True(twoSiemens > oneSiemens);
+            Assert.True(twoSiemens >= oneSiemens);
+
+            Assert.False(oneSiemens > twoSiemens);
+            Assert.False(oneSiemens >= twoSiemens);
+            Assert.False(twoSiemens < oneSiemens);
+            Assert.False(twoSiemens <= oneSiemens);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            Assert.Equal(0, siemens.CompareTo(siemens));
+            Assert.True(siemens.CompareTo(ElectricAdmittance<double>.Zero) > 0);
+            Assert.True(ElectricAdmittance<double>.Zero.CompareTo(siemens) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            Assert.Throws<ArgumentException>(() => siemens.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            Assert.Throws<ArgumentNullException>(() => siemens.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricAdmittance<double>.FromSiemens(1);
+            var b = ElectricAdmittance<double>.FromSiemens(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricAdmittance<double>.FromSiemens(1);
+            var b = ElectricAdmittance<double>.FromSiemens(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricAdmittance<double>.FromSiemens(1);
+            Assert.True(v.Equals(ElectricAdmittance<double>.FromSiemens(1), SiemensTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricAdmittance<double>.Zero, SiemensTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            Assert.False(siemens.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            Assert.False(siemens.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricAdmittanceUnit.Undefined, ElectricAdmittance<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricAdmittanceUnit)).Cast<ElectricAdmittanceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricAdmittanceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricAdmittance<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricChargeDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricChargeDensityTestsBase.g.cs
new file mode 100644
index 0000000000..bf026c49e4
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricChargeDensityTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricChargeDensity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricChargeDensityTestsBase
+    {
+        protected abstract double CoulombsPerCubicMeterInOneCoulombPerCubicMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CoulombsPerCubicMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>((double)0.0, ElectricChargeDensityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>(double.PositiveInfinity, ElectricChargeDensityUnit.CoulombPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>(double.NegativeInfinity, ElectricChargeDensityUnit.CoulombPerCubicMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>(double.NaN, ElectricChargeDensityUnit.CoulombPerCubicMeter));
+        }
+
+        [Fact]
+        public void CoulombPerCubicMeterToElectricChargeDensityUnits()
+        {
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            AssertEx.EqualTolerance(CoulombsPerCubicMeterInOneCoulombPerCubicMeter, coulombpercubicmeter.CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricChargeDensity<double>.From(1, ElectricChargeDensityUnit.CoulombPerCubicMeter).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+        }
+
+        [Fact]
+        public void FromCoulombsPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromCoulombsPerCubicMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            AssertEx.EqualTolerance(CoulombsPerCubicMeterInOneCoulombPerCubicMeter, coulombpercubicmeter.As(ElectricChargeDensityUnit.CoulombPerCubicMeter), CoulombsPerCubicMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+
+            var coulombpercubicmeterQuantity = coulombpercubicmeter.ToUnit(ElectricChargeDensityUnit.CoulombPerCubicMeter);
+            AssertEx.EqualTolerance(CoulombsPerCubicMeterInOneCoulombPerCubicMeter, (double)coulombpercubicmeterQuantity.Value, CoulombsPerCubicMeterTolerance);
+            Assert.Equal(ElectricChargeDensityUnit.CoulombPerCubicMeter, coulombpercubicmeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(coulombpercubicmeter.CoulombsPerCubicMeter).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricChargeDensity<double> v = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            AssertEx.EqualTolerance(-1, -v.CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(3)-v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(10)/5).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(10)/ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(5), CoulombsPerCubicMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricChargeDensity<double> oneCoulombPerCubicMeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> twoCoulombsPerCubicMeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(2);
+
+            Assert.True(oneCoulombPerCubicMeter < twoCoulombsPerCubicMeter);
+            Assert.True(oneCoulombPerCubicMeter <= twoCoulombsPerCubicMeter);
+            Assert.True(twoCoulombsPerCubicMeter > oneCoulombPerCubicMeter);
+            Assert.True(twoCoulombsPerCubicMeter >= oneCoulombPerCubicMeter);
+
+            Assert.False(oneCoulombPerCubicMeter > twoCoulombsPerCubicMeter);
+            Assert.False(oneCoulombPerCubicMeter >= twoCoulombsPerCubicMeter);
+            Assert.False(twoCoulombsPerCubicMeter < oneCoulombPerCubicMeter);
+            Assert.False(twoCoulombsPerCubicMeter <= oneCoulombPerCubicMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            Assert.Equal(0, coulombpercubicmeter.CompareTo(coulombpercubicmeter));
+            Assert.True(coulombpercubicmeter.CompareTo(ElectricChargeDensity<double>.Zero) > 0);
+            Assert.True(ElectricChargeDensity<double>.Zero.CompareTo(coulombpercubicmeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            Assert.Throws<ArgumentException>(() => coulombpercubicmeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            Assert.Throws<ArgumentNullException>(() => coulombpercubicmeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            var b = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            var b = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            Assert.True(v.Equals(ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1), CoulombsPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricChargeDensity<double>.Zero, CoulombsPerCubicMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            Assert.False(coulombpercubicmeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            Assert.False(coulombpercubicmeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricChargeDensityUnit.Undefined, ElectricChargeDensity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricChargeDensityUnit)).Cast<ElectricChargeDensityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricChargeDensityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricChargeDensity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricChargeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricChargeTestsBase.g.cs
new file mode 100644
index 0000000000..3631a32bf6
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricChargeTestsBase.g.cs
@@ -0,0 +1,283 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricCharge.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricChargeTestsBase
+    {
+        protected abstract double AmpereHoursInOneCoulomb { get; }
+        protected abstract double CoulombsInOneCoulomb { get; }
+        protected abstract double KiloampereHoursInOneCoulomb { get; }
+        protected abstract double MegaampereHoursInOneCoulomb { get; }
+        protected abstract double MilliampereHoursInOneCoulomb { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double AmpereHoursTolerance { get { return 1e-5; } }
+        protected virtual double CoulombsTolerance { get { return 1e-5; } }
+        protected virtual double KiloampereHoursTolerance { get { return 1e-5; } }
+        protected virtual double MegaampereHoursTolerance { get { return 1e-5; } }
+        protected virtual double MilliampereHoursTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>((double)0.0, ElectricChargeUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>(double.PositiveInfinity, ElectricChargeUnit.Coulomb));
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>(double.NegativeInfinity, ElectricChargeUnit.Coulomb));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>(double.NaN, ElectricChargeUnit.Coulomb));
+        }
+
+        [Fact]
+        public void CoulombToElectricChargeUnits()
+        {
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            AssertEx.EqualTolerance(AmpereHoursInOneCoulomb, coulomb.AmpereHours, AmpereHoursTolerance);
+            AssertEx.EqualTolerance(CoulombsInOneCoulomb, coulomb.Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(KiloampereHoursInOneCoulomb, coulomb.KiloampereHours, KiloampereHoursTolerance);
+            AssertEx.EqualTolerance(MegaampereHoursInOneCoulomb, coulomb.MegaampereHours, MegaampereHoursTolerance);
+            AssertEx.EqualTolerance(MilliampereHoursInOneCoulomb, coulomb.MilliampereHours, MilliampereHoursTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.From(1, ElectricChargeUnit.AmpereHour).AmpereHours, AmpereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.From(1, ElectricChargeUnit.Coulomb).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.From(1, ElectricChargeUnit.KiloampereHour).KiloampereHours, KiloampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.From(1, ElectricChargeUnit.MegaampereHour).MegaampereHours, MegaampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.From(1, ElectricChargeUnit.MilliampereHour).MilliampereHours, MilliampereHoursTolerance);
+        }
+
+        [Fact]
+        public void FromCoulombs_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCharge<double>.FromCoulombs(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCharge<double>.FromCoulombs(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromCoulombs_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCharge<double>.FromCoulombs(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var coulomb = ElectricCharge<double>.FromCoulombs(1);
+            AssertEx.EqualTolerance(AmpereHoursInOneCoulomb, coulomb.As(ElectricChargeUnit.AmpereHour), AmpereHoursTolerance);
+            AssertEx.EqualTolerance(CoulombsInOneCoulomb, coulomb.As(ElectricChargeUnit.Coulomb), CoulombsTolerance);
+            AssertEx.EqualTolerance(KiloampereHoursInOneCoulomb, coulomb.As(ElectricChargeUnit.KiloampereHour), KiloampereHoursTolerance);
+            AssertEx.EqualTolerance(MegaampereHoursInOneCoulomb, coulomb.As(ElectricChargeUnit.MegaampereHour), MegaampereHoursTolerance);
+            AssertEx.EqualTolerance(MilliampereHoursInOneCoulomb, coulomb.As(ElectricChargeUnit.MilliampereHour), MilliampereHoursTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var coulomb = ElectricCharge<double>.FromCoulombs(1);
+
+            var amperehourQuantity = coulomb.ToUnit(ElectricChargeUnit.AmpereHour);
+            AssertEx.EqualTolerance(AmpereHoursInOneCoulomb, (double)amperehourQuantity.Value, AmpereHoursTolerance);
+            Assert.Equal(ElectricChargeUnit.AmpereHour, amperehourQuantity.Unit);
+
+            var coulombQuantity = coulomb.ToUnit(ElectricChargeUnit.Coulomb);
+            AssertEx.EqualTolerance(CoulombsInOneCoulomb, (double)coulombQuantity.Value, CoulombsTolerance);
+            Assert.Equal(ElectricChargeUnit.Coulomb, coulombQuantity.Unit);
+
+            var kiloamperehourQuantity = coulomb.ToUnit(ElectricChargeUnit.KiloampereHour);
+            AssertEx.EqualTolerance(KiloampereHoursInOneCoulomb, (double)kiloamperehourQuantity.Value, KiloampereHoursTolerance);
+            Assert.Equal(ElectricChargeUnit.KiloampereHour, kiloamperehourQuantity.Unit);
+
+            var megaamperehourQuantity = coulomb.ToUnit(ElectricChargeUnit.MegaampereHour);
+            AssertEx.EqualTolerance(MegaampereHoursInOneCoulomb, (double)megaamperehourQuantity.Value, MegaampereHoursTolerance);
+            Assert.Equal(ElectricChargeUnit.MegaampereHour, megaamperehourQuantity.Unit);
+
+            var milliamperehourQuantity = coulomb.ToUnit(ElectricChargeUnit.MilliampereHour);
+            AssertEx.EqualTolerance(MilliampereHoursInOneCoulomb, (double)milliamperehourQuantity.Value, MilliampereHoursTolerance);
+            Assert.Equal(ElectricChargeUnit.MilliampereHour, milliamperehourQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromAmpereHours(coulomb.AmpereHours).Coulombs, AmpereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromCoulombs(coulomb.Coulombs).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromKiloampereHours(coulomb.KiloampereHours).Coulombs, KiloampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromMegaampereHours(coulomb.MegaampereHours).Coulombs, MegaampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromMilliampereHours(coulomb.MilliampereHours).Coulombs, MilliampereHoursTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricCharge<double> v = ElectricCharge<double>.FromCoulombs(1);
+            AssertEx.EqualTolerance(-1, -v.Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCharge<double>.FromCoulombs(3)-v).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCharge<double>.FromCoulombs(10)/5).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(2, ElectricCharge<double>.FromCoulombs(10)/ElectricCharge<double>.FromCoulombs(5), CoulombsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricCharge<double> oneCoulomb = ElectricCharge<double>.FromCoulombs(1);
+            ElectricCharge<double> twoCoulombs = ElectricCharge<double>.FromCoulombs(2);
+
+            Assert.True(oneCoulomb < twoCoulombs);
+            Assert.True(oneCoulomb <= twoCoulombs);
+            Assert.True(twoCoulombs > oneCoulomb);
+            Assert.True(twoCoulombs >= oneCoulomb);
+
+            Assert.False(oneCoulomb > twoCoulombs);
+            Assert.False(oneCoulomb >= twoCoulombs);
+            Assert.False(twoCoulombs < oneCoulomb);
+            Assert.False(twoCoulombs <= oneCoulomb);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            Assert.Equal(0, coulomb.CompareTo(coulomb));
+            Assert.True(coulomb.CompareTo(ElectricCharge<double>.Zero) > 0);
+            Assert.True(ElectricCharge<double>.Zero.CompareTo(coulomb) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            Assert.Throws<ArgumentException>(() => coulomb.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            Assert.Throws<ArgumentNullException>(() => coulomb.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricCharge<double>.FromCoulombs(1);
+            var b = ElectricCharge<double>.FromCoulombs(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricCharge<double>.FromCoulombs(1);
+            var b = ElectricCharge<double>.FromCoulombs(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricCharge<double>.FromCoulombs(1);
+            Assert.True(v.Equals(ElectricCharge<double>.FromCoulombs(1), CoulombsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCharge<double>.Zero, CoulombsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            Assert.False(coulomb.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            Assert.False(coulomb.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricChargeUnit.Undefined, ElectricCharge<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricChargeUnit)).Cast<ElectricChargeUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricChargeUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricCharge<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricConductanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricConductanceTestsBase.g.cs
new file mode 100644
index 0000000000..e318176632
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricConductanceTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricConductance.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricConductanceTestsBase
+    {
+        protected abstract double MicrosiemensInOneSiemens { get; }
+        protected abstract double MillisiemensInOneSiemens { get; }
+        protected abstract double SiemensInOneSiemens { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double MicrosiemensTolerance { get { return 1e-5; } }
+        protected virtual double MillisiemensTolerance { get { return 1e-5; } }
+        protected virtual double SiemensTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>((double)0.0, ElectricConductanceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>(double.PositiveInfinity, ElectricConductanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>(double.NegativeInfinity, ElectricConductanceUnit.Siemens));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>(double.NaN, ElectricConductanceUnit.Siemens));
+        }
+
+        [Fact]
+        public void SiemensToElectricConductanceUnits()
+        {
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.Microsiemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.Millisiemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(SiemensInOneSiemens, siemens.Siemens, SiemensTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.From(1, ElectricConductanceUnit.Microsiemens).Microsiemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.From(1, ElectricConductanceUnit.Millisiemens).Millisiemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.From(1, ElectricConductanceUnit.Siemens).Siemens, SiemensTolerance);
+        }
+
+        [Fact]
+        public void FromSiemens_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricConductance<double>.FromSiemens(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricConductance<double>.FromSiemens(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromSiemens_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricConductance<double>.FromSiemens(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var siemens = ElectricConductance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.As(ElectricConductanceUnit.Microsiemens), MicrosiemensTolerance);
+            AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.As(ElectricConductanceUnit.Millisiemens), MillisiemensTolerance);
+            AssertEx.EqualTolerance(SiemensInOneSiemens, siemens.As(ElectricConductanceUnit.Siemens), SiemensTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var siemens = ElectricConductance<double>.FromSiemens(1);
+
+            var microsiemensQuantity = siemens.ToUnit(ElectricConductanceUnit.Microsiemens);
+            AssertEx.EqualTolerance(MicrosiemensInOneSiemens, (double)microsiemensQuantity.Value, MicrosiemensTolerance);
+            Assert.Equal(ElectricConductanceUnit.Microsiemens, microsiemensQuantity.Unit);
+
+            var millisiemensQuantity = siemens.ToUnit(ElectricConductanceUnit.Millisiemens);
+            AssertEx.EqualTolerance(MillisiemensInOneSiemens, (double)millisiemensQuantity.Value, MillisiemensTolerance);
+            Assert.Equal(ElectricConductanceUnit.Millisiemens, millisiemensQuantity.Unit);
+
+            var siemensQuantity = siemens.ToUnit(ElectricConductanceUnit.Siemens);
+            AssertEx.EqualTolerance(SiemensInOneSiemens, (double)siemensQuantity.Value, SiemensTolerance);
+            Assert.Equal(ElectricConductanceUnit.Siemens, siemensQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricConductance<double> v = ElectricConductance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(-1, -v.Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductance<double>.FromSiemens(3)-v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductance<double>.FromSiemens(10)/5).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, ElectricConductance<double>.FromSiemens(10)/ElectricConductance<double>.FromSiemens(5), SiemensTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricConductance<double> oneSiemens = ElectricConductance<double>.FromSiemens(1);
+            ElectricConductance<double> twoSiemens = ElectricConductance<double>.FromSiemens(2);
+
+            Assert.True(oneSiemens < twoSiemens);
+            Assert.True(oneSiemens <= twoSiemens);
+            Assert.True(twoSiemens > oneSiemens);
+            Assert.True(twoSiemens >= oneSiemens);
+
+            Assert.False(oneSiemens > twoSiemens);
+            Assert.False(oneSiemens >= twoSiemens);
+            Assert.False(twoSiemens < oneSiemens);
+            Assert.False(twoSiemens <= oneSiemens);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            Assert.Equal(0, siemens.CompareTo(siemens));
+            Assert.True(siemens.CompareTo(ElectricConductance<double>.Zero) > 0);
+            Assert.True(ElectricConductance<double>.Zero.CompareTo(siemens) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            Assert.Throws<ArgumentException>(() => siemens.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            Assert.Throws<ArgumentNullException>(() => siemens.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricConductance<double>.FromSiemens(1);
+            var b = ElectricConductance<double>.FromSiemens(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricConductance<double>.FromSiemens(1);
+            var b = ElectricConductance<double>.FromSiemens(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricConductance<double>.FromSiemens(1);
+            Assert.True(v.Equals(ElectricConductance<double>.FromSiemens(1), SiemensTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricConductance<double>.Zero, SiemensTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            Assert.False(siemens.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            Assert.False(siemens.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricConductanceUnit.Undefined, ElectricConductance<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricConductanceUnit)).Cast<ElectricConductanceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricConductanceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricConductance<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricConductivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricConductivityTestsBase.g.cs
new file mode 100644
index 0000000000..0876b151ac
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricConductivityTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricConductivity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricConductivityTestsBase
+    {
+        protected abstract double SiemensPerFootInOneSiemensPerMeter { get; }
+        protected abstract double SiemensPerInchInOneSiemensPerMeter { get; }
+        protected abstract double SiemensPerMeterInOneSiemensPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double SiemensPerFootTolerance { get { return 1e-5; } }
+        protected virtual double SiemensPerInchTolerance { get { return 1e-5; } }
+        protected virtual double SiemensPerMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>((double)0.0, ElectricConductivityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>(double.PositiveInfinity, ElectricConductivityUnit.SiemensPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>(double.NegativeInfinity, ElectricConductivityUnit.SiemensPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>(double.NaN, ElectricConductivityUnit.SiemensPerMeter));
+        }
+
+        [Fact]
+        public void SiemensPerMeterToElectricConductivityUnits()
+        {
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            AssertEx.EqualTolerance(SiemensPerFootInOneSiemensPerMeter, siemenspermeter.SiemensPerFoot, SiemensPerFootTolerance);
+            AssertEx.EqualTolerance(SiemensPerInchInOneSiemensPerMeter, siemenspermeter.SiemensPerInch, SiemensPerInchTolerance);
+            AssertEx.EqualTolerance(SiemensPerMeterInOneSiemensPerMeter, siemenspermeter.SiemensPerMeter, SiemensPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.From(1, ElectricConductivityUnit.SiemensPerFoot).SiemensPerFoot, SiemensPerFootTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.From(1, ElectricConductivityUnit.SiemensPerInch).SiemensPerInch, SiemensPerInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.From(1, ElectricConductivityUnit.SiemensPerMeter).SiemensPerMeter, SiemensPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromSiemensPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricConductivity<double>.FromSiemensPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricConductivity<double>.FromSiemensPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromSiemensPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricConductivity<double>.FromSiemensPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            AssertEx.EqualTolerance(SiemensPerFootInOneSiemensPerMeter, siemenspermeter.As(ElectricConductivityUnit.SiemensPerFoot), SiemensPerFootTolerance);
+            AssertEx.EqualTolerance(SiemensPerInchInOneSiemensPerMeter, siemenspermeter.As(ElectricConductivityUnit.SiemensPerInch), SiemensPerInchTolerance);
+            AssertEx.EqualTolerance(SiemensPerMeterInOneSiemensPerMeter, siemenspermeter.As(ElectricConductivityUnit.SiemensPerMeter), SiemensPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+
+            var siemensperfootQuantity = siemenspermeter.ToUnit(ElectricConductivityUnit.SiemensPerFoot);
+            AssertEx.EqualTolerance(SiemensPerFootInOneSiemensPerMeter, (double)siemensperfootQuantity.Value, SiemensPerFootTolerance);
+            Assert.Equal(ElectricConductivityUnit.SiemensPerFoot, siemensperfootQuantity.Unit);
+
+            var siemensperinchQuantity = siemenspermeter.ToUnit(ElectricConductivityUnit.SiemensPerInch);
+            AssertEx.EqualTolerance(SiemensPerInchInOneSiemensPerMeter, (double)siemensperinchQuantity.Value, SiemensPerInchTolerance);
+            Assert.Equal(ElectricConductivityUnit.SiemensPerInch, siemensperinchQuantity.Unit);
+
+            var siemenspermeterQuantity = siemenspermeter.ToUnit(ElectricConductivityUnit.SiemensPerMeter);
+            AssertEx.EqualTolerance(SiemensPerMeterInOneSiemensPerMeter, (double)siemenspermeterQuantity.Value, SiemensPerMeterTolerance);
+            Assert.Equal(ElectricConductivityUnit.SiemensPerMeter, siemenspermeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.FromSiemensPerFoot(siemenspermeter.SiemensPerFoot).SiemensPerMeter, SiemensPerFootTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.FromSiemensPerInch(siemenspermeter.SiemensPerInch).SiemensPerMeter, SiemensPerInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.FromSiemensPerMeter(siemenspermeter.SiemensPerMeter).SiemensPerMeter, SiemensPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricConductivity<double> v = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductivity<double>.FromSiemensPerMeter(3)-v).SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductivity<double>.FromSiemensPerMeter(10)/5).SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricConductivity<double>.FromSiemensPerMeter(10)/ElectricConductivity<double>.FromSiemensPerMeter(5), SiemensPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricConductivity<double> oneSiemensPerMeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            ElectricConductivity<double> twoSiemensPerMeter = ElectricConductivity<double>.FromSiemensPerMeter(2);
+
+            Assert.True(oneSiemensPerMeter < twoSiemensPerMeter);
+            Assert.True(oneSiemensPerMeter <= twoSiemensPerMeter);
+            Assert.True(twoSiemensPerMeter > oneSiemensPerMeter);
+            Assert.True(twoSiemensPerMeter >= oneSiemensPerMeter);
+
+            Assert.False(oneSiemensPerMeter > twoSiemensPerMeter);
+            Assert.False(oneSiemensPerMeter >= twoSiemensPerMeter);
+            Assert.False(twoSiemensPerMeter < oneSiemensPerMeter);
+            Assert.False(twoSiemensPerMeter <= oneSiemensPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            Assert.Equal(0, siemenspermeter.CompareTo(siemenspermeter));
+            Assert.True(siemenspermeter.CompareTo(ElectricConductivity<double>.Zero) > 0);
+            Assert.True(ElectricConductivity<double>.Zero.CompareTo(siemenspermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            Assert.Throws<ArgumentException>(() => siemenspermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => siemenspermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            var b = ElectricConductivity<double>.FromSiemensPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            var b = ElectricConductivity<double>.FromSiemensPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            Assert.True(v.Equals(ElectricConductivity<double>.FromSiemensPerMeter(1), SiemensPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricConductivity<double>.Zero, SiemensPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            Assert.False(siemenspermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            Assert.False(siemenspermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricConductivityUnit.Undefined, ElectricConductivity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricConductivityUnit)).Cast<ElectricConductivityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricConductivityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricConductivity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentDensityTestsBase.g.cs
new file mode 100644
index 0000000000..477b8a3214
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentDensityTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricCurrentDensity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricCurrentDensityTestsBase
+    {
+        protected abstract double AmperesPerSquareFootInOneAmperePerSquareMeter { get; }
+        protected abstract double AmperesPerSquareInchInOneAmperePerSquareMeter { get; }
+        protected abstract double AmperesPerSquareMeterInOneAmperePerSquareMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double AmperesPerSquareFootTolerance { get { return 1e-5; } }
+        protected virtual double AmperesPerSquareInchTolerance { get { return 1e-5; } }
+        protected virtual double AmperesPerSquareMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>((double)0.0, ElectricCurrentDensityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>(double.PositiveInfinity, ElectricCurrentDensityUnit.AmperePerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>(double.NegativeInfinity, ElectricCurrentDensityUnit.AmperePerSquareMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>(double.NaN, ElectricCurrentDensityUnit.AmperePerSquareMeter));
+        }
+
+        [Fact]
+        public void AmperePerSquareMeterToElectricCurrentDensityUnits()
+        {
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            AssertEx.EqualTolerance(AmperesPerSquareFootInOneAmperePerSquareMeter, amperepersquaremeter.AmperesPerSquareFoot, AmperesPerSquareFootTolerance);
+            AssertEx.EqualTolerance(AmperesPerSquareInchInOneAmperePerSquareMeter, amperepersquaremeter.AmperesPerSquareInch, AmperesPerSquareInchTolerance);
+            AssertEx.EqualTolerance(AmperesPerSquareMeterInOneAmperePerSquareMeter, amperepersquaremeter.AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.From(1, ElectricCurrentDensityUnit.AmperePerSquareFoot).AmperesPerSquareFoot, AmperesPerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.From(1, ElectricCurrentDensityUnit.AmperePerSquareInch).AmperesPerSquareInch, AmperesPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.From(1, ElectricCurrentDensityUnit.AmperePerSquareMeter).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromAmperesPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromAmperesPerSquareMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            AssertEx.EqualTolerance(AmperesPerSquareFootInOneAmperePerSquareMeter, amperepersquaremeter.As(ElectricCurrentDensityUnit.AmperePerSquareFoot), AmperesPerSquareFootTolerance);
+            AssertEx.EqualTolerance(AmperesPerSquareInchInOneAmperePerSquareMeter, amperepersquaremeter.As(ElectricCurrentDensityUnit.AmperePerSquareInch), AmperesPerSquareInchTolerance);
+            AssertEx.EqualTolerance(AmperesPerSquareMeterInOneAmperePerSquareMeter, amperepersquaremeter.As(ElectricCurrentDensityUnit.AmperePerSquareMeter), AmperesPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+
+            var amperepersquarefootQuantity = amperepersquaremeter.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareFoot);
+            AssertEx.EqualTolerance(AmperesPerSquareFootInOneAmperePerSquareMeter, (double)amperepersquarefootQuantity.Value, AmperesPerSquareFootTolerance);
+            Assert.Equal(ElectricCurrentDensityUnit.AmperePerSquareFoot, amperepersquarefootQuantity.Unit);
+
+            var amperepersquareinchQuantity = amperepersquaremeter.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareInch);
+            AssertEx.EqualTolerance(AmperesPerSquareInchInOneAmperePerSquareMeter, (double)amperepersquareinchQuantity.Value, AmperesPerSquareInchTolerance);
+            Assert.Equal(ElectricCurrentDensityUnit.AmperePerSquareInch, amperepersquareinchQuantity.Unit);
+
+            var amperepersquaremeterQuantity = amperepersquaremeter.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareMeter);
+            AssertEx.EqualTolerance(AmperesPerSquareMeterInOneAmperePerSquareMeter, (double)amperepersquaremeterQuantity.Value, AmperesPerSquareMeterTolerance);
+            Assert.Equal(ElectricCurrentDensityUnit.AmperePerSquareMeter, amperepersquaremeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.FromAmperesPerSquareFoot(amperepersquaremeter.AmperesPerSquareFoot).AmperesPerSquareMeter, AmperesPerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.FromAmperesPerSquareInch(amperepersquaremeter.AmperesPerSquareInch).AmperesPerSquareMeter, AmperesPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(amperepersquaremeter.AmperesPerSquareMeter).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricCurrentDensity<double> v = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            AssertEx.EqualTolerance(-1, -v.AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(3)-v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(10)/5).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(10)/ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(5), AmperesPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricCurrentDensity<double> oneAmperePerSquareMeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> twoAmperesPerSquareMeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(2);
+
+            Assert.True(oneAmperePerSquareMeter < twoAmperesPerSquareMeter);
+            Assert.True(oneAmperePerSquareMeter <= twoAmperesPerSquareMeter);
+            Assert.True(twoAmperesPerSquareMeter > oneAmperePerSquareMeter);
+            Assert.True(twoAmperesPerSquareMeter >= oneAmperePerSquareMeter);
+
+            Assert.False(oneAmperePerSquareMeter > twoAmperesPerSquareMeter);
+            Assert.False(oneAmperePerSquareMeter >= twoAmperesPerSquareMeter);
+            Assert.False(twoAmperesPerSquareMeter < oneAmperePerSquareMeter);
+            Assert.False(twoAmperesPerSquareMeter <= oneAmperePerSquareMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            Assert.Equal(0, amperepersquaremeter.CompareTo(amperepersquaremeter));
+            Assert.True(amperepersquaremeter.CompareTo(ElectricCurrentDensity<double>.Zero) > 0);
+            Assert.True(ElectricCurrentDensity<double>.Zero.CompareTo(amperepersquaremeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            Assert.Throws<ArgumentException>(() => amperepersquaremeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            Assert.Throws<ArgumentNullException>(() => amperepersquaremeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            var b = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            var b = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            Assert.True(v.Equals(ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1), AmperesPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCurrentDensity<double>.Zero, AmperesPerSquareMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            Assert.False(amperepersquaremeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            Assert.False(amperepersquaremeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricCurrentDensityUnit.Undefined, ElectricCurrentDensity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricCurrentDensityUnit)).Cast<ElectricCurrentDensityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricCurrentDensityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricCurrentDensity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentGradientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentGradientTestsBase.g.cs
new file mode 100644
index 0000000000..b972687008
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentGradientTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricCurrentGradient.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricCurrentGradientTestsBase
+    {
+        protected abstract double AmperesPerSecondInOneAmperePerSecond { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double AmperesPerSecondTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>((double)0.0, ElectricCurrentGradientUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>(double.PositiveInfinity, ElectricCurrentGradientUnit.AmperePerSecond));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>(double.NegativeInfinity, ElectricCurrentGradientUnit.AmperePerSecond));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>(double.NaN, ElectricCurrentGradientUnit.AmperePerSecond));
+        }
+
+        [Fact]
+        public void AmperePerSecondToElectricCurrentGradientUnits()
+        {
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            AssertEx.EqualTolerance(AmperesPerSecondInOneAmperePerSecond, amperepersecond.AmperesPerSecond, AmperesPerSecondTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricCurrentGradient<double>.From(1, ElectricCurrentGradientUnit.AmperePerSecond).AmperesPerSecond, AmperesPerSecondTolerance);
+        }
+
+        [Fact]
+        public void FromAmperesPerSecond_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient<double>.FromAmperesPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient<double>.FromAmperesPerSecond(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromAmperesPerSecond_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient<double>.FromAmperesPerSecond(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            AssertEx.EqualTolerance(AmperesPerSecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerSecond), AmperesPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+
+            var amperepersecondQuantity = amperepersecond.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond);
+            AssertEx.EqualTolerance(AmperesPerSecondInOneAmperePerSecond, (double)amperepersecondQuantity.Value, AmperesPerSecondTolerance);
+            Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, amperepersecondQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            AssertEx.EqualTolerance(1, ElectricCurrentGradient<double>.FromAmperesPerSecond(amperepersecond.AmperesPerSecond).AmperesPerSecond, AmperesPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricCurrentGradient<double> v = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            AssertEx.EqualTolerance(-1, -v.AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentGradient<double>.FromAmperesPerSecond(3)-v).AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (v + v).AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (v*10).AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (10*v).AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentGradient<double>.FromAmperesPerSecond(10)/5).AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(2, ElectricCurrentGradient<double>.FromAmperesPerSecond(10)/ElectricCurrentGradient<double>.FromAmperesPerSecond(5), AmperesPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricCurrentGradient<double> oneAmperePerSecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> twoAmperesPerSecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(2);
+
+            Assert.True(oneAmperePerSecond < twoAmperesPerSecond);
+            Assert.True(oneAmperePerSecond <= twoAmperesPerSecond);
+            Assert.True(twoAmperesPerSecond > oneAmperePerSecond);
+            Assert.True(twoAmperesPerSecond >= oneAmperePerSecond);
+
+            Assert.False(oneAmperePerSecond > twoAmperesPerSecond);
+            Assert.False(oneAmperePerSecond >= twoAmperesPerSecond);
+            Assert.False(twoAmperesPerSecond < oneAmperePerSecond);
+            Assert.False(twoAmperesPerSecond <= oneAmperePerSecond);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            Assert.Equal(0, amperepersecond.CompareTo(amperepersecond));
+            Assert.True(amperepersecond.CompareTo(ElectricCurrentGradient<double>.Zero) > 0);
+            Assert.True(ElectricCurrentGradient<double>.Zero.CompareTo(amperepersecond) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            Assert.Throws<ArgumentException>(() => amperepersecond.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            Assert.Throws<ArgumentNullException>(() => amperepersecond.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            var b = ElectricCurrentGradient<double>.FromAmperesPerSecond(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            var b = ElectricCurrentGradient<double>.FromAmperesPerSecond(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            Assert.True(v.Equals(ElectricCurrentGradient<double>.FromAmperesPerSecond(1), AmperesPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCurrentGradient<double>.Zero, AmperesPerSecondTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            Assert.False(amperepersecond.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            Assert.False(amperepersecond.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricCurrentGradientUnit.Undefined, ElectricCurrentGradient<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricCurrentGradientUnit)).Cast<ElectricCurrentGradientUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricCurrentGradientUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricCurrentGradient<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs
new file mode 100644
index 0000000000..4cc1204b03
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs
@@ -0,0 +1,313 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricCurrent.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricCurrentTestsBase
+    {
+        protected abstract double AmperesInOneAmpere { get; }
+        protected abstract double CentiamperesInOneAmpere { get; }
+        protected abstract double KiloamperesInOneAmpere { get; }
+        protected abstract double MegaamperesInOneAmpere { get; }
+        protected abstract double MicroamperesInOneAmpere { get; }
+        protected abstract double MilliamperesInOneAmpere { get; }
+        protected abstract double NanoamperesInOneAmpere { get; }
+        protected abstract double PicoamperesInOneAmpere { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double AmperesTolerance { get { return 1e-5; } }
+        protected virtual double CentiamperesTolerance { get { return 1e-5; } }
+        protected virtual double KiloamperesTolerance { get { return 1e-5; } }
+        protected virtual double MegaamperesTolerance { get { return 1e-5; } }
+        protected virtual double MicroamperesTolerance { get { return 1e-5; } }
+        protected virtual double MilliamperesTolerance { get { return 1e-5; } }
+        protected virtual double NanoamperesTolerance { get { return 1e-5; } }
+        protected virtual double PicoamperesTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>((double)0.0, ElectricCurrentUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>(double.PositiveInfinity, ElectricCurrentUnit.Ampere));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>(double.NegativeInfinity, ElectricCurrentUnit.Ampere));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>(double.NaN, ElectricCurrentUnit.Ampere));
+        }
+
+        [Fact]
+        public void AmpereToElectricCurrentUnits()
+        {
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            AssertEx.EqualTolerance(AmperesInOneAmpere, ampere.Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(CentiamperesInOneAmpere, ampere.Centiamperes, CentiamperesTolerance);
+            AssertEx.EqualTolerance(KiloamperesInOneAmpere, ampere.Kiloamperes, KiloamperesTolerance);
+            AssertEx.EqualTolerance(MegaamperesInOneAmpere, ampere.Megaamperes, MegaamperesTolerance);
+            AssertEx.EqualTolerance(MicroamperesInOneAmpere, ampere.Microamperes, MicroamperesTolerance);
+            AssertEx.EqualTolerance(MilliamperesInOneAmpere, ampere.Milliamperes, MilliamperesTolerance);
+            AssertEx.EqualTolerance(NanoamperesInOneAmpere, ampere.Nanoamperes, NanoamperesTolerance);
+            AssertEx.EqualTolerance(PicoamperesInOneAmpere, ampere.Picoamperes, PicoamperesTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Ampere).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Centiampere).Centiamperes, CentiamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Kiloampere).Kiloamperes, KiloamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Megaampere).Megaamperes, MegaamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Microampere).Microamperes, MicroamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Milliampere).Milliamperes, MilliamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Nanoampere).Nanoamperes, NanoamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.From(1, ElectricCurrentUnit.Picoampere).Picoamperes, PicoamperesTolerance);
+        }
+
+        [Fact]
+        public void FromAmperes_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCurrent<double>.FromAmperes(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrent<double>.FromAmperes(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromAmperes_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricCurrent<double>.FromAmperes(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var ampere = ElectricCurrent<double>.FromAmperes(1);
+            AssertEx.EqualTolerance(AmperesInOneAmpere, ampere.As(ElectricCurrentUnit.Ampere), AmperesTolerance);
+            AssertEx.EqualTolerance(CentiamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Centiampere), CentiamperesTolerance);
+            AssertEx.EqualTolerance(KiloamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Kiloampere), KiloamperesTolerance);
+            AssertEx.EqualTolerance(MegaamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Megaampere), MegaamperesTolerance);
+            AssertEx.EqualTolerance(MicroamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Microampere), MicroamperesTolerance);
+            AssertEx.EqualTolerance(MilliamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Milliampere), MilliamperesTolerance);
+            AssertEx.EqualTolerance(NanoamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Nanoampere), NanoamperesTolerance);
+            AssertEx.EqualTolerance(PicoamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Picoampere), PicoamperesTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var ampere = ElectricCurrent<double>.FromAmperes(1);
+
+            var ampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Ampere);
+            AssertEx.EqualTolerance(AmperesInOneAmpere, (double)ampereQuantity.Value, AmperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Ampere, ampereQuantity.Unit);
+
+            var centiampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Centiampere);
+            AssertEx.EqualTolerance(CentiamperesInOneAmpere, (double)centiampereQuantity.Value, CentiamperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Centiampere, centiampereQuantity.Unit);
+
+            var kiloampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Kiloampere);
+            AssertEx.EqualTolerance(KiloamperesInOneAmpere, (double)kiloampereQuantity.Value, KiloamperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Kiloampere, kiloampereQuantity.Unit);
+
+            var megaampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Megaampere);
+            AssertEx.EqualTolerance(MegaamperesInOneAmpere, (double)megaampereQuantity.Value, MegaamperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Megaampere, megaampereQuantity.Unit);
+
+            var microampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Microampere);
+            AssertEx.EqualTolerance(MicroamperesInOneAmpere, (double)microampereQuantity.Value, MicroamperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Microampere, microampereQuantity.Unit);
+
+            var milliampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Milliampere);
+            AssertEx.EqualTolerance(MilliamperesInOneAmpere, (double)milliampereQuantity.Value, MilliamperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Milliampere, milliampereQuantity.Unit);
+
+            var nanoampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Nanoampere);
+            AssertEx.EqualTolerance(NanoamperesInOneAmpere, (double)nanoampereQuantity.Value, NanoamperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Nanoampere, nanoampereQuantity.Unit);
+
+            var picoampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Picoampere);
+            AssertEx.EqualTolerance(PicoamperesInOneAmpere, (double)picoampereQuantity.Value, PicoamperesTolerance);
+            Assert.Equal(ElectricCurrentUnit.Picoampere, picoampereQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromAmperes(ampere.Amperes).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromCentiamperes(ampere.Centiamperes).Amperes, CentiamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromKiloamperes(ampere.Kiloamperes).Amperes, KiloamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromMegaamperes(ampere.Megaamperes).Amperes, MegaamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromMicroamperes(ampere.Microamperes).Amperes, MicroamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromMilliamperes(ampere.Milliamperes).Amperes, MilliamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromNanoamperes(ampere.Nanoamperes).Amperes, NanoamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromPicoamperes(ampere.Picoamperes).Amperes, PicoamperesTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricCurrent<double> v = ElectricCurrent<double>.FromAmperes(1);
+            AssertEx.EqualTolerance(-1, -v.Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrent<double>.FromAmperes(3)-v).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrent<double>.FromAmperes(10)/5).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(2, ElectricCurrent<double>.FromAmperes(10)/ElectricCurrent<double>.FromAmperes(5), AmperesTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricCurrent<double> oneAmpere = ElectricCurrent<double>.FromAmperes(1);
+            ElectricCurrent<double> twoAmperes = ElectricCurrent<double>.FromAmperes(2);
+
+            Assert.True(oneAmpere < twoAmperes);
+            Assert.True(oneAmpere <= twoAmperes);
+            Assert.True(twoAmperes > oneAmpere);
+            Assert.True(twoAmperes >= oneAmpere);
+
+            Assert.False(oneAmpere > twoAmperes);
+            Assert.False(oneAmpere >= twoAmperes);
+            Assert.False(twoAmperes < oneAmpere);
+            Assert.False(twoAmperes <= oneAmpere);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            Assert.Equal(0, ampere.CompareTo(ampere));
+            Assert.True(ampere.CompareTo(ElectricCurrent<double>.Zero) > 0);
+            Assert.True(ElectricCurrent<double>.Zero.CompareTo(ampere) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            Assert.Throws<ArgumentException>(() => ampere.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            Assert.Throws<ArgumentNullException>(() => ampere.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricCurrent<double>.FromAmperes(1);
+            var b = ElectricCurrent<double>.FromAmperes(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricCurrent<double>.FromAmperes(1);
+            var b = ElectricCurrent<double>.FromAmperes(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricCurrent<double>.FromAmperes(1);
+            Assert.True(v.Equals(ElectricCurrent<double>.FromAmperes(1), AmperesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCurrent<double>.Zero, AmperesTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            Assert.False(ampere.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            Assert.False(ampere.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricCurrentUnit.Undefined, ElectricCurrent<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricCurrentUnit)).Cast<ElectricCurrentUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricCurrentUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricCurrent<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricFieldTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricFieldTestsBase.g.cs
new file mode 100644
index 0000000000..2ed2eb5dd3
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricFieldTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricField.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricFieldTestsBase
+    {
+        protected abstract double VoltsPerMeterInOneVoltPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double VoltsPerMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>((double)0.0, ElectricFieldUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>(double.PositiveInfinity, ElectricFieldUnit.VoltPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>(double.NegativeInfinity, ElectricFieldUnit.VoltPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>(double.NaN, ElectricFieldUnit.VoltPerMeter));
+        }
+
+        [Fact]
+        public void VoltPerMeterToElectricFieldUnits()
+        {
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            AssertEx.EqualTolerance(VoltsPerMeterInOneVoltPerMeter, voltpermeter.VoltsPerMeter, VoltsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricField<double>.From(1, ElectricFieldUnit.VoltPerMeter).VoltsPerMeter, VoltsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromVoltsPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricField<double>.FromVoltsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricField<double>.FromVoltsPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVoltsPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricField<double>.FromVoltsPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            AssertEx.EqualTolerance(VoltsPerMeterInOneVoltPerMeter, voltpermeter.As(ElectricFieldUnit.VoltPerMeter), VoltsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+
+            var voltpermeterQuantity = voltpermeter.ToUnit(ElectricFieldUnit.VoltPerMeter);
+            AssertEx.EqualTolerance(VoltsPerMeterInOneVoltPerMeter, (double)voltpermeterQuantity.Value, VoltsPerMeterTolerance);
+            Assert.Equal(ElectricFieldUnit.VoltPerMeter, voltpermeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            AssertEx.EqualTolerance(1, ElectricField<double>.FromVoltsPerMeter(voltpermeter.VoltsPerMeter).VoltsPerMeter, VoltsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricField<double> v = ElectricField<double>.FromVoltsPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricField<double>.FromVoltsPerMeter(3)-v).VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricField<double>.FromVoltsPerMeter(10)/5).VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricField<double>.FromVoltsPerMeter(10)/ElectricField<double>.FromVoltsPerMeter(5), VoltsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricField<double> oneVoltPerMeter = ElectricField<double>.FromVoltsPerMeter(1);
+            ElectricField<double> twoVoltsPerMeter = ElectricField<double>.FromVoltsPerMeter(2);
+
+            Assert.True(oneVoltPerMeter < twoVoltsPerMeter);
+            Assert.True(oneVoltPerMeter <= twoVoltsPerMeter);
+            Assert.True(twoVoltsPerMeter > oneVoltPerMeter);
+            Assert.True(twoVoltsPerMeter >= oneVoltPerMeter);
+
+            Assert.False(oneVoltPerMeter > twoVoltsPerMeter);
+            Assert.False(oneVoltPerMeter >= twoVoltsPerMeter);
+            Assert.False(twoVoltsPerMeter < oneVoltPerMeter);
+            Assert.False(twoVoltsPerMeter <= oneVoltPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            Assert.Equal(0, voltpermeter.CompareTo(voltpermeter));
+            Assert.True(voltpermeter.CompareTo(ElectricField<double>.Zero) > 0);
+            Assert.True(ElectricField<double>.Zero.CompareTo(voltpermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            Assert.Throws<ArgumentException>(() => voltpermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => voltpermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricField<double>.FromVoltsPerMeter(1);
+            var b = ElectricField<double>.FromVoltsPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricField<double>.FromVoltsPerMeter(1);
+            var b = ElectricField<double>.FromVoltsPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricField<double>.FromVoltsPerMeter(1);
+            Assert.True(v.Equals(ElectricField<double>.FromVoltsPerMeter(1), VoltsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricField<double>.Zero, VoltsPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            Assert.False(voltpermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            Assert.False(voltpermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricFieldUnit.Undefined, ElectricField<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricFieldUnit)).Cast<ElectricFieldUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricFieldUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricField<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricInductanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricInductanceTestsBase.g.cs
new file mode 100644
index 0000000000..f81ea5d4ba
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricInductanceTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricInductance.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricInductanceTestsBase
+    {
+        protected abstract double HenriesInOneHenry { get; }
+        protected abstract double MicrohenriesInOneHenry { get; }
+        protected abstract double MillihenriesInOneHenry { get; }
+        protected abstract double NanohenriesInOneHenry { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double HenriesTolerance { get { return 1e-5; } }
+        protected virtual double MicrohenriesTolerance { get { return 1e-5; } }
+        protected virtual double MillihenriesTolerance { get { return 1e-5; } }
+        protected virtual double NanohenriesTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>((double)0.0, ElectricInductanceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>(double.PositiveInfinity, ElectricInductanceUnit.Henry));
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>(double.NegativeInfinity, ElectricInductanceUnit.Henry));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>(double.NaN, ElectricInductanceUnit.Henry));
+        }
+
+        [Fact]
+        public void HenryToElectricInductanceUnits()
+        {
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            AssertEx.EqualTolerance(HenriesInOneHenry, henry.Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(MicrohenriesInOneHenry, henry.Microhenries, MicrohenriesTolerance);
+            AssertEx.EqualTolerance(MillihenriesInOneHenry, henry.Millihenries, MillihenriesTolerance);
+            AssertEx.EqualTolerance(NanohenriesInOneHenry, henry.Nanohenries, NanohenriesTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.From(1, ElectricInductanceUnit.Henry).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.From(1, ElectricInductanceUnit.Microhenry).Microhenries, MicrohenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.From(1, ElectricInductanceUnit.Millihenry).Millihenries, MillihenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.From(1, ElectricInductanceUnit.Nanohenry).Nanohenries, NanohenriesTolerance);
+        }
+
+        [Fact]
+        public void FromHenries_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricInductance<double>.FromHenries(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricInductance<double>.FromHenries(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromHenries_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricInductance<double>.FromHenries(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var henry = ElectricInductance<double>.FromHenries(1);
+            AssertEx.EqualTolerance(HenriesInOneHenry, henry.As(ElectricInductanceUnit.Henry), HenriesTolerance);
+            AssertEx.EqualTolerance(MicrohenriesInOneHenry, henry.As(ElectricInductanceUnit.Microhenry), MicrohenriesTolerance);
+            AssertEx.EqualTolerance(MillihenriesInOneHenry, henry.As(ElectricInductanceUnit.Millihenry), MillihenriesTolerance);
+            AssertEx.EqualTolerance(NanohenriesInOneHenry, henry.As(ElectricInductanceUnit.Nanohenry), NanohenriesTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var henry = ElectricInductance<double>.FromHenries(1);
+
+            var henryQuantity = henry.ToUnit(ElectricInductanceUnit.Henry);
+            AssertEx.EqualTolerance(HenriesInOneHenry, (double)henryQuantity.Value, HenriesTolerance);
+            Assert.Equal(ElectricInductanceUnit.Henry, henryQuantity.Unit);
+
+            var microhenryQuantity = henry.ToUnit(ElectricInductanceUnit.Microhenry);
+            AssertEx.EqualTolerance(MicrohenriesInOneHenry, (double)microhenryQuantity.Value, MicrohenriesTolerance);
+            Assert.Equal(ElectricInductanceUnit.Microhenry, microhenryQuantity.Unit);
+
+            var millihenryQuantity = henry.ToUnit(ElectricInductanceUnit.Millihenry);
+            AssertEx.EqualTolerance(MillihenriesInOneHenry, (double)millihenryQuantity.Value, MillihenriesTolerance);
+            Assert.Equal(ElectricInductanceUnit.Millihenry, millihenryQuantity.Unit);
+
+            var nanohenryQuantity = henry.ToUnit(ElectricInductanceUnit.Nanohenry);
+            AssertEx.EqualTolerance(NanohenriesInOneHenry, (double)nanohenryQuantity.Value, NanohenriesTolerance);
+            Assert.Equal(ElectricInductanceUnit.Nanohenry, nanohenryQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromHenries(henry.Henries).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromMicrohenries(henry.Microhenries).Henries, MicrohenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromMillihenries(henry.Millihenries).Henries, MillihenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromNanohenries(henry.Nanohenries).Henries, NanohenriesTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricInductance<double> v = ElectricInductance<double>.FromHenries(1);
+            AssertEx.EqualTolerance(-1, -v.Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricInductance<double>.FromHenries(3)-v).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricInductance<double>.FromHenries(10)/5).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(2, ElectricInductance<double>.FromHenries(10)/ElectricInductance<double>.FromHenries(5), HenriesTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricInductance<double> oneHenry = ElectricInductance<double>.FromHenries(1);
+            ElectricInductance<double> twoHenries = ElectricInductance<double>.FromHenries(2);
+
+            Assert.True(oneHenry < twoHenries);
+            Assert.True(oneHenry <= twoHenries);
+            Assert.True(twoHenries > oneHenry);
+            Assert.True(twoHenries >= oneHenry);
+
+            Assert.False(oneHenry > twoHenries);
+            Assert.False(oneHenry >= twoHenries);
+            Assert.False(twoHenries < oneHenry);
+            Assert.False(twoHenries <= oneHenry);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            Assert.Equal(0, henry.CompareTo(henry));
+            Assert.True(henry.CompareTo(ElectricInductance<double>.Zero) > 0);
+            Assert.True(ElectricInductance<double>.Zero.CompareTo(henry) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            Assert.Throws<ArgumentException>(() => henry.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            Assert.Throws<ArgumentNullException>(() => henry.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricInductance<double>.FromHenries(1);
+            var b = ElectricInductance<double>.FromHenries(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricInductance<double>.FromHenries(1);
+            var b = ElectricInductance<double>.FromHenries(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricInductance<double>.FromHenries(1);
+            Assert.True(v.Equals(ElectricInductance<double>.FromHenries(1), HenriesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricInductance<double>.Zero, HenriesTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            Assert.False(henry.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            Assert.False(henry.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricInductanceUnit.Undefined, ElectricInductance<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricInductanceUnit)).Cast<ElectricInductanceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricInductanceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricInductance<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialAcTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialAcTestsBase.g.cs
new file mode 100644
index 0000000000..3ed8c586d2
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialAcTestsBase.g.cs
@@ -0,0 +1,283 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricPotentialAc.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricPotentialAcTestsBase
+    {
+        protected abstract double KilovoltsAcInOneVoltAc { get; }
+        protected abstract double MegavoltsAcInOneVoltAc { get; }
+        protected abstract double MicrovoltsAcInOneVoltAc { get; }
+        protected abstract double MillivoltsAcInOneVoltAc { get; }
+        protected abstract double VoltsAcInOneVoltAc { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilovoltsAcTolerance { get { return 1e-5; } }
+        protected virtual double MegavoltsAcTolerance { get { return 1e-5; } }
+        protected virtual double MicrovoltsAcTolerance { get { return 1e-5; } }
+        protected virtual double MillivoltsAcTolerance { get { return 1e-5; } }
+        protected virtual double VoltsAcTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>((double)0.0, ElectricPotentialAcUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>(double.PositiveInfinity, ElectricPotentialAcUnit.VoltAc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>(double.NegativeInfinity, ElectricPotentialAcUnit.VoltAc));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>(double.NaN, ElectricPotentialAcUnit.VoltAc));
+        }
+
+        [Fact]
+        public void VoltAcToElectricPotentialAcUnits()
+        {
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            AssertEx.EqualTolerance(KilovoltsAcInOneVoltAc, voltac.KilovoltsAc, KilovoltsAcTolerance);
+            AssertEx.EqualTolerance(MegavoltsAcInOneVoltAc, voltac.MegavoltsAc, MegavoltsAcTolerance);
+            AssertEx.EqualTolerance(MicrovoltsAcInOneVoltAc, voltac.MicrovoltsAc, MicrovoltsAcTolerance);
+            AssertEx.EqualTolerance(MillivoltsAcInOneVoltAc, voltac.MillivoltsAc, MillivoltsAcTolerance);
+            AssertEx.EqualTolerance(VoltsAcInOneVoltAc, voltac.VoltsAc, VoltsAcTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.KilovoltAc).KilovoltsAc, KilovoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.MegavoltAc).MegavoltsAc, MegavoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.MicrovoltAc).MicrovoltsAc, MicrovoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.MillivoltAc).MillivoltsAc, MillivoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.VoltAc).VoltsAc, VoltsAcTolerance);
+        }
+
+        [Fact]
+        public void FromVoltsAc_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricPotentialAc<double>.FromVoltsAc(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialAc<double>.FromVoltsAc(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVoltsAc_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricPotentialAc<double>.FromVoltsAc(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            AssertEx.EqualTolerance(KilovoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.KilovoltAc), KilovoltsAcTolerance);
+            AssertEx.EqualTolerance(MegavoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.MegavoltAc), MegavoltsAcTolerance);
+            AssertEx.EqualTolerance(MicrovoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.MicrovoltAc), MicrovoltsAcTolerance);
+            AssertEx.EqualTolerance(MillivoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.MillivoltAc), MillivoltsAcTolerance);
+            AssertEx.EqualTolerance(VoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.VoltAc), VoltsAcTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+
+            var kilovoltacQuantity = voltac.ToUnit(ElectricPotentialAcUnit.KilovoltAc);
+            AssertEx.EqualTolerance(KilovoltsAcInOneVoltAc, (double)kilovoltacQuantity.Value, KilovoltsAcTolerance);
+            Assert.Equal(ElectricPotentialAcUnit.KilovoltAc, kilovoltacQuantity.Unit);
+
+            var megavoltacQuantity = voltac.ToUnit(ElectricPotentialAcUnit.MegavoltAc);
+            AssertEx.EqualTolerance(MegavoltsAcInOneVoltAc, (double)megavoltacQuantity.Value, MegavoltsAcTolerance);
+            Assert.Equal(ElectricPotentialAcUnit.MegavoltAc, megavoltacQuantity.Unit);
+
+            var microvoltacQuantity = voltac.ToUnit(ElectricPotentialAcUnit.MicrovoltAc);
+            AssertEx.EqualTolerance(MicrovoltsAcInOneVoltAc, (double)microvoltacQuantity.Value, MicrovoltsAcTolerance);
+            Assert.Equal(ElectricPotentialAcUnit.MicrovoltAc, microvoltacQuantity.Unit);
+
+            var millivoltacQuantity = voltac.ToUnit(ElectricPotentialAcUnit.MillivoltAc);
+            AssertEx.EqualTolerance(MillivoltsAcInOneVoltAc, (double)millivoltacQuantity.Value, MillivoltsAcTolerance);
+            Assert.Equal(ElectricPotentialAcUnit.MillivoltAc, millivoltacQuantity.Unit);
+
+            var voltacQuantity = voltac.ToUnit(ElectricPotentialAcUnit.VoltAc);
+            AssertEx.EqualTolerance(VoltsAcInOneVoltAc, (double)voltacQuantity.Value, VoltsAcTolerance);
+            Assert.Equal(ElectricPotentialAcUnit.VoltAc, voltacQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromKilovoltsAc(voltac.KilovoltsAc).VoltsAc, KilovoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromMegavoltsAc(voltac.MegavoltsAc).VoltsAc, MegavoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromMicrovoltsAc(voltac.MicrovoltsAc).VoltsAc, MicrovoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromMillivoltsAc(voltac.MillivoltsAc).VoltsAc, MillivoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromVoltsAc(voltac.VoltsAc).VoltsAc, VoltsAcTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricPotentialAc<double> v = ElectricPotentialAc<double>.FromVoltsAc(1);
+            AssertEx.EqualTolerance(-1, -v.VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialAc<double>.FromVoltsAc(3)-v).VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(2, (v + v).VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(10, (v*10).VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(10, (10*v).VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialAc<double>.FromVoltsAc(10)/5).VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(2, ElectricPotentialAc<double>.FromVoltsAc(10)/ElectricPotentialAc<double>.FromVoltsAc(5), VoltsAcTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricPotentialAc<double> oneVoltAc = ElectricPotentialAc<double>.FromVoltsAc(1);
+            ElectricPotentialAc<double> twoVoltsAc = ElectricPotentialAc<double>.FromVoltsAc(2);
+
+            Assert.True(oneVoltAc < twoVoltsAc);
+            Assert.True(oneVoltAc <= twoVoltsAc);
+            Assert.True(twoVoltsAc > oneVoltAc);
+            Assert.True(twoVoltsAc >= oneVoltAc);
+
+            Assert.False(oneVoltAc > twoVoltsAc);
+            Assert.False(oneVoltAc >= twoVoltsAc);
+            Assert.False(twoVoltsAc < oneVoltAc);
+            Assert.False(twoVoltsAc <= oneVoltAc);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            Assert.Equal(0, voltac.CompareTo(voltac));
+            Assert.True(voltac.CompareTo(ElectricPotentialAc<double>.Zero) > 0);
+            Assert.True(ElectricPotentialAc<double>.Zero.CompareTo(voltac) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            Assert.Throws<ArgumentException>(() => voltac.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            Assert.Throws<ArgumentNullException>(() => voltac.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricPotentialAc<double>.FromVoltsAc(1);
+            var b = ElectricPotentialAc<double>.FromVoltsAc(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricPotentialAc<double>.FromVoltsAc(1);
+            var b = ElectricPotentialAc<double>.FromVoltsAc(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricPotentialAc<double>.FromVoltsAc(1);
+            Assert.True(v.Equals(ElectricPotentialAc<double>.FromVoltsAc(1), VoltsAcTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricPotentialAc<double>.Zero, VoltsAcTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            Assert.False(voltac.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            Assert.False(voltac.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricPotentialAcUnit.Undefined, ElectricPotentialAc<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricPotentialAcUnit)).Cast<ElectricPotentialAcUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricPotentialAcUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricPotentialAc<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialDcTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialDcTestsBase.g.cs
new file mode 100644
index 0000000000..c3294f938b
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialDcTestsBase.g.cs
@@ -0,0 +1,283 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricPotentialDc.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricPotentialDcTestsBase
+    {
+        protected abstract double KilovoltsDcInOneVoltDc { get; }
+        protected abstract double MegavoltsDcInOneVoltDc { get; }
+        protected abstract double MicrovoltsDcInOneVoltDc { get; }
+        protected abstract double MillivoltsDcInOneVoltDc { get; }
+        protected abstract double VoltsDcInOneVoltDc { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilovoltsDcTolerance { get { return 1e-5; } }
+        protected virtual double MegavoltsDcTolerance { get { return 1e-5; } }
+        protected virtual double MicrovoltsDcTolerance { get { return 1e-5; } }
+        protected virtual double MillivoltsDcTolerance { get { return 1e-5; } }
+        protected virtual double VoltsDcTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>((double)0.0, ElectricPotentialDcUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>(double.PositiveInfinity, ElectricPotentialDcUnit.VoltDc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>(double.NegativeInfinity, ElectricPotentialDcUnit.VoltDc));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>(double.NaN, ElectricPotentialDcUnit.VoltDc));
+        }
+
+        [Fact]
+        public void VoltDcToElectricPotentialDcUnits()
+        {
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            AssertEx.EqualTolerance(KilovoltsDcInOneVoltDc, voltdc.KilovoltsDc, KilovoltsDcTolerance);
+            AssertEx.EqualTolerance(MegavoltsDcInOneVoltDc, voltdc.MegavoltsDc, MegavoltsDcTolerance);
+            AssertEx.EqualTolerance(MicrovoltsDcInOneVoltDc, voltdc.MicrovoltsDc, MicrovoltsDcTolerance);
+            AssertEx.EqualTolerance(MillivoltsDcInOneVoltDc, voltdc.MillivoltsDc, MillivoltsDcTolerance);
+            AssertEx.EqualTolerance(VoltsDcInOneVoltDc, voltdc.VoltsDc, VoltsDcTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.KilovoltDc).KilovoltsDc, KilovoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.MegavoltDc).MegavoltsDc, MegavoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.MicrovoltDc).MicrovoltsDc, MicrovoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.MillivoltDc).MillivoltsDc, MillivoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.VoltDc).VoltsDc, VoltsDcTolerance);
+        }
+
+        [Fact]
+        public void FromVoltsDc_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricPotentialDc<double>.FromVoltsDc(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialDc<double>.FromVoltsDc(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVoltsDc_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricPotentialDc<double>.FromVoltsDc(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            AssertEx.EqualTolerance(KilovoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.KilovoltDc), KilovoltsDcTolerance);
+            AssertEx.EqualTolerance(MegavoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.MegavoltDc), MegavoltsDcTolerance);
+            AssertEx.EqualTolerance(MicrovoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.MicrovoltDc), MicrovoltsDcTolerance);
+            AssertEx.EqualTolerance(MillivoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.MillivoltDc), MillivoltsDcTolerance);
+            AssertEx.EqualTolerance(VoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.VoltDc), VoltsDcTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+
+            var kilovoltdcQuantity = voltdc.ToUnit(ElectricPotentialDcUnit.KilovoltDc);
+            AssertEx.EqualTolerance(KilovoltsDcInOneVoltDc, (double)kilovoltdcQuantity.Value, KilovoltsDcTolerance);
+            Assert.Equal(ElectricPotentialDcUnit.KilovoltDc, kilovoltdcQuantity.Unit);
+
+            var megavoltdcQuantity = voltdc.ToUnit(ElectricPotentialDcUnit.MegavoltDc);
+            AssertEx.EqualTolerance(MegavoltsDcInOneVoltDc, (double)megavoltdcQuantity.Value, MegavoltsDcTolerance);
+            Assert.Equal(ElectricPotentialDcUnit.MegavoltDc, megavoltdcQuantity.Unit);
+
+            var microvoltdcQuantity = voltdc.ToUnit(ElectricPotentialDcUnit.MicrovoltDc);
+            AssertEx.EqualTolerance(MicrovoltsDcInOneVoltDc, (double)microvoltdcQuantity.Value, MicrovoltsDcTolerance);
+            Assert.Equal(ElectricPotentialDcUnit.MicrovoltDc, microvoltdcQuantity.Unit);
+
+            var millivoltdcQuantity = voltdc.ToUnit(ElectricPotentialDcUnit.MillivoltDc);
+            AssertEx.EqualTolerance(MillivoltsDcInOneVoltDc, (double)millivoltdcQuantity.Value, MillivoltsDcTolerance);
+            Assert.Equal(ElectricPotentialDcUnit.MillivoltDc, millivoltdcQuantity.Unit);
+
+            var voltdcQuantity = voltdc.ToUnit(ElectricPotentialDcUnit.VoltDc);
+            AssertEx.EqualTolerance(VoltsDcInOneVoltDc, (double)voltdcQuantity.Value, VoltsDcTolerance);
+            Assert.Equal(ElectricPotentialDcUnit.VoltDc, voltdcQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromKilovoltsDc(voltdc.KilovoltsDc).VoltsDc, KilovoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromMegavoltsDc(voltdc.MegavoltsDc).VoltsDc, MegavoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromMicrovoltsDc(voltdc.MicrovoltsDc).VoltsDc, MicrovoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromMillivoltsDc(voltdc.MillivoltsDc).VoltsDc, MillivoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromVoltsDc(voltdc.VoltsDc).VoltsDc, VoltsDcTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricPotentialDc<double> v = ElectricPotentialDc<double>.FromVoltsDc(1);
+            AssertEx.EqualTolerance(-1, -v.VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialDc<double>.FromVoltsDc(3)-v).VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(2, (v + v).VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(10, (v*10).VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(10, (10*v).VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialDc<double>.FromVoltsDc(10)/5).VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(2, ElectricPotentialDc<double>.FromVoltsDc(10)/ElectricPotentialDc<double>.FromVoltsDc(5), VoltsDcTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricPotentialDc<double> oneVoltDc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            ElectricPotentialDc<double> twoVoltsDc = ElectricPotentialDc<double>.FromVoltsDc(2);
+
+            Assert.True(oneVoltDc < twoVoltsDc);
+            Assert.True(oneVoltDc <= twoVoltsDc);
+            Assert.True(twoVoltsDc > oneVoltDc);
+            Assert.True(twoVoltsDc >= oneVoltDc);
+
+            Assert.False(oneVoltDc > twoVoltsDc);
+            Assert.False(oneVoltDc >= twoVoltsDc);
+            Assert.False(twoVoltsDc < oneVoltDc);
+            Assert.False(twoVoltsDc <= oneVoltDc);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            Assert.Equal(0, voltdc.CompareTo(voltdc));
+            Assert.True(voltdc.CompareTo(ElectricPotentialDc<double>.Zero) > 0);
+            Assert.True(ElectricPotentialDc<double>.Zero.CompareTo(voltdc) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            Assert.Throws<ArgumentException>(() => voltdc.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            Assert.Throws<ArgumentNullException>(() => voltdc.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricPotentialDc<double>.FromVoltsDc(1);
+            var b = ElectricPotentialDc<double>.FromVoltsDc(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricPotentialDc<double>.FromVoltsDc(1);
+            var b = ElectricPotentialDc<double>.FromVoltsDc(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricPotentialDc<double>.FromVoltsDc(1);
+            Assert.True(v.Equals(ElectricPotentialDc<double>.FromVoltsDc(1), VoltsDcTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricPotentialDc<double>.Zero, VoltsDcTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            Assert.False(voltdc.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            Assert.False(voltdc.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricPotentialDcUnit.Undefined, ElectricPotentialDc<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricPotentialDcUnit)).Cast<ElectricPotentialDcUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricPotentialDcUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricPotentialDc<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs
new file mode 100644
index 0000000000..6e9a28e357
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs
@@ -0,0 +1,283 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricPotential.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricPotentialTestsBase
+    {
+        protected abstract double KilovoltsInOneVolt { get; }
+        protected abstract double MegavoltsInOneVolt { get; }
+        protected abstract double MicrovoltsInOneVolt { get; }
+        protected abstract double MillivoltsInOneVolt { get; }
+        protected abstract double VoltsInOneVolt { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilovoltsTolerance { get { return 1e-5; } }
+        protected virtual double MegavoltsTolerance { get { return 1e-5; } }
+        protected virtual double MicrovoltsTolerance { get { return 1e-5; } }
+        protected virtual double MillivoltsTolerance { get { return 1e-5; } }
+        protected virtual double VoltsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>((double)0.0, ElectricPotentialUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>(double.PositiveInfinity, ElectricPotentialUnit.Volt));
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>(double.NegativeInfinity, ElectricPotentialUnit.Volt));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>(double.NaN, ElectricPotentialUnit.Volt));
+        }
+
+        [Fact]
+        public void VoltToElectricPotentialUnits()
+        {
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            AssertEx.EqualTolerance(KilovoltsInOneVolt, volt.Kilovolts, KilovoltsTolerance);
+            AssertEx.EqualTolerance(MegavoltsInOneVolt, volt.Megavolts, MegavoltsTolerance);
+            AssertEx.EqualTolerance(MicrovoltsInOneVolt, volt.Microvolts, MicrovoltsTolerance);
+            AssertEx.EqualTolerance(MillivoltsInOneVolt, volt.Millivolts, MillivoltsTolerance);
+            AssertEx.EqualTolerance(VoltsInOneVolt, volt.Volts, VoltsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.From(1, ElectricPotentialUnit.Kilovolt).Kilovolts, KilovoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.From(1, ElectricPotentialUnit.Megavolt).Megavolts, MegavoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.From(1, ElectricPotentialUnit.Microvolt).Microvolts, MicrovoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.From(1, ElectricPotentialUnit.Millivolt).Millivolts, MillivoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.From(1, ElectricPotentialUnit.Volt).Volts, VoltsTolerance);
+        }
+
+        [Fact]
+        public void FromVolts_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricPotential<double>.FromVolts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotential<double>.FromVolts(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVolts_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricPotential<double>.FromVolts(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var volt = ElectricPotential<double>.FromVolts(1);
+            AssertEx.EqualTolerance(KilovoltsInOneVolt, volt.As(ElectricPotentialUnit.Kilovolt), KilovoltsTolerance);
+            AssertEx.EqualTolerance(MegavoltsInOneVolt, volt.As(ElectricPotentialUnit.Megavolt), MegavoltsTolerance);
+            AssertEx.EqualTolerance(MicrovoltsInOneVolt, volt.As(ElectricPotentialUnit.Microvolt), MicrovoltsTolerance);
+            AssertEx.EqualTolerance(MillivoltsInOneVolt, volt.As(ElectricPotentialUnit.Millivolt), MillivoltsTolerance);
+            AssertEx.EqualTolerance(VoltsInOneVolt, volt.As(ElectricPotentialUnit.Volt), VoltsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var volt = ElectricPotential<double>.FromVolts(1);
+
+            var kilovoltQuantity = volt.ToUnit(ElectricPotentialUnit.Kilovolt);
+            AssertEx.EqualTolerance(KilovoltsInOneVolt, (double)kilovoltQuantity.Value, KilovoltsTolerance);
+            Assert.Equal(ElectricPotentialUnit.Kilovolt, kilovoltQuantity.Unit);
+
+            var megavoltQuantity = volt.ToUnit(ElectricPotentialUnit.Megavolt);
+            AssertEx.EqualTolerance(MegavoltsInOneVolt, (double)megavoltQuantity.Value, MegavoltsTolerance);
+            Assert.Equal(ElectricPotentialUnit.Megavolt, megavoltQuantity.Unit);
+
+            var microvoltQuantity = volt.ToUnit(ElectricPotentialUnit.Microvolt);
+            AssertEx.EqualTolerance(MicrovoltsInOneVolt, (double)microvoltQuantity.Value, MicrovoltsTolerance);
+            Assert.Equal(ElectricPotentialUnit.Microvolt, microvoltQuantity.Unit);
+
+            var millivoltQuantity = volt.ToUnit(ElectricPotentialUnit.Millivolt);
+            AssertEx.EqualTolerance(MillivoltsInOneVolt, (double)millivoltQuantity.Value, MillivoltsTolerance);
+            Assert.Equal(ElectricPotentialUnit.Millivolt, millivoltQuantity.Unit);
+
+            var voltQuantity = volt.ToUnit(ElectricPotentialUnit.Volt);
+            AssertEx.EqualTolerance(VoltsInOneVolt, (double)voltQuantity.Value, VoltsTolerance);
+            Assert.Equal(ElectricPotentialUnit.Volt, voltQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromKilovolts(volt.Kilovolts).Volts, KilovoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromMegavolts(volt.Megavolts).Volts, MegavoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromMicrovolts(volt.Microvolts).Volts, MicrovoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromMillivolts(volt.Millivolts).Volts, MillivoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromVolts(volt.Volts).Volts, VoltsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricPotential<double> v = ElectricPotential<double>.FromVolts(1);
+            AssertEx.EqualTolerance(-1, -v.Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotential<double>.FromVolts(3)-v).Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotential<double>.FromVolts(10)/5).Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(2, ElectricPotential<double>.FromVolts(10)/ElectricPotential<double>.FromVolts(5), VoltsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricPotential<double> oneVolt = ElectricPotential<double>.FromVolts(1);
+            ElectricPotential<double> twoVolts = ElectricPotential<double>.FromVolts(2);
+
+            Assert.True(oneVolt < twoVolts);
+            Assert.True(oneVolt <= twoVolts);
+            Assert.True(twoVolts > oneVolt);
+            Assert.True(twoVolts >= oneVolt);
+
+            Assert.False(oneVolt > twoVolts);
+            Assert.False(oneVolt >= twoVolts);
+            Assert.False(twoVolts < oneVolt);
+            Assert.False(twoVolts <= oneVolt);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            Assert.Equal(0, volt.CompareTo(volt));
+            Assert.True(volt.CompareTo(ElectricPotential<double>.Zero) > 0);
+            Assert.True(ElectricPotential<double>.Zero.CompareTo(volt) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            Assert.Throws<ArgumentException>(() => volt.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            Assert.Throws<ArgumentNullException>(() => volt.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricPotential<double>.FromVolts(1);
+            var b = ElectricPotential<double>.FromVolts(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricPotential<double>.FromVolts(1);
+            var b = ElectricPotential<double>.FromVolts(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricPotential<double>.FromVolts(1);
+            Assert.True(v.Equals(ElectricPotential<double>.FromVolts(1), VoltsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricPotential<double>.Zero, VoltsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            Assert.False(volt.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            Assert.False(volt.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricPotentialUnit.Undefined, ElectricPotential<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricPotentialUnit)).Cast<ElectricPotentialUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricPotentialUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricPotential<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs
new file mode 100644
index 0000000000..e413ea233d
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs
@@ -0,0 +1,283 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricResistance.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricResistanceTestsBase
+    {
+        protected abstract double GigaohmsInOneOhm { get; }
+        protected abstract double KiloohmsInOneOhm { get; }
+        protected abstract double MegaohmsInOneOhm { get; }
+        protected abstract double MilliohmsInOneOhm { get; }
+        protected abstract double OhmsInOneOhm { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double GigaohmsTolerance { get { return 1e-5; } }
+        protected virtual double KiloohmsTolerance { get { return 1e-5; } }
+        protected virtual double MegaohmsTolerance { get { return 1e-5; } }
+        protected virtual double MilliohmsTolerance { get { return 1e-5; } }
+        protected virtual double OhmsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>((double)0.0, ElectricResistanceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>(double.PositiveInfinity, ElectricResistanceUnit.Ohm));
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>(double.NegativeInfinity, ElectricResistanceUnit.Ohm));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>(double.NaN, ElectricResistanceUnit.Ohm));
+        }
+
+        [Fact]
+        public void OhmToElectricResistanceUnits()
+        {
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            AssertEx.EqualTolerance(GigaohmsInOneOhm, ohm.Gigaohms, GigaohmsTolerance);
+            AssertEx.EqualTolerance(KiloohmsInOneOhm, ohm.Kiloohms, KiloohmsTolerance);
+            AssertEx.EqualTolerance(MegaohmsInOneOhm, ohm.Megaohms, MegaohmsTolerance);
+            AssertEx.EqualTolerance(MilliohmsInOneOhm, ohm.Milliohms, MilliohmsTolerance);
+            AssertEx.EqualTolerance(OhmsInOneOhm, ohm.Ohms, OhmsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.From(1, ElectricResistanceUnit.Gigaohm).Gigaohms, GigaohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.From(1, ElectricResistanceUnit.Kiloohm).Kiloohms, KiloohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.From(1, ElectricResistanceUnit.Megaohm).Megaohms, MegaohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.From(1, ElectricResistanceUnit.Milliohm).Milliohms, MilliohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.From(1, ElectricResistanceUnit.Ohm).Ohms, OhmsTolerance);
+        }
+
+        [Fact]
+        public void FromOhms_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricResistance<double>.FromOhms(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricResistance<double>.FromOhms(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromOhms_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricResistance<double>.FromOhms(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var ohm = ElectricResistance<double>.FromOhms(1);
+            AssertEx.EqualTolerance(GigaohmsInOneOhm, ohm.As(ElectricResistanceUnit.Gigaohm), GigaohmsTolerance);
+            AssertEx.EqualTolerance(KiloohmsInOneOhm, ohm.As(ElectricResistanceUnit.Kiloohm), KiloohmsTolerance);
+            AssertEx.EqualTolerance(MegaohmsInOneOhm, ohm.As(ElectricResistanceUnit.Megaohm), MegaohmsTolerance);
+            AssertEx.EqualTolerance(MilliohmsInOneOhm, ohm.As(ElectricResistanceUnit.Milliohm), MilliohmsTolerance);
+            AssertEx.EqualTolerance(OhmsInOneOhm, ohm.As(ElectricResistanceUnit.Ohm), OhmsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var ohm = ElectricResistance<double>.FromOhms(1);
+
+            var gigaohmQuantity = ohm.ToUnit(ElectricResistanceUnit.Gigaohm);
+            AssertEx.EqualTolerance(GigaohmsInOneOhm, (double)gigaohmQuantity.Value, GigaohmsTolerance);
+            Assert.Equal(ElectricResistanceUnit.Gigaohm, gigaohmQuantity.Unit);
+
+            var kiloohmQuantity = ohm.ToUnit(ElectricResistanceUnit.Kiloohm);
+            AssertEx.EqualTolerance(KiloohmsInOneOhm, (double)kiloohmQuantity.Value, KiloohmsTolerance);
+            Assert.Equal(ElectricResistanceUnit.Kiloohm, kiloohmQuantity.Unit);
+
+            var megaohmQuantity = ohm.ToUnit(ElectricResistanceUnit.Megaohm);
+            AssertEx.EqualTolerance(MegaohmsInOneOhm, (double)megaohmQuantity.Value, MegaohmsTolerance);
+            Assert.Equal(ElectricResistanceUnit.Megaohm, megaohmQuantity.Unit);
+
+            var milliohmQuantity = ohm.ToUnit(ElectricResistanceUnit.Milliohm);
+            AssertEx.EqualTolerance(MilliohmsInOneOhm, (double)milliohmQuantity.Value, MilliohmsTolerance);
+            Assert.Equal(ElectricResistanceUnit.Milliohm, milliohmQuantity.Unit);
+
+            var ohmQuantity = ohm.ToUnit(ElectricResistanceUnit.Ohm);
+            AssertEx.EqualTolerance(OhmsInOneOhm, (double)ohmQuantity.Value, OhmsTolerance);
+            Assert.Equal(ElectricResistanceUnit.Ohm, ohmQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromGigaohms(ohm.Gigaohms).Ohms, GigaohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromKiloohms(ohm.Kiloohms).Ohms, KiloohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromMegaohms(ohm.Megaohms).Ohms, MegaohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromMilliohms(ohm.Milliohms).Ohms, MilliohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromOhms(ohm.Ohms).Ohms, OhmsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricResistance<double> v = ElectricResistance<double>.FromOhms(1);
+            AssertEx.EqualTolerance(-1, -v.Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricResistance<double>.FromOhms(3)-v).Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricResistance<double>.FromOhms(10)/5).Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(2, ElectricResistance<double>.FromOhms(10)/ElectricResistance<double>.FromOhms(5), OhmsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricResistance<double> oneOhm = ElectricResistance<double>.FromOhms(1);
+            ElectricResistance<double> twoOhms = ElectricResistance<double>.FromOhms(2);
+
+            Assert.True(oneOhm < twoOhms);
+            Assert.True(oneOhm <= twoOhms);
+            Assert.True(twoOhms > oneOhm);
+            Assert.True(twoOhms >= oneOhm);
+
+            Assert.False(oneOhm > twoOhms);
+            Assert.False(oneOhm >= twoOhms);
+            Assert.False(twoOhms < oneOhm);
+            Assert.False(twoOhms <= oneOhm);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            Assert.Equal(0, ohm.CompareTo(ohm));
+            Assert.True(ohm.CompareTo(ElectricResistance<double>.Zero) > 0);
+            Assert.True(ElectricResistance<double>.Zero.CompareTo(ohm) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            Assert.Throws<ArgumentException>(() => ohm.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            Assert.Throws<ArgumentNullException>(() => ohm.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricResistance<double>.FromOhms(1);
+            var b = ElectricResistance<double>.FromOhms(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricResistance<double>.FromOhms(1);
+            var b = ElectricResistance<double>.FromOhms(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricResistance<double>.FromOhms(1);
+            Assert.True(v.Equals(ElectricResistance<double>.FromOhms(1), OhmsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricResistance<double>.Zero, OhmsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            Assert.False(ohm.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            Assert.False(ohm.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricResistanceUnit.Undefined, ElectricResistance<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricResistanceUnit)).Cast<ElectricResistanceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricResistanceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricResistance<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricSurfaceChargeDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricSurfaceChargeDensityTestsBase.g.cs
new file mode 100644
index 0000000000..46669b804c
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ElectricSurfaceChargeDensityTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ElectricSurfaceChargeDensity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ElectricSurfaceChargeDensityTestsBase
+    {
+        protected abstract double CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter { get; }
+        protected abstract double CoulombsPerSquareInchInOneCoulombPerSquareMeter { get; }
+        protected abstract double CoulombsPerSquareMeterInOneCoulombPerSquareMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CoulombsPerSquareCentimeterTolerance { get { return 1e-5; } }
+        protected virtual double CoulombsPerSquareInchTolerance { get { return 1e-5; } }
+        protected virtual double CoulombsPerSquareMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>((double)0.0, ElectricSurfaceChargeDensityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>(double.PositiveInfinity, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>(double.NegativeInfinity, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>(double.NaN, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
+        }
+
+        [Fact]
+        public void CoulombPerSquareMeterToElectricSurfaceChargeDensityUnits()
+        {
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            AssertEx.EqualTolerance(CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter, coulombpersquaremeter.CoulombsPerSquareCentimeter, CoulombsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(CoulombsPerSquareInchInOneCoulombPerSquareMeter, coulombpersquaremeter.CoulombsPerSquareInch, CoulombsPerSquareInchTolerance);
+            AssertEx.EqualTolerance(CoulombsPerSquareMeterInOneCoulombPerSquareMeter, coulombpersquaremeter.CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter).CoulombsPerSquareCentimeter, CoulombsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch).CoulombsPerSquareInch, CoulombsPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromCoulombsPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromCoulombsPerSquareMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            AssertEx.EqualTolerance(CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter, coulombpersquaremeter.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter), CoulombsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(CoulombsPerSquareInchInOneCoulombPerSquareMeter, coulombpersquaremeter.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch), CoulombsPerSquareInchTolerance);
+            AssertEx.EqualTolerance(CoulombsPerSquareMeterInOneCoulombPerSquareMeter, coulombpersquaremeter.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter), CoulombsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+
+            var coulombpersquarecentimeterQuantity = coulombpersquaremeter.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
+            AssertEx.EqualTolerance(CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter, (double)coulombpersquarecentimeterQuantity.Value, CoulombsPerSquareCentimeterTolerance);
+            Assert.Equal(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, coulombpersquarecentimeterQuantity.Unit);
+
+            var coulombpersquareinchQuantity = coulombpersquaremeter.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
+            AssertEx.EqualTolerance(CoulombsPerSquareInchInOneCoulombPerSquareMeter, (double)coulombpersquareinchQuantity.Value, CoulombsPerSquareInchTolerance);
+            Assert.Equal(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, coulombpersquareinchQuantity.Unit);
+
+            var coulombpersquaremeterQuantity = coulombpersquaremeter.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
+            AssertEx.EqualTolerance(CoulombsPerSquareMeterInOneCoulombPerSquareMeter, (double)coulombpersquaremeterQuantity.Value, CoulombsPerSquareMeterTolerance);
+            Assert.Equal(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, coulombpersquaremeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareCentimeter(coulombpersquaremeter.CoulombsPerSquareCentimeter).CoulombsPerSquareMeter, CoulombsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareInch(coulombpersquaremeter.CoulombsPerSquareInch).CoulombsPerSquareMeter, CoulombsPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(coulombpersquaremeter.CoulombsPerSquareMeter).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ElectricSurfaceChargeDensity<double> v = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            AssertEx.EqualTolerance(-1, -v.CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(3)-v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(10)/5).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(10)/ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(5), CoulombsPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ElectricSurfaceChargeDensity<double> oneCoulombPerSquareMeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> twoCoulombsPerSquareMeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(2);
+
+            Assert.True(oneCoulombPerSquareMeter < twoCoulombsPerSquareMeter);
+            Assert.True(oneCoulombPerSquareMeter <= twoCoulombsPerSquareMeter);
+            Assert.True(twoCoulombsPerSquareMeter > oneCoulombPerSquareMeter);
+            Assert.True(twoCoulombsPerSquareMeter >= oneCoulombPerSquareMeter);
+
+            Assert.False(oneCoulombPerSquareMeter > twoCoulombsPerSquareMeter);
+            Assert.False(oneCoulombPerSquareMeter >= twoCoulombsPerSquareMeter);
+            Assert.False(twoCoulombsPerSquareMeter < oneCoulombPerSquareMeter);
+            Assert.False(twoCoulombsPerSquareMeter <= oneCoulombPerSquareMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            Assert.Equal(0, coulombpersquaremeter.CompareTo(coulombpersquaremeter));
+            Assert.True(coulombpersquaremeter.CompareTo(ElectricSurfaceChargeDensity<double>.Zero) > 0);
+            Assert.True(ElectricSurfaceChargeDensity<double>.Zero.CompareTo(coulombpersquaremeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            Assert.Throws<ArgumentException>(() => coulombpersquaremeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            Assert.Throws<ArgumentNullException>(() => coulombpersquaremeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            var b = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            var b = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            Assert.True(v.Equals(ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1), CoulombsPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricSurfaceChargeDensity<double>.Zero, CoulombsPerSquareMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            Assert.False(coulombpersquaremeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            Assert.False(coulombpersquaremeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ElectricSurfaceChargeDensityUnit.Undefined, ElectricSurfaceChargeDensity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ElectricSurfaceChargeDensityUnit)).Cast<ElectricSurfaceChargeDensityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ElectricSurfaceChargeDensityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ElectricSurfaceChargeDensity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs
new file mode 100644
index 0000000000..6d058a1bca
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs
@@ -0,0 +1,473 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Energy.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class EnergyTestsBase
+    {
+        protected abstract double BritishThermalUnitsInOneJoule { get; }
+        protected abstract double CaloriesInOneJoule { get; }
+        protected abstract double DecathermsEcInOneJoule { get; }
+        protected abstract double DecathermsImperialInOneJoule { get; }
+        protected abstract double DecathermsUsInOneJoule { get; }
+        protected abstract double ElectronVoltsInOneJoule { get; }
+        protected abstract double ErgsInOneJoule { get; }
+        protected abstract double FootPoundsInOneJoule { get; }
+        protected abstract double GigabritishThermalUnitsInOneJoule { get; }
+        protected abstract double GigawattHoursInOneJoule { get; }
+        protected abstract double JoulesInOneJoule { get; }
+        protected abstract double KilobritishThermalUnitsInOneJoule { get; }
+        protected abstract double KilocaloriesInOneJoule { get; }
+        protected abstract double KilojoulesInOneJoule { get; }
+        protected abstract double KilowattHoursInOneJoule { get; }
+        protected abstract double MegabritishThermalUnitsInOneJoule { get; }
+        protected abstract double MegajoulesInOneJoule { get; }
+        protected abstract double MegawattHoursInOneJoule { get; }
+        protected abstract double MillijoulesInOneJoule { get; }
+        protected abstract double TerawattHoursInOneJoule { get; }
+        protected abstract double ThermsEcInOneJoule { get; }
+        protected abstract double ThermsImperialInOneJoule { get; }
+        protected abstract double ThermsUsInOneJoule { get; }
+        protected abstract double WattHoursInOneJoule { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double BritishThermalUnitsTolerance { get { return 1e-5; } }
+        protected virtual double CaloriesTolerance { get { return 1e-5; } }
+        protected virtual double DecathermsEcTolerance { get { return 1e-5; } }
+        protected virtual double DecathermsImperialTolerance { get { return 1e-5; } }
+        protected virtual double DecathermsUsTolerance { get { return 1e-5; } }
+        protected virtual double ElectronVoltsTolerance { get { return 1e-5; } }
+        protected virtual double ErgsTolerance { get { return 1e-5; } }
+        protected virtual double FootPoundsTolerance { get { return 1e-5; } }
+        protected virtual double GigabritishThermalUnitsTolerance { get { return 1e-5; } }
+        protected virtual double GigawattHoursTolerance { get { return 1e-5; } }
+        protected virtual double JoulesTolerance { get { return 1e-5; } }
+        protected virtual double KilobritishThermalUnitsTolerance { get { return 1e-5; } }
+        protected virtual double KilocaloriesTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesTolerance { get { return 1e-5; } }
+        protected virtual double KilowattHoursTolerance { get { return 1e-5; } }
+        protected virtual double MegabritishThermalUnitsTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesTolerance { get { return 1e-5; } }
+        protected virtual double MegawattHoursTolerance { get { return 1e-5; } }
+        protected virtual double MillijoulesTolerance { get { return 1e-5; } }
+        protected virtual double TerawattHoursTolerance { get { return 1e-5; } }
+        protected virtual double ThermsEcTolerance { get { return 1e-5; } }
+        protected virtual double ThermsImperialTolerance { get { return 1e-5; } }
+        protected virtual double ThermsUsTolerance { get { return 1e-5; } }
+        protected virtual double WattHoursTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Energy<double>((double)0.0, EnergyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Energy<double>(double.PositiveInfinity, EnergyUnit.Joule));
+            Assert.Throws<ArgumentException>(() => new Energy<double>(double.NegativeInfinity, EnergyUnit.Joule));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Energy<double>(double.NaN, EnergyUnit.Joule));
+        }
+
+        [Fact]
+        public void JouleToEnergyUnits()
+        {
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            AssertEx.EqualTolerance(BritishThermalUnitsInOneJoule, joule.BritishThermalUnits, BritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(CaloriesInOneJoule, joule.Calories, CaloriesTolerance);
+            AssertEx.EqualTolerance(DecathermsEcInOneJoule, joule.DecathermsEc, DecathermsEcTolerance);
+            AssertEx.EqualTolerance(DecathermsImperialInOneJoule, joule.DecathermsImperial, DecathermsImperialTolerance);
+            AssertEx.EqualTolerance(DecathermsUsInOneJoule, joule.DecathermsUs, DecathermsUsTolerance);
+            AssertEx.EqualTolerance(ElectronVoltsInOneJoule, joule.ElectronVolts, ElectronVoltsTolerance);
+            AssertEx.EqualTolerance(ErgsInOneJoule, joule.Ergs, ErgsTolerance);
+            AssertEx.EqualTolerance(FootPoundsInOneJoule, joule.FootPounds, FootPoundsTolerance);
+            AssertEx.EqualTolerance(GigabritishThermalUnitsInOneJoule, joule.GigabritishThermalUnits, GigabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(GigawattHoursInOneJoule, joule.GigawattHours, GigawattHoursTolerance);
+            AssertEx.EqualTolerance(JoulesInOneJoule, joule.Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(KilobritishThermalUnitsInOneJoule, joule.KilobritishThermalUnits, KilobritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(KilocaloriesInOneJoule, joule.Kilocalories, KilocaloriesTolerance);
+            AssertEx.EqualTolerance(KilojoulesInOneJoule, joule.Kilojoules, KilojoulesTolerance);
+            AssertEx.EqualTolerance(KilowattHoursInOneJoule, joule.KilowattHours, KilowattHoursTolerance);
+            AssertEx.EqualTolerance(MegabritishThermalUnitsInOneJoule, joule.MegabritishThermalUnits, MegabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(MegajoulesInOneJoule, joule.Megajoules, MegajoulesTolerance);
+            AssertEx.EqualTolerance(MegawattHoursInOneJoule, joule.MegawattHours, MegawattHoursTolerance);
+            AssertEx.EqualTolerance(MillijoulesInOneJoule, joule.Millijoules, MillijoulesTolerance);
+            AssertEx.EqualTolerance(TerawattHoursInOneJoule, joule.TerawattHours, TerawattHoursTolerance);
+            AssertEx.EqualTolerance(ThermsEcInOneJoule, joule.ThermsEc, ThermsEcTolerance);
+            AssertEx.EqualTolerance(ThermsImperialInOneJoule, joule.ThermsImperial, ThermsImperialTolerance);
+            AssertEx.EqualTolerance(ThermsUsInOneJoule, joule.ThermsUs, ThermsUsTolerance);
+            AssertEx.EqualTolerance(WattHoursInOneJoule, joule.WattHours, WattHoursTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.BritishThermalUnit).BritishThermalUnits, BritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.Calorie).Calories, CaloriesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.DecathermEc).DecathermsEc, DecathermsEcTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.DecathermImperial).DecathermsImperial, DecathermsImperialTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.DecathermUs).DecathermsUs, DecathermsUsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.ElectronVolt).ElectronVolts, ElectronVoltsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.Erg).Ergs, ErgsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.FootPound).FootPounds, FootPoundsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.GigabritishThermalUnit).GigabritishThermalUnits, GigabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.GigawattHour).GigawattHours, GigawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.Joule).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.KilobritishThermalUnit).KilobritishThermalUnits, KilobritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.Kilocalorie).Kilocalories, KilocaloriesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.Kilojoule).Kilojoules, KilojoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.KilowattHour).KilowattHours, KilowattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.MegabritishThermalUnit).MegabritishThermalUnits, MegabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.Megajoule).Megajoules, MegajoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.MegawattHour).MegawattHours, MegawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.Millijoule).Millijoules, MillijoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.TerawattHour).TerawattHours, TerawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.ThermEc).ThermsEc, ThermsEcTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.ThermImperial).ThermsImperial, ThermsImperialTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.ThermUs).ThermsUs, ThermsUsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.From(1, EnergyUnit.WattHour).WattHours, WattHoursTolerance);
+        }
+
+        [Fact]
+        public void FromJoules_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Energy<double>.FromJoules(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Energy<double>.FromJoules(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromJoules_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Energy<double>.FromJoules(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var joule = Energy<double>.FromJoules(1);
+            AssertEx.EqualTolerance(BritishThermalUnitsInOneJoule, joule.As(EnergyUnit.BritishThermalUnit), BritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(CaloriesInOneJoule, joule.As(EnergyUnit.Calorie), CaloriesTolerance);
+            AssertEx.EqualTolerance(DecathermsEcInOneJoule, joule.As(EnergyUnit.DecathermEc), DecathermsEcTolerance);
+            AssertEx.EqualTolerance(DecathermsImperialInOneJoule, joule.As(EnergyUnit.DecathermImperial), DecathermsImperialTolerance);
+            AssertEx.EqualTolerance(DecathermsUsInOneJoule, joule.As(EnergyUnit.DecathermUs), DecathermsUsTolerance);
+            AssertEx.EqualTolerance(ElectronVoltsInOneJoule, joule.As(EnergyUnit.ElectronVolt), ElectronVoltsTolerance);
+            AssertEx.EqualTolerance(ErgsInOneJoule, joule.As(EnergyUnit.Erg), ErgsTolerance);
+            AssertEx.EqualTolerance(FootPoundsInOneJoule, joule.As(EnergyUnit.FootPound), FootPoundsTolerance);
+            AssertEx.EqualTolerance(GigabritishThermalUnitsInOneJoule, joule.As(EnergyUnit.GigabritishThermalUnit), GigabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(GigawattHoursInOneJoule, joule.As(EnergyUnit.GigawattHour), GigawattHoursTolerance);
+            AssertEx.EqualTolerance(JoulesInOneJoule, joule.As(EnergyUnit.Joule), JoulesTolerance);
+            AssertEx.EqualTolerance(KilobritishThermalUnitsInOneJoule, joule.As(EnergyUnit.KilobritishThermalUnit), KilobritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(KilocaloriesInOneJoule, joule.As(EnergyUnit.Kilocalorie), KilocaloriesTolerance);
+            AssertEx.EqualTolerance(KilojoulesInOneJoule, joule.As(EnergyUnit.Kilojoule), KilojoulesTolerance);
+            AssertEx.EqualTolerance(KilowattHoursInOneJoule, joule.As(EnergyUnit.KilowattHour), KilowattHoursTolerance);
+            AssertEx.EqualTolerance(MegabritishThermalUnitsInOneJoule, joule.As(EnergyUnit.MegabritishThermalUnit), MegabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(MegajoulesInOneJoule, joule.As(EnergyUnit.Megajoule), MegajoulesTolerance);
+            AssertEx.EqualTolerance(MegawattHoursInOneJoule, joule.As(EnergyUnit.MegawattHour), MegawattHoursTolerance);
+            AssertEx.EqualTolerance(MillijoulesInOneJoule, joule.As(EnergyUnit.Millijoule), MillijoulesTolerance);
+            AssertEx.EqualTolerance(TerawattHoursInOneJoule, joule.As(EnergyUnit.TerawattHour), TerawattHoursTolerance);
+            AssertEx.EqualTolerance(ThermsEcInOneJoule, joule.As(EnergyUnit.ThermEc), ThermsEcTolerance);
+            AssertEx.EqualTolerance(ThermsImperialInOneJoule, joule.As(EnergyUnit.ThermImperial), ThermsImperialTolerance);
+            AssertEx.EqualTolerance(ThermsUsInOneJoule, joule.As(EnergyUnit.ThermUs), ThermsUsTolerance);
+            AssertEx.EqualTolerance(WattHoursInOneJoule, joule.As(EnergyUnit.WattHour), WattHoursTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var joule = Energy<double>.FromJoules(1);
+
+            var britishthermalunitQuantity = joule.ToUnit(EnergyUnit.BritishThermalUnit);
+            AssertEx.EqualTolerance(BritishThermalUnitsInOneJoule, (double)britishthermalunitQuantity.Value, BritishThermalUnitsTolerance);
+            Assert.Equal(EnergyUnit.BritishThermalUnit, britishthermalunitQuantity.Unit);
+
+            var calorieQuantity = joule.ToUnit(EnergyUnit.Calorie);
+            AssertEx.EqualTolerance(CaloriesInOneJoule, (double)calorieQuantity.Value, CaloriesTolerance);
+            Assert.Equal(EnergyUnit.Calorie, calorieQuantity.Unit);
+
+            var decathermecQuantity = joule.ToUnit(EnergyUnit.DecathermEc);
+            AssertEx.EqualTolerance(DecathermsEcInOneJoule, (double)decathermecQuantity.Value, DecathermsEcTolerance);
+            Assert.Equal(EnergyUnit.DecathermEc, decathermecQuantity.Unit);
+
+            var decathermimperialQuantity = joule.ToUnit(EnergyUnit.DecathermImperial);
+            AssertEx.EqualTolerance(DecathermsImperialInOneJoule, (double)decathermimperialQuantity.Value, DecathermsImperialTolerance);
+            Assert.Equal(EnergyUnit.DecathermImperial, decathermimperialQuantity.Unit);
+
+            var decathermusQuantity = joule.ToUnit(EnergyUnit.DecathermUs);
+            AssertEx.EqualTolerance(DecathermsUsInOneJoule, (double)decathermusQuantity.Value, DecathermsUsTolerance);
+            Assert.Equal(EnergyUnit.DecathermUs, decathermusQuantity.Unit);
+
+            var electronvoltQuantity = joule.ToUnit(EnergyUnit.ElectronVolt);
+            AssertEx.EqualTolerance(ElectronVoltsInOneJoule, (double)electronvoltQuantity.Value, ElectronVoltsTolerance);
+            Assert.Equal(EnergyUnit.ElectronVolt, electronvoltQuantity.Unit);
+
+            var ergQuantity = joule.ToUnit(EnergyUnit.Erg);
+            AssertEx.EqualTolerance(ErgsInOneJoule, (double)ergQuantity.Value, ErgsTolerance);
+            Assert.Equal(EnergyUnit.Erg, ergQuantity.Unit);
+
+            var footpoundQuantity = joule.ToUnit(EnergyUnit.FootPound);
+            AssertEx.EqualTolerance(FootPoundsInOneJoule, (double)footpoundQuantity.Value, FootPoundsTolerance);
+            Assert.Equal(EnergyUnit.FootPound, footpoundQuantity.Unit);
+
+            var gigabritishthermalunitQuantity = joule.ToUnit(EnergyUnit.GigabritishThermalUnit);
+            AssertEx.EqualTolerance(GigabritishThermalUnitsInOneJoule, (double)gigabritishthermalunitQuantity.Value, GigabritishThermalUnitsTolerance);
+            Assert.Equal(EnergyUnit.GigabritishThermalUnit, gigabritishthermalunitQuantity.Unit);
+
+            var gigawatthourQuantity = joule.ToUnit(EnergyUnit.GigawattHour);
+            AssertEx.EqualTolerance(GigawattHoursInOneJoule, (double)gigawatthourQuantity.Value, GigawattHoursTolerance);
+            Assert.Equal(EnergyUnit.GigawattHour, gigawatthourQuantity.Unit);
+
+            var jouleQuantity = joule.ToUnit(EnergyUnit.Joule);
+            AssertEx.EqualTolerance(JoulesInOneJoule, (double)jouleQuantity.Value, JoulesTolerance);
+            Assert.Equal(EnergyUnit.Joule, jouleQuantity.Unit);
+
+            var kilobritishthermalunitQuantity = joule.ToUnit(EnergyUnit.KilobritishThermalUnit);
+            AssertEx.EqualTolerance(KilobritishThermalUnitsInOneJoule, (double)kilobritishthermalunitQuantity.Value, KilobritishThermalUnitsTolerance);
+            Assert.Equal(EnergyUnit.KilobritishThermalUnit, kilobritishthermalunitQuantity.Unit);
+
+            var kilocalorieQuantity = joule.ToUnit(EnergyUnit.Kilocalorie);
+            AssertEx.EqualTolerance(KilocaloriesInOneJoule, (double)kilocalorieQuantity.Value, KilocaloriesTolerance);
+            Assert.Equal(EnergyUnit.Kilocalorie, kilocalorieQuantity.Unit);
+
+            var kilojouleQuantity = joule.ToUnit(EnergyUnit.Kilojoule);
+            AssertEx.EqualTolerance(KilojoulesInOneJoule, (double)kilojouleQuantity.Value, KilojoulesTolerance);
+            Assert.Equal(EnergyUnit.Kilojoule, kilojouleQuantity.Unit);
+
+            var kilowatthourQuantity = joule.ToUnit(EnergyUnit.KilowattHour);
+            AssertEx.EqualTolerance(KilowattHoursInOneJoule, (double)kilowatthourQuantity.Value, KilowattHoursTolerance);
+            Assert.Equal(EnergyUnit.KilowattHour, kilowatthourQuantity.Unit);
+
+            var megabritishthermalunitQuantity = joule.ToUnit(EnergyUnit.MegabritishThermalUnit);
+            AssertEx.EqualTolerance(MegabritishThermalUnitsInOneJoule, (double)megabritishthermalunitQuantity.Value, MegabritishThermalUnitsTolerance);
+            Assert.Equal(EnergyUnit.MegabritishThermalUnit, megabritishthermalunitQuantity.Unit);
+
+            var megajouleQuantity = joule.ToUnit(EnergyUnit.Megajoule);
+            AssertEx.EqualTolerance(MegajoulesInOneJoule, (double)megajouleQuantity.Value, MegajoulesTolerance);
+            Assert.Equal(EnergyUnit.Megajoule, megajouleQuantity.Unit);
+
+            var megawatthourQuantity = joule.ToUnit(EnergyUnit.MegawattHour);
+            AssertEx.EqualTolerance(MegawattHoursInOneJoule, (double)megawatthourQuantity.Value, MegawattHoursTolerance);
+            Assert.Equal(EnergyUnit.MegawattHour, megawatthourQuantity.Unit);
+
+            var millijouleQuantity = joule.ToUnit(EnergyUnit.Millijoule);
+            AssertEx.EqualTolerance(MillijoulesInOneJoule, (double)millijouleQuantity.Value, MillijoulesTolerance);
+            Assert.Equal(EnergyUnit.Millijoule, millijouleQuantity.Unit);
+
+            var terawatthourQuantity = joule.ToUnit(EnergyUnit.TerawattHour);
+            AssertEx.EqualTolerance(TerawattHoursInOneJoule, (double)terawatthourQuantity.Value, TerawattHoursTolerance);
+            Assert.Equal(EnergyUnit.TerawattHour, terawatthourQuantity.Unit);
+
+            var thermecQuantity = joule.ToUnit(EnergyUnit.ThermEc);
+            AssertEx.EqualTolerance(ThermsEcInOneJoule, (double)thermecQuantity.Value, ThermsEcTolerance);
+            Assert.Equal(EnergyUnit.ThermEc, thermecQuantity.Unit);
+
+            var thermimperialQuantity = joule.ToUnit(EnergyUnit.ThermImperial);
+            AssertEx.EqualTolerance(ThermsImperialInOneJoule, (double)thermimperialQuantity.Value, ThermsImperialTolerance);
+            Assert.Equal(EnergyUnit.ThermImperial, thermimperialQuantity.Unit);
+
+            var thermusQuantity = joule.ToUnit(EnergyUnit.ThermUs);
+            AssertEx.EqualTolerance(ThermsUsInOneJoule, (double)thermusQuantity.Value, ThermsUsTolerance);
+            Assert.Equal(EnergyUnit.ThermUs, thermusQuantity.Unit);
+
+            var watthourQuantity = joule.ToUnit(EnergyUnit.WattHour);
+            AssertEx.EqualTolerance(WattHoursInOneJoule, (double)watthourQuantity.Value, WattHoursTolerance);
+            Assert.Equal(EnergyUnit.WattHour, watthourQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            AssertEx.EqualTolerance(1, Energy<double>.FromBritishThermalUnits(joule.BritishThermalUnits).Joules, BritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromCalories(joule.Calories).Joules, CaloriesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromDecathermsEc(joule.DecathermsEc).Joules, DecathermsEcTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromDecathermsImperial(joule.DecathermsImperial).Joules, DecathermsImperialTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromDecathermsUs(joule.DecathermsUs).Joules, DecathermsUsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromElectronVolts(joule.ElectronVolts).Joules, ElectronVoltsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromErgs(joule.Ergs).Joules, ErgsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromFootPounds(joule.FootPounds).Joules, FootPoundsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromGigabritishThermalUnits(joule.GigabritishThermalUnits).Joules, GigabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromGigawattHours(joule.GigawattHours).Joules, GigawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromJoules(joule.Joules).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilobritishThermalUnits(joule.KilobritishThermalUnits).Joules, KilobritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilocalories(joule.Kilocalories).Joules, KilocaloriesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilojoules(joule.Kilojoules).Joules, KilojoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilowattHours(joule.KilowattHours).Joules, KilowattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegabritishThermalUnits(joule.MegabritishThermalUnits).Joules, MegabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegajoules(joule.Megajoules).Joules, MegajoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegawattHours(joule.MegawattHours).Joules, MegawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMillijoules(joule.Millijoules).Joules, MillijoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromTerawattHours(joule.TerawattHours).Joules, TerawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromThermsEc(joule.ThermsEc).Joules, ThermsEcTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromThermsImperial(joule.ThermsImperial).Joules, ThermsImperialTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromThermsUs(joule.ThermsUs).Joules, ThermsUsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromWattHours(joule.WattHours).Joules, WattHoursTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Energy<double> v = Energy<double>.FromJoules(1);
+            AssertEx.EqualTolerance(-1, -v.Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(2, (Energy<double>.FromJoules(3)-v).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(2, (Energy<double>.FromJoules(10)/5).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(2, Energy<double>.FromJoules(10)/Energy<double>.FromJoules(5), JoulesTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Energy<double> oneJoule = Energy<double>.FromJoules(1);
+            Energy<double> twoJoules = Energy<double>.FromJoules(2);
+
+            Assert.True(oneJoule < twoJoules);
+            Assert.True(oneJoule <= twoJoules);
+            Assert.True(twoJoules > oneJoule);
+            Assert.True(twoJoules >= oneJoule);
+
+            Assert.False(oneJoule > twoJoules);
+            Assert.False(oneJoule >= twoJoules);
+            Assert.False(twoJoules < oneJoule);
+            Assert.False(twoJoules <= oneJoule);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            Assert.Equal(0, joule.CompareTo(joule));
+            Assert.True(joule.CompareTo(Energy<double>.Zero) > 0);
+            Assert.True(Energy<double>.Zero.CompareTo(joule) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            Assert.Throws<ArgumentException>(() => joule.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            Assert.Throws<ArgumentNullException>(() => joule.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Energy<double>.FromJoules(1);
+            var b = Energy<double>.FromJoules(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Energy<double>.FromJoules(1);
+            var b = Energy<double>.FromJoules(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Energy<double>.FromJoules(1);
+            Assert.True(v.Equals(Energy<double>.FromJoules(1), JoulesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Energy<double>.Zero, JoulesTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            Assert.False(joule.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            Assert.False(joule.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(EnergyUnit.Undefined, Energy<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(EnergyUnit)).Cast<EnergyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == EnergyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Energy<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/EntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EntropyTestsBase.g.cs
new file mode 100644
index 0000000000..1904d507f8
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/EntropyTestsBase.g.cs
@@ -0,0 +1,303 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Entropy.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class EntropyTestsBase
+    {
+        protected abstract double CaloriesPerKelvinInOneJoulePerKelvin { get; }
+        protected abstract double JoulesPerDegreeCelsiusInOneJoulePerKelvin { get; }
+        protected abstract double JoulesPerKelvinInOneJoulePerKelvin { get; }
+        protected abstract double KilocaloriesPerKelvinInOneJoulePerKelvin { get; }
+        protected abstract double KilojoulesPerDegreeCelsiusInOneJoulePerKelvin { get; }
+        protected abstract double KilojoulesPerKelvinInOneJoulePerKelvin { get; }
+        protected abstract double MegajoulesPerKelvinInOneJoulePerKelvin { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CaloriesPerKelvinTolerance { get { return 1e-5; } }
+        protected virtual double JoulesPerDegreeCelsiusTolerance { get { return 1e-5; } }
+        protected virtual double JoulesPerKelvinTolerance { get { return 1e-5; } }
+        protected virtual double KilocaloriesPerKelvinTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerDegreeCelsiusTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerKelvinTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesPerKelvinTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Entropy<double>((double)0.0, EntropyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Entropy<double>(double.PositiveInfinity, EntropyUnit.JoulePerKelvin));
+            Assert.Throws<ArgumentException>(() => new Entropy<double>(double.NegativeInfinity, EntropyUnit.JoulePerKelvin));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Entropy<double>(double.NaN, EntropyUnit.JoulePerKelvin));
+        }
+
+        [Fact]
+        public void JoulePerKelvinToEntropyUnits()
+        {
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            AssertEx.EqualTolerance(CaloriesPerKelvinInOneJoulePerKelvin, jouleperkelvin.CaloriesPerKelvin, CaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(JoulesPerDegreeCelsiusInOneJoulePerKelvin, jouleperkelvin.JoulesPerDegreeCelsius, JoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(JoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(KilocaloriesPerKelvinInOneJoulePerKelvin, jouleperkelvin.KilocaloriesPerKelvin, KilocaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerDegreeCelsiusInOneJoulePerKelvin, jouleperkelvin.KilojoulesPerDegreeCelsius, KilojoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.KilojoulesPerKelvin, KilojoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.MegajoulesPerKelvin, MegajoulesPerKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Entropy<double>.From(1, EntropyUnit.CaloriePerKelvin).CaloriesPerKelvin, CaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.From(1, EntropyUnit.JoulePerDegreeCelsius).JoulesPerDegreeCelsius, JoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.From(1, EntropyUnit.JoulePerKelvin).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.From(1, EntropyUnit.KilocaloriePerKelvin).KilocaloriesPerKelvin, KilocaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.From(1, EntropyUnit.KilojoulePerDegreeCelsius).KilojoulesPerDegreeCelsius, KilojoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.From(1, EntropyUnit.KilojoulePerKelvin).KilojoulesPerKelvin, KilojoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.From(1, EntropyUnit.MegajoulePerKelvin).MegajoulesPerKelvin, MegajoulesPerKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromJoulesPerKelvin_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Entropy<double>.FromJoulesPerKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Entropy<double>.FromJoulesPerKelvin(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromJoulesPerKelvin_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Entropy<double>.FromJoulesPerKelvin(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            AssertEx.EqualTolerance(CaloriesPerKelvinInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.CaloriePerKelvin), CaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(JoulesPerDegreeCelsiusInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.JoulePerDegreeCelsius), JoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(JoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.JoulePerKelvin), JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(KilocaloriesPerKelvinInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.KilocaloriePerKelvin), KilocaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerDegreeCelsiusInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.KilojoulePerDegreeCelsius), KilojoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.KilojoulePerKelvin), KilojoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.MegajoulePerKelvin), MegajoulesPerKelvinTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+
+            var calorieperkelvinQuantity = jouleperkelvin.ToUnit(EntropyUnit.CaloriePerKelvin);
+            AssertEx.EqualTolerance(CaloriesPerKelvinInOneJoulePerKelvin, (double)calorieperkelvinQuantity.Value, CaloriesPerKelvinTolerance);
+            Assert.Equal(EntropyUnit.CaloriePerKelvin, calorieperkelvinQuantity.Unit);
+
+            var jouleperdegreecelsiusQuantity = jouleperkelvin.ToUnit(EntropyUnit.JoulePerDegreeCelsius);
+            AssertEx.EqualTolerance(JoulesPerDegreeCelsiusInOneJoulePerKelvin, (double)jouleperdegreecelsiusQuantity.Value, JoulesPerDegreeCelsiusTolerance);
+            Assert.Equal(EntropyUnit.JoulePerDegreeCelsius, jouleperdegreecelsiusQuantity.Unit);
+
+            var jouleperkelvinQuantity = jouleperkelvin.ToUnit(EntropyUnit.JoulePerKelvin);
+            AssertEx.EqualTolerance(JoulesPerKelvinInOneJoulePerKelvin, (double)jouleperkelvinQuantity.Value, JoulesPerKelvinTolerance);
+            Assert.Equal(EntropyUnit.JoulePerKelvin, jouleperkelvinQuantity.Unit);
+
+            var kilocalorieperkelvinQuantity = jouleperkelvin.ToUnit(EntropyUnit.KilocaloriePerKelvin);
+            AssertEx.EqualTolerance(KilocaloriesPerKelvinInOneJoulePerKelvin, (double)kilocalorieperkelvinQuantity.Value, KilocaloriesPerKelvinTolerance);
+            Assert.Equal(EntropyUnit.KilocaloriePerKelvin, kilocalorieperkelvinQuantity.Unit);
+
+            var kilojouleperdegreecelsiusQuantity = jouleperkelvin.ToUnit(EntropyUnit.KilojoulePerDegreeCelsius);
+            AssertEx.EqualTolerance(KilojoulesPerDegreeCelsiusInOneJoulePerKelvin, (double)kilojouleperdegreecelsiusQuantity.Value, KilojoulesPerDegreeCelsiusTolerance);
+            Assert.Equal(EntropyUnit.KilojoulePerDegreeCelsius, kilojouleperdegreecelsiusQuantity.Unit);
+
+            var kilojouleperkelvinQuantity = jouleperkelvin.ToUnit(EntropyUnit.KilojoulePerKelvin);
+            AssertEx.EqualTolerance(KilojoulesPerKelvinInOneJoulePerKelvin, (double)kilojouleperkelvinQuantity.Value, KilojoulesPerKelvinTolerance);
+            Assert.Equal(EntropyUnit.KilojoulePerKelvin, kilojouleperkelvinQuantity.Unit);
+
+            var megajouleperkelvinQuantity = jouleperkelvin.ToUnit(EntropyUnit.MegajoulePerKelvin);
+            AssertEx.EqualTolerance(MegajoulesPerKelvinInOneJoulePerKelvin, (double)megajouleperkelvinQuantity.Value, MegajoulesPerKelvinTolerance);
+            Assert.Equal(EntropyUnit.MegajoulePerKelvin, megajouleperkelvinQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromCaloriesPerKelvin(jouleperkelvin.CaloriesPerKelvin).JoulesPerKelvin, CaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromJoulesPerDegreeCelsius(jouleperkelvin.JoulesPerDegreeCelsius).JoulesPerKelvin, JoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromJoulesPerKelvin(jouleperkelvin.JoulesPerKelvin).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromKilocaloriesPerKelvin(jouleperkelvin.KilocaloriesPerKelvin).JoulesPerKelvin, KilocaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromKilojoulesPerDegreeCelsius(jouleperkelvin.KilojoulesPerDegreeCelsius).JoulesPerKelvin, KilojoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromKilojoulesPerKelvin(jouleperkelvin.KilojoulesPerKelvin).JoulesPerKelvin, KilojoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromMegajoulesPerKelvin(jouleperkelvin.MegajoulesPerKelvin).JoulesPerKelvin, MegajoulesPerKelvinTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Entropy<double> v = Entropy<double>.FromJoulesPerKelvin(1);
+            AssertEx.EqualTolerance(-1, -v.JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(2, (Entropy<double>.FromJoulesPerKelvin(3)-v).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(2, (v + v).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(10, (v*10).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(10, (10*v).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(2, (Entropy<double>.FromJoulesPerKelvin(10)/5).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(2, Entropy<double>.FromJoulesPerKelvin(10)/Entropy<double>.FromJoulesPerKelvin(5), JoulesPerKelvinTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Entropy<double> oneJoulePerKelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            Entropy<double> twoJoulesPerKelvin = Entropy<double>.FromJoulesPerKelvin(2);
+
+            Assert.True(oneJoulePerKelvin < twoJoulesPerKelvin);
+            Assert.True(oneJoulePerKelvin <= twoJoulesPerKelvin);
+            Assert.True(twoJoulesPerKelvin > oneJoulePerKelvin);
+            Assert.True(twoJoulesPerKelvin >= oneJoulePerKelvin);
+
+            Assert.False(oneJoulePerKelvin > twoJoulesPerKelvin);
+            Assert.False(oneJoulePerKelvin >= twoJoulesPerKelvin);
+            Assert.False(twoJoulesPerKelvin < oneJoulePerKelvin);
+            Assert.False(twoJoulesPerKelvin <= oneJoulePerKelvin);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            Assert.Equal(0, jouleperkelvin.CompareTo(jouleperkelvin));
+            Assert.True(jouleperkelvin.CompareTo(Entropy<double>.Zero) > 0);
+            Assert.True(Entropy<double>.Zero.CompareTo(jouleperkelvin) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            Assert.Throws<ArgumentException>(() => jouleperkelvin.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            Assert.Throws<ArgumentNullException>(() => jouleperkelvin.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Entropy<double>.FromJoulesPerKelvin(1);
+            var b = Entropy<double>.FromJoulesPerKelvin(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Entropy<double>.FromJoulesPerKelvin(1);
+            var b = Entropy<double>.FromJoulesPerKelvin(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Entropy<double>.FromJoulesPerKelvin(1);
+            Assert.True(v.Equals(Entropy<double>.FromJoulesPerKelvin(1), JoulesPerKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Entropy<double>.Zero, JoulesPerKelvinTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            Assert.False(jouleperkelvin.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            Assert.False(jouleperkelvin.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(EntropyUnit.Undefined, Entropy<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(EntropyUnit)).Cast<EntropyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == EntropyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Entropy<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ForcePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForcePerLengthTestsBase.g.cs
new file mode 100644
index 0000000000..e505262677
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ForcePerLengthTestsBase.g.cs
@@ -0,0 +1,353 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ForcePerLength.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ForcePerLengthTestsBase
+    {
+        protected abstract double CentinewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double DecinewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double KilogramsForcePerMeterInOneNewtonPerMeter { get; }
+        protected abstract double KilonewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double MeganewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double MicronewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double MillinewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double NanonewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double NewtonsPerMeterInOneNewtonPerMeter { get; }
+        protected abstract double PoundsForcePerFootInOneNewtonPerMeter { get; }
+        protected abstract double PoundsForcePerInchInOneNewtonPerMeter { get; }
+        protected abstract double PoundsForcePerYardInOneNewtonPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CentinewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double DecinewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double KilogramsForcePerMeterTolerance { get { return 1e-5; } }
+        protected virtual double KilonewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double MeganewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double MicronewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double MillinewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double NanonewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double NewtonsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double PoundsForcePerFootTolerance { get { return 1e-5; } }
+        protected virtual double PoundsForcePerInchTolerance { get { return 1e-5; } }
+        protected virtual double PoundsForcePerYardTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>((double)0.0, ForcePerLengthUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>(double.PositiveInfinity, ForcePerLengthUnit.NewtonPerMeter));
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>(double.NegativeInfinity, ForcePerLengthUnit.NewtonPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>(double.NaN, ForcePerLengthUnit.NewtonPerMeter));
+        }
+
+        [Fact]
+        public void NewtonPerMeterToForcePerLengthUnits()
+        {
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            AssertEx.EqualTolerance(CentinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.CentinewtonsPerMeter, CentinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(DecinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.DecinewtonsPerMeter, DecinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(KilogramsForcePerMeterInOneNewtonPerMeter, newtonpermeter.KilogramsForcePerMeter, KilogramsForcePerMeterTolerance);
+            AssertEx.EqualTolerance(KilonewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.KilonewtonsPerMeter, KilonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(MeganewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.MeganewtonsPerMeter, MeganewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(MicronewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.MicronewtonsPerMeter, MicronewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(MillinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.MillinewtonsPerMeter, MillinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(NanonewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.NanonewtonsPerMeter, NanonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(NewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(PoundsForcePerFootInOneNewtonPerMeter, newtonpermeter.PoundsForcePerFoot, PoundsForcePerFootTolerance);
+            AssertEx.EqualTolerance(PoundsForcePerInchInOneNewtonPerMeter, newtonpermeter.PoundsForcePerInch, PoundsForcePerInchTolerance);
+            AssertEx.EqualTolerance(PoundsForcePerYardInOneNewtonPerMeter, newtonpermeter.PoundsForcePerYard, PoundsForcePerYardTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.CentinewtonPerMeter).CentinewtonsPerMeter, CentinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.DecinewtonPerMeter).DecinewtonsPerMeter, DecinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.KilogramForcePerMeter).KilogramsForcePerMeter, KilogramsForcePerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.KilonewtonPerMeter).KilonewtonsPerMeter, KilonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.MeganewtonPerMeter).MeganewtonsPerMeter, MeganewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.MicronewtonPerMeter).MicronewtonsPerMeter, MicronewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.MillinewtonPerMeter).MillinewtonsPerMeter, MillinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.NanonewtonPerMeter).NanonewtonsPerMeter, NanonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.NewtonPerMeter).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.PoundForcePerFoot).PoundsForcePerFoot, PoundsForcePerFootTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.PoundForcePerInch).PoundsForcePerInch, PoundsForcePerInchTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.From(1, ForcePerLengthUnit.PoundForcePerYard).PoundsForcePerYard, PoundsForcePerYardTolerance);
+        }
+
+        [Fact]
+        public void FromNewtonsPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ForcePerLength<double>.FromNewtonsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ForcePerLength<double>.FromNewtonsPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromNewtonsPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ForcePerLength<double>.FromNewtonsPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            AssertEx.EqualTolerance(CentinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.CentinewtonPerMeter), CentinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(DecinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.DecinewtonPerMeter), DecinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(KilogramsForcePerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.KilogramForcePerMeter), KilogramsForcePerMeterTolerance);
+            AssertEx.EqualTolerance(KilonewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.KilonewtonPerMeter), KilonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(MeganewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.MeganewtonPerMeter), MeganewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(MicronewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.MicronewtonPerMeter), MicronewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(MillinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.MillinewtonPerMeter), MillinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(NanonewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.NanonewtonPerMeter), NanonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(NewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.NewtonPerMeter), NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(PoundsForcePerFootInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.PoundForcePerFoot), PoundsForcePerFootTolerance);
+            AssertEx.EqualTolerance(PoundsForcePerInchInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.PoundForcePerInch), PoundsForcePerInchTolerance);
+            AssertEx.EqualTolerance(PoundsForcePerYardInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.PoundForcePerYard), PoundsForcePerYardTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+
+            var centinewtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.CentinewtonPerMeter);
+            AssertEx.EqualTolerance(CentinewtonsPerMeterInOneNewtonPerMeter, (double)centinewtonpermeterQuantity.Value, CentinewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.CentinewtonPerMeter, centinewtonpermeterQuantity.Unit);
+
+            var decinewtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.DecinewtonPerMeter);
+            AssertEx.EqualTolerance(DecinewtonsPerMeterInOneNewtonPerMeter, (double)decinewtonpermeterQuantity.Value, DecinewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.DecinewtonPerMeter, decinewtonpermeterQuantity.Unit);
+
+            var kilogramforcepermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.KilogramForcePerMeter);
+            AssertEx.EqualTolerance(KilogramsForcePerMeterInOneNewtonPerMeter, (double)kilogramforcepermeterQuantity.Value, KilogramsForcePerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.KilogramForcePerMeter, kilogramforcepermeterQuantity.Unit);
+
+            var kilonewtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.KilonewtonPerMeter);
+            AssertEx.EqualTolerance(KilonewtonsPerMeterInOneNewtonPerMeter, (double)kilonewtonpermeterQuantity.Value, KilonewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.KilonewtonPerMeter, kilonewtonpermeterQuantity.Unit);
+
+            var meganewtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.MeganewtonPerMeter);
+            AssertEx.EqualTolerance(MeganewtonsPerMeterInOneNewtonPerMeter, (double)meganewtonpermeterQuantity.Value, MeganewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.MeganewtonPerMeter, meganewtonpermeterQuantity.Unit);
+
+            var micronewtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.MicronewtonPerMeter);
+            AssertEx.EqualTolerance(MicronewtonsPerMeterInOneNewtonPerMeter, (double)micronewtonpermeterQuantity.Value, MicronewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.MicronewtonPerMeter, micronewtonpermeterQuantity.Unit);
+
+            var millinewtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.MillinewtonPerMeter);
+            AssertEx.EqualTolerance(MillinewtonsPerMeterInOneNewtonPerMeter, (double)millinewtonpermeterQuantity.Value, MillinewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.MillinewtonPerMeter, millinewtonpermeterQuantity.Unit);
+
+            var nanonewtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.NanonewtonPerMeter);
+            AssertEx.EqualTolerance(NanonewtonsPerMeterInOneNewtonPerMeter, (double)nanonewtonpermeterQuantity.Value, NanonewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.NanonewtonPerMeter, nanonewtonpermeterQuantity.Unit);
+
+            var newtonpermeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.NewtonPerMeter);
+            AssertEx.EqualTolerance(NewtonsPerMeterInOneNewtonPerMeter, (double)newtonpermeterQuantity.Value, NewtonsPerMeterTolerance);
+            Assert.Equal(ForcePerLengthUnit.NewtonPerMeter, newtonpermeterQuantity.Unit);
+
+            var poundforceperfootQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.PoundForcePerFoot);
+            AssertEx.EqualTolerance(PoundsForcePerFootInOneNewtonPerMeter, (double)poundforceperfootQuantity.Value, PoundsForcePerFootTolerance);
+            Assert.Equal(ForcePerLengthUnit.PoundForcePerFoot, poundforceperfootQuantity.Unit);
+
+            var poundforceperinchQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.PoundForcePerInch);
+            AssertEx.EqualTolerance(PoundsForcePerInchInOneNewtonPerMeter, (double)poundforceperinchQuantity.Value, PoundsForcePerInchTolerance);
+            Assert.Equal(ForcePerLengthUnit.PoundForcePerInch, poundforceperinchQuantity.Unit);
+
+            var poundforceperyardQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.PoundForcePerYard);
+            AssertEx.EqualTolerance(PoundsForcePerYardInOneNewtonPerMeter, (double)poundforceperyardQuantity.Value, PoundsForcePerYardTolerance);
+            Assert.Equal(ForcePerLengthUnit.PoundForcePerYard, poundforceperyardQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromCentinewtonsPerMeter(newtonpermeter.CentinewtonsPerMeter).NewtonsPerMeter, CentinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromDecinewtonsPerMeter(newtonpermeter.DecinewtonsPerMeter).NewtonsPerMeter, DecinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilogramsForcePerMeter(newtonpermeter.KilogramsForcePerMeter).NewtonsPerMeter, KilogramsForcePerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilonewtonsPerMeter(newtonpermeter.KilonewtonsPerMeter).NewtonsPerMeter, KilonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMeganewtonsPerMeter(newtonpermeter.MeganewtonsPerMeter).NewtonsPerMeter, MeganewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMicronewtonsPerMeter(newtonpermeter.MicronewtonsPerMeter).NewtonsPerMeter, MicronewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMillinewtonsPerMeter(newtonpermeter.MillinewtonsPerMeter).NewtonsPerMeter, MillinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNanonewtonsPerMeter(newtonpermeter.NanonewtonsPerMeter).NewtonsPerMeter, NanonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNewtonsPerMeter(newtonpermeter.NewtonsPerMeter).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromPoundsForcePerFoot(newtonpermeter.PoundsForcePerFoot).NewtonsPerMeter, PoundsForcePerFootTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromPoundsForcePerInch(newtonpermeter.PoundsForcePerInch).NewtonsPerMeter, PoundsForcePerInchTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromPoundsForcePerYard(newtonpermeter.PoundsForcePerYard).NewtonsPerMeter, PoundsForcePerYardTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ForcePerLength<double> v = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ForcePerLength<double>.FromNewtonsPerMeter(3)-v).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ForcePerLength<double>.FromNewtonsPerMeter(10)/5).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, ForcePerLength<double>.FromNewtonsPerMeter(10)/ForcePerLength<double>.FromNewtonsPerMeter(5), NewtonsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ForcePerLength<double> oneNewtonPerMeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            ForcePerLength<double> twoNewtonsPerMeter = ForcePerLength<double>.FromNewtonsPerMeter(2);
+
+            Assert.True(oneNewtonPerMeter < twoNewtonsPerMeter);
+            Assert.True(oneNewtonPerMeter <= twoNewtonsPerMeter);
+            Assert.True(twoNewtonsPerMeter > oneNewtonPerMeter);
+            Assert.True(twoNewtonsPerMeter >= oneNewtonPerMeter);
+
+            Assert.False(oneNewtonPerMeter > twoNewtonsPerMeter);
+            Assert.False(oneNewtonPerMeter >= twoNewtonsPerMeter);
+            Assert.False(twoNewtonsPerMeter < oneNewtonPerMeter);
+            Assert.False(twoNewtonsPerMeter <= oneNewtonPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            Assert.Equal(0, newtonpermeter.CompareTo(newtonpermeter));
+            Assert.True(newtonpermeter.CompareTo(ForcePerLength<double>.Zero) > 0);
+            Assert.True(ForcePerLength<double>.Zero.CompareTo(newtonpermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            Assert.Throws<ArgumentException>(() => newtonpermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => newtonpermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            var b = ForcePerLength<double>.FromNewtonsPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            var b = ForcePerLength<double>.FromNewtonsPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            Assert.True(v.Equals(ForcePerLength<double>.FromNewtonsPerMeter(1), NewtonsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ForcePerLength<double>.Zero, NewtonsPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            Assert.False(newtonpermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            Assert.False(newtonpermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ForcePerLengthUnit.Undefined, ForcePerLength<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ForcePerLengthUnit)).Cast<ForcePerLengthUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ForcePerLengthUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ForcePerLength<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs
new file mode 100644
index 0000000000..a0a63418ac
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs
@@ -0,0 +1,363 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Force.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ForceTestsBase
+    {
+        protected abstract double DecanewtonsInOneNewton { get; }
+        protected abstract double DyneInOneNewton { get; }
+        protected abstract double KilogramsForceInOneNewton { get; }
+        protected abstract double KilonewtonsInOneNewton { get; }
+        protected abstract double KiloPondsInOneNewton { get; }
+        protected abstract double MeganewtonsInOneNewton { get; }
+        protected abstract double MicronewtonsInOneNewton { get; }
+        protected abstract double MillinewtonsInOneNewton { get; }
+        protected abstract double NewtonsInOneNewton { get; }
+        protected abstract double OunceForceInOneNewton { get; }
+        protected abstract double PoundalsInOneNewton { get; }
+        protected abstract double PoundsForceInOneNewton { get; }
+        protected abstract double TonnesForceInOneNewton { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DecanewtonsTolerance { get { return 1e-5; } }
+        protected virtual double DyneTolerance { get { return 1e-5; } }
+        protected virtual double KilogramsForceTolerance { get { return 1e-5; } }
+        protected virtual double KilonewtonsTolerance { get { return 1e-5; } }
+        protected virtual double KiloPondsTolerance { get { return 1e-5; } }
+        protected virtual double MeganewtonsTolerance { get { return 1e-5; } }
+        protected virtual double MicronewtonsTolerance { get { return 1e-5; } }
+        protected virtual double MillinewtonsTolerance { get { return 1e-5; } }
+        protected virtual double NewtonsTolerance { get { return 1e-5; } }
+        protected virtual double OunceForceTolerance { get { return 1e-5; } }
+        protected virtual double PoundalsTolerance { get { return 1e-5; } }
+        protected virtual double PoundsForceTolerance { get { return 1e-5; } }
+        protected virtual double TonnesForceTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Force<double>((double)0.0, ForceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Force<double>(double.PositiveInfinity, ForceUnit.Newton));
+            Assert.Throws<ArgumentException>(() => new Force<double>(double.NegativeInfinity, ForceUnit.Newton));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Force<double>(double.NaN, ForceUnit.Newton));
+        }
+
+        [Fact]
+        public void NewtonToForceUnits()
+        {
+            Force<double> newton = Force<double>.FromNewtons(1);
+            AssertEx.EqualTolerance(DecanewtonsInOneNewton, newton.Decanewtons, DecanewtonsTolerance);
+            AssertEx.EqualTolerance(DyneInOneNewton, newton.Dyne, DyneTolerance);
+            AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.KilogramsForce, KilogramsForceTolerance);
+            AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.Kilonewtons, KilonewtonsTolerance);
+            AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.KiloPonds, KiloPondsTolerance);
+            AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.Meganewtons, MeganewtonsTolerance);
+            AssertEx.EqualTolerance(MicronewtonsInOneNewton, newton.Micronewtons, MicronewtonsTolerance);
+            AssertEx.EqualTolerance(MillinewtonsInOneNewton, newton.Millinewtons, MillinewtonsTolerance);
+            AssertEx.EqualTolerance(NewtonsInOneNewton, newton.Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(OunceForceInOneNewton, newton.OunceForce, OunceForceTolerance);
+            AssertEx.EqualTolerance(PoundalsInOneNewton, newton.Poundals, PoundalsTolerance);
+            AssertEx.EqualTolerance(PoundsForceInOneNewton, newton.PoundsForce, PoundsForceTolerance);
+            AssertEx.EqualTolerance(TonnesForceInOneNewton, newton.TonnesForce, TonnesForceTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Decanewton).Decanewtons, DecanewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Dyn).Dyne, DyneTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.KilogramForce).KilogramsForce, KilogramsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Kilonewton).Kilonewtons, KilonewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.KiloPond).KiloPonds, KiloPondsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Meganewton).Meganewtons, MeganewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Micronewton).Micronewtons, MicronewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Millinewton).Millinewtons, MillinewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Newton).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.OunceForce).OunceForce, OunceForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.Poundal).Poundals, PoundalsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.PoundForce).PoundsForce, PoundsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.From(1, ForceUnit.TonneForce).TonnesForce, TonnesForceTolerance);
+        }
+
+        [Fact]
+        public void FromNewtons_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Force<double>.FromNewtons(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Force<double>.FromNewtons(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromNewtons_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Force<double>.FromNewtons(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var newton = Force<double>.FromNewtons(1);
+            AssertEx.EqualTolerance(DecanewtonsInOneNewton, newton.As(ForceUnit.Decanewton), DecanewtonsTolerance);
+            AssertEx.EqualTolerance(DyneInOneNewton, newton.As(ForceUnit.Dyn), DyneTolerance);
+            AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.As(ForceUnit.KilogramForce), KilogramsForceTolerance);
+            AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.As(ForceUnit.Kilonewton), KilonewtonsTolerance);
+            AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.As(ForceUnit.KiloPond), KiloPondsTolerance);
+            AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.As(ForceUnit.Meganewton), MeganewtonsTolerance);
+            AssertEx.EqualTolerance(MicronewtonsInOneNewton, newton.As(ForceUnit.Micronewton), MicronewtonsTolerance);
+            AssertEx.EqualTolerance(MillinewtonsInOneNewton, newton.As(ForceUnit.Millinewton), MillinewtonsTolerance);
+            AssertEx.EqualTolerance(NewtonsInOneNewton, newton.As(ForceUnit.Newton), NewtonsTolerance);
+            AssertEx.EqualTolerance(OunceForceInOneNewton, newton.As(ForceUnit.OunceForce), OunceForceTolerance);
+            AssertEx.EqualTolerance(PoundalsInOneNewton, newton.As(ForceUnit.Poundal), PoundalsTolerance);
+            AssertEx.EqualTolerance(PoundsForceInOneNewton, newton.As(ForceUnit.PoundForce), PoundsForceTolerance);
+            AssertEx.EqualTolerance(TonnesForceInOneNewton, newton.As(ForceUnit.TonneForce), TonnesForceTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var newton = Force<double>.FromNewtons(1);
+
+            var decanewtonQuantity = newton.ToUnit(ForceUnit.Decanewton);
+            AssertEx.EqualTolerance(DecanewtonsInOneNewton, (double)decanewtonQuantity.Value, DecanewtonsTolerance);
+            Assert.Equal(ForceUnit.Decanewton, decanewtonQuantity.Unit);
+
+            var dynQuantity = newton.ToUnit(ForceUnit.Dyn);
+            AssertEx.EqualTolerance(DyneInOneNewton, (double)dynQuantity.Value, DyneTolerance);
+            Assert.Equal(ForceUnit.Dyn, dynQuantity.Unit);
+
+            var kilogramforceQuantity = newton.ToUnit(ForceUnit.KilogramForce);
+            AssertEx.EqualTolerance(KilogramsForceInOneNewton, (double)kilogramforceQuantity.Value, KilogramsForceTolerance);
+            Assert.Equal(ForceUnit.KilogramForce, kilogramforceQuantity.Unit);
+
+            var kilonewtonQuantity = newton.ToUnit(ForceUnit.Kilonewton);
+            AssertEx.EqualTolerance(KilonewtonsInOneNewton, (double)kilonewtonQuantity.Value, KilonewtonsTolerance);
+            Assert.Equal(ForceUnit.Kilonewton, kilonewtonQuantity.Unit);
+
+            var kilopondQuantity = newton.ToUnit(ForceUnit.KiloPond);
+            AssertEx.EqualTolerance(KiloPondsInOneNewton, (double)kilopondQuantity.Value, KiloPondsTolerance);
+            Assert.Equal(ForceUnit.KiloPond, kilopondQuantity.Unit);
+
+            var meganewtonQuantity = newton.ToUnit(ForceUnit.Meganewton);
+            AssertEx.EqualTolerance(MeganewtonsInOneNewton, (double)meganewtonQuantity.Value, MeganewtonsTolerance);
+            Assert.Equal(ForceUnit.Meganewton, meganewtonQuantity.Unit);
+
+            var micronewtonQuantity = newton.ToUnit(ForceUnit.Micronewton);
+            AssertEx.EqualTolerance(MicronewtonsInOneNewton, (double)micronewtonQuantity.Value, MicronewtonsTolerance);
+            Assert.Equal(ForceUnit.Micronewton, micronewtonQuantity.Unit);
+
+            var millinewtonQuantity = newton.ToUnit(ForceUnit.Millinewton);
+            AssertEx.EqualTolerance(MillinewtonsInOneNewton, (double)millinewtonQuantity.Value, MillinewtonsTolerance);
+            Assert.Equal(ForceUnit.Millinewton, millinewtonQuantity.Unit);
+
+            var newtonQuantity = newton.ToUnit(ForceUnit.Newton);
+            AssertEx.EqualTolerance(NewtonsInOneNewton, (double)newtonQuantity.Value, NewtonsTolerance);
+            Assert.Equal(ForceUnit.Newton, newtonQuantity.Unit);
+
+            var ounceforceQuantity = newton.ToUnit(ForceUnit.OunceForce);
+            AssertEx.EqualTolerance(OunceForceInOneNewton, (double)ounceforceQuantity.Value, OunceForceTolerance);
+            Assert.Equal(ForceUnit.OunceForce, ounceforceQuantity.Unit);
+
+            var poundalQuantity = newton.ToUnit(ForceUnit.Poundal);
+            AssertEx.EqualTolerance(PoundalsInOneNewton, (double)poundalQuantity.Value, PoundalsTolerance);
+            Assert.Equal(ForceUnit.Poundal, poundalQuantity.Unit);
+
+            var poundforceQuantity = newton.ToUnit(ForceUnit.PoundForce);
+            AssertEx.EqualTolerance(PoundsForceInOneNewton, (double)poundforceQuantity.Value, PoundsForceTolerance);
+            Assert.Equal(ForceUnit.PoundForce, poundforceQuantity.Unit);
+
+            var tonneforceQuantity = newton.ToUnit(ForceUnit.TonneForce);
+            AssertEx.EqualTolerance(TonnesForceInOneNewton, (double)tonneforceQuantity.Value, TonnesForceTolerance);
+            Assert.Equal(ForceUnit.TonneForce, tonneforceQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Force<double> newton = Force<double>.FromNewtons(1);
+            AssertEx.EqualTolerance(1, Force<double>.FromDecanewtons(newton.Decanewtons).Newtons, DecanewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromDyne(newton.Dyne).Newtons, DyneTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromKilogramsForce(newton.KilogramsForce).Newtons, KilogramsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromKilonewtons(newton.Kilonewtons).Newtons, KilonewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromKiloPonds(newton.KiloPonds).Newtons, KiloPondsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromMeganewtons(newton.Meganewtons).Newtons, MeganewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromMicronewtons(newton.Micronewtons).Newtons, MicronewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromMillinewtons(newton.Millinewtons).Newtons, MillinewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromNewtons(newton.Newtons).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromOunceForce(newton.OunceForce).Newtons, OunceForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromPoundals(newton.Poundals).Newtons, PoundalsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromPoundsForce(newton.PoundsForce).Newtons, PoundsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromTonnesForce(newton.TonnesForce).Newtons, TonnesForceTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Force<double> v = Force<double>.FromNewtons(1);
+            AssertEx.EqualTolerance(-1, -v.Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(2, (Force<double>.FromNewtons(3)-v).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(2, (Force<double>.FromNewtons(10)/5).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(2, Force<double>.FromNewtons(10)/Force<double>.FromNewtons(5), NewtonsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Force<double> oneNewton = Force<double>.FromNewtons(1);
+            Force<double> twoNewtons = Force<double>.FromNewtons(2);
+
+            Assert.True(oneNewton < twoNewtons);
+            Assert.True(oneNewton <= twoNewtons);
+            Assert.True(twoNewtons > oneNewton);
+            Assert.True(twoNewtons >= oneNewton);
+
+            Assert.False(oneNewton > twoNewtons);
+            Assert.False(oneNewton >= twoNewtons);
+            Assert.False(twoNewtons < oneNewton);
+            Assert.False(twoNewtons <= oneNewton);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Force<double> newton = Force<double>.FromNewtons(1);
+            Assert.Equal(0, newton.CompareTo(newton));
+            Assert.True(newton.CompareTo(Force<double>.Zero) > 0);
+            Assert.True(Force<double>.Zero.CompareTo(newton) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Force<double> newton = Force<double>.FromNewtons(1);
+            Assert.Throws<ArgumentException>(() => newton.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Force<double> newton = Force<double>.FromNewtons(1);
+            Assert.Throws<ArgumentNullException>(() => newton.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Force<double>.FromNewtons(1);
+            var b = Force<double>.FromNewtons(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Force<double>.FromNewtons(1);
+            var b = Force<double>.FromNewtons(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Force<double>.FromNewtons(1);
+            Assert.True(v.Equals(Force<double>.FromNewtons(1), NewtonsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Force<double>.Zero, NewtonsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Force<double> newton = Force<double>.FromNewtons(1);
+            Assert.False(newton.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Force<double> newton = Force<double>.FromNewtons(1);
+            Assert.False(newton.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ForceUnit.Undefined, Force<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ForceUnit)).Cast<ForceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ForceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Force<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
new file mode 100644
index 0000000000..ac64205b6a
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
@@ -0,0 +1,323 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Frequency.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class FrequencyTestsBase
+    {
+        protected abstract double BeatsPerMinuteInOneHertz { get; }
+        protected abstract double CyclesPerHourInOneHertz { get; }
+        protected abstract double CyclesPerMinuteInOneHertz { get; }
+        protected abstract double GigahertzInOneHertz { get; }
+        protected abstract double HertzInOneHertz { get; }
+        protected abstract double KilohertzInOneHertz { get; }
+        protected abstract double MegahertzInOneHertz { get; }
+        protected abstract double RadiansPerSecondInOneHertz { get; }
+        protected abstract double TerahertzInOneHertz { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double BeatsPerMinuteTolerance { get { return 1e-5; } }
+        protected virtual double CyclesPerHourTolerance { get { return 1e-5; } }
+        protected virtual double CyclesPerMinuteTolerance { get { return 1e-5; } }
+        protected virtual double GigahertzTolerance { get { return 1e-5; } }
+        protected virtual double HertzTolerance { get { return 1e-5; } }
+        protected virtual double KilohertzTolerance { get { return 1e-5; } }
+        protected virtual double MegahertzTolerance { get { return 1e-5; } }
+        protected virtual double RadiansPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double TerahertzTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Frequency<double>((double)0.0, FrequencyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Frequency<double>(double.PositiveInfinity, FrequencyUnit.Hertz));
+            Assert.Throws<ArgumentException>(() => new Frequency<double>(double.NegativeInfinity, FrequencyUnit.Hertz));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Frequency<double>(double.NaN, FrequencyUnit.Hertz));
+        }
+
+        [Fact]
+        public void HertzToFrequencyUnits()
+        {
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            AssertEx.EqualTolerance(BeatsPerMinuteInOneHertz, hertz.BeatsPerMinute, BeatsPerMinuteTolerance);
+            AssertEx.EqualTolerance(CyclesPerHourInOneHertz, hertz.CyclesPerHour, CyclesPerHourTolerance);
+            AssertEx.EqualTolerance(CyclesPerMinuteInOneHertz, hertz.CyclesPerMinute, CyclesPerMinuteTolerance);
+            AssertEx.EqualTolerance(GigahertzInOneHertz, hertz.Gigahertz, GigahertzTolerance);
+            AssertEx.EqualTolerance(HertzInOneHertz, hertz.Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(KilohertzInOneHertz, hertz.Kilohertz, KilohertzTolerance);
+            AssertEx.EqualTolerance(MegahertzInOneHertz, hertz.Megahertz, MegahertzTolerance);
+            AssertEx.EqualTolerance(RadiansPerSecondInOneHertz, hertz.RadiansPerSecond, RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(TerahertzInOneHertz, hertz.Terahertz, TerahertzTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.BeatPerMinute).BeatsPerMinute, BeatsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.CyclePerHour).CyclesPerHour, CyclesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.CyclePerMinute).CyclesPerMinute, CyclesPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.Gigahertz).Gigahertz, GigahertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.Hertz).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.Kilohertz).Kilohertz, KilohertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.Megahertz).Megahertz, MegahertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.RadianPerSecond).RadiansPerSecond, RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.From(1, FrequencyUnit.Terahertz).Terahertz, TerahertzTolerance);
+        }
+
+        [Fact]
+        public void FromHertz_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Frequency<double>.FromHertz(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Frequency<double>.FromHertz(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromHertz_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Frequency<double>.FromHertz(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var hertz = Frequency<double>.FromHertz(1);
+            AssertEx.EqualTolerance(BeatsPerMinuteInOneHertz, hertz.As(FrequencyUnit.BeatPerMinute), BeatsPerMinuteTolerance);
+            AssertEx.EqualTolerance(CyclesPerHourInOneHertz, hertz.As(FrequencyUnit.CyclePerHour), CyclesPerHourTolerance);
+            AssertEx.EqualTolerance(CyclesPerMinuteInOneHertz, hertz.As(FrequencyUnit.CyclePerMinute), CyclesPerMinuteTolerance);
+            AssertEx.EqualTolerance(GigahertzInOneHertz, hertz.As(FrequencyUnit.Gigahertz), GigahertzTolerance);
+            AssertEx.EqualTolerance(HertzInOneHertz, hertz.As(FrequencyUnit.Hertz), HertzTolerance);
+            AssertEx.EqualTolerance(KilohertzInOneHertz, hertz.As(FrequencyUnit.Kilohertz), KilohertzTolerance);
+            AssertEx.EqualTolerance(MegahertzInOneHertz, hertz.As(FrequencyUnit.Megahertz), MegahertzTolerance);
+            AssertEx.EqualTolerance(RadiansPerSecondInOneHertz, hertz.As(FrequencyUnit.RadianPerSecond), RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(TerahertzInOneHertz, hertz.As(FrequencyUnit.Terahertz), TerahertzTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var hertz = Frequency<double>.FromHertz(1);
+
+            var beatperminuteQuantity = hertz.ToUnit(FrequencyUnit.BeatPerMinute);
+            AssertEx.EqualTolerance(BeatsPerMinuteInOneHertz, (double)beatperminuteQuantity.Value, BeatsPerMinuteTolerance);
+            Assert.Equal(FrequencyUnit.BeatPerMinute, beatperminuteQuantity.Unit);
+
+            var cycleperhourQuantity = hertz.ToUnit(FrequencyUnit.CyclePerHour);
+            AssertEx.EqualTolerance(CyclesPerHourInOneHertz, (double)cycleperhourQuantity.Value, CyclesPerHourTolerance);
+            Assert.Equal(FrequencyUnit.CyclePerHour, cycleperhourQuantity.Unit);
+
+            var cycleperminuteQuantity = hertz.ToUnit(FrequencyUnit.CyclePerMinute);
+            AssertEx.EqualTolerance(CyclesPerMinuteInOneHertz, (double)cycleperminuteQuantity.Value, CyclesPerMinuteTolerance);
+            Assert.Equal(FrequencyUnit.CyclePerMinute, cycleperminuteQuantity.Unit);
+
+            var gigahertzQuantity = hertz.ToUnit(FrequencyUnit.Gigahertz);
+            AssertEx.EqualTolerance(GigahertzInOneHertz, (double)gigahertzQuantity.Value, GigahertzTolerance);
+            Assert.Equal(FrequencyUnit.Gigahertz, gigahertzQuantity.Unit);
+
+            var hertzQuantity = hertz.ToUnit(FrequencyUnit.Hertz);
+            AssertEx.EqualTolerance(HertzInOneHertz, (double)hertzQuantity.Value, HertzTolerance);
+            Assert.Equal(FrequencyUnit.Hertz, hertzQuantity.Unit);
+
+            var kilohertzQuantity = hertz.ToUnit(FrequencyUnit.Kilohertz);
+            AssertEx.EqualTolerance(KilohertzInOneHertz, (double)kilohertzQuantity.Value, KilohertzTolerance);
+            Assert.Equal(FrequencyUnit.Kilohertz, kilohertzQuantity.Unit);
+
+            var megahertzQuantity = hertz.ToUnit(FrequencyUnit.Megahertz);
+            AssertEx.EqualTolerance(MegahertzInOneHertz, (double)megahertzQuantity.Value, MegahertzTolerance);
+            Assert.Equal(FrequencyUnit.Megahertz, megahertzQuantity.Unit);
+
+            var radianpersecondQuantity = hertz.ToUnit(FrequencyUnit.RadianPerSecond);
+            AssertEx.EqualTolerance(RadiansPerSecondInOneHertz, (double)radianpersecondQuantity.Value, RadiansPerSecondTolerance);
+            Assert.Equal(FrequencyUnit.RadianPerSecond, radianpersecondQuantity.Unit);
+
+            var terahertzQuantity = hertz.ToUnit(FrequencyUnit.Terahertz);
+            AssertEx.EqualTolerance(TerahertzInOneHertz, (double)terahertzQuantity.Value, TerahertzTolerance);
+            Assert.Equal(FrequencyUnit.Terahertz, terahertzQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromBeatsPerMinute(hertz.BeatsPerMinute).Hertz, BeatsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromCyclesPerHour(hertz.CyclesPerHour).Hertz, CyclesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromCyclesPerMinute(hertz.CyclesPerMinute).Hertz, CyclesPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromGigahertz(hertz.Gigahertz).Hertz, GigahertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromHertz(hertz.Hertz).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromKilohertz(hertz.Kilohertz).Hertz, KilohertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromMegahertz(hertz.Megahertz).Hertz, MegahertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromRadiansPerSecond(hertz.RadiansPerSecond).Hertz, RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromTerahertz(hertz.Terahertz).Hertz, TerahertzTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Frequency<double> v = Frequency<double>.FromHertz(1);
+            AssertEx.EqualTolerance(-1, -v.Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(2, (Frequency<double>.FromHertz(3)-v).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(2, (Frequency<double>.FromHertz(10)/5).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(2, Frequency<double>.FromHertz(10)/Frequency<double>.FromHertz(5), HertzTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Frequency<double> oneHertz = Frequency<double>.FromHertz(1);
+            Frequency<double> twoHertz = Frequency<double>.FromHertz(2);
+
+            Assert.True(oneHertz < twoHertz);
+            Assert.True(oneHertz <= twoHertz);
+            Assert.True(twoHertz > oneHertz);
+            Assert.True(twoHertz >= oneHertz);
+
+            Assert.False(oneHertz > twoHertz);
+            Assert.False(oneHertz >= twoHertz);
+            Assert.False(twoHertz < oneHertz);
+            Assert.False(twoHertz <= oneHertz);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            Assert.Equal(0, hertz.CompareTo(hertz));
+            Assert.True(hertz.CompareTo(Frequency<double>.Zero) > 0);
+            Assert.True(Frequency<double>.Zero.CompareTo(hertz) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            Assert.Throws<ArgumentException>(() => hertz.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            Assert.Throws<ArgumentNullException>(() => hertz.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Frequency<double>.FromHertz(1);
+            var b = Frequency<double>.FromHertz(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Frequency<double>.FromHertz(1);
+            var b = Frequency<double>.FromHertz(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Frequency<double>.FromHertz(1);
+            Assert.True(v.Equals(Frequency<double>.FromHertz(1), HertzTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Frequency<double>.Zero, HertzTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            Assert.False(hertz.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            Assert.False(hertz.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(FrequencyUnit.Undefined, Frequency<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(FrequencyUnit)).Cast<FrequencyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == FrequencyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Frequency<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/FuelEfficiencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FuelEfficiencyTestsBase.g.cs
new file mode 100644
index 0000000000..3060eddcb3
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/FuelEfficiencyTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of FuelEfficiency.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class FuelEfficiencyTestsBase
+    {
+        protected abstract double KilometersPerLitersInOneLiterPer100Kilometers { get; }
+        protected abstract double LitersPer100KilometersInOneLiterPer100Kilometers { get; }
+        protected abstract double MilesPerUkGallonInOneLiterPer100Kilometers { get; }
+        protected abstract double MilesPerUsGallonInOneLiterPer100Kilometers { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilometersPerLitersTolerance { get { return 1e-5; } }
+        protected virtual double LitersPer100KilometersTolerance { get { return 1e-5; } }
+        protected virtual double MilesPerUkGallonTolerance { get { return 1e-5; } }
+        protected virtual double MilesPerUsGallonTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>((double)0.0, FuelEfficiencyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>(double.PositiveInfinity, FuelEfficiencyUnit.LiterPer100Kilometers));
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>(double.NegativeInfinity, FuelEfficiencyUnit.LiterPer100Kilometers));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>(double.NaN, FuelEfficiencyUnit.LiterPer100Kilometers));
+        }
+
+        [Fact]
+        public void LiterPer100KilometersToFuelEfficiencyUnits()
+        {
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, literper100kilometers.KilometersPerLiters, KilometersPerLitersTolerance);
+            AssertEx.EqualTolerance(LitersPer100KilometersInOneLiterPer100Kilometers, literper100kilometers.LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(MilesPerUkGallonInOneLiterPer100Kilometers, literper100kilometers.MilesPerUkGallon, MilesPerUkGallonTolerance);
+            AssertEx.EqualTolerance(MilesPerUsGallonInOneLiterPer100Kilometers, literper100kilometers.MilesPerUsGallon, MilesPerUsGallonTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.From(1, FuelEfficiencyUnit.KilometerPerLiter).KilometersPerLiters, KilometersPerLitersTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.From(1, FuelEfficiencyUnit.LiterPer100Kilometers).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.From(1, FuelEfficiencyUnit.MilePerUkGallon).MilesPerUkGallon, MilesPerUkGallonTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.From(1, FuelEfficiencyUnit.MilePerUsGallon).MilesPerUsGallon, MilesPerUsGallonTolerance);
+        }
+
+        [Fact]
+        public void FromLitersPer100Kilometers_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => FuelEfficiency<double>.FromLitersPer100Kilometers(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => FuelEfficiency<double>.FromLitersPer100Kilometers(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromLitersPer100Kilometers_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => FuelEfficiency<double>.FromLitersPer100Kilometers(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.KilometerPerLiter), KilometersPerLitersTolerance);
+            AssertEx.EqualTolerance(LitersPer100KilometersInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.LiterPer100Kilometers), LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(MilesPerUkGallonInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.MilePerUkGallon), MilesPerUkGallonTolerance);
+            AssertEx.EqualTolerance(MilesPerUsGallonInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.MilePerUsGallon), MilesPerUsGallonTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+
+            var kilometerperliterQuantity = literper100kilometers.ToUnit(FuelEfficiencyUnit.KilometerPerLiter);
+            AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, (double)kilometerperliterQuantity.Value, KilometersPerLitersTolerance);
+            Assert.Equal(FuelEfficiencyUnit.KilometerPerLiter, kilometerperliterQuantity.Unit);
+
+            var literper100kilometersQuantity = literper100kilometers.ToUnit(FuelEfficiencyUnit.LiterPer100Kilometers);
+            AssertEx.EqualTolerance(LitersPer100KilometersInOneLiterPer100Kilometers, (double)literper100kilometersQuantity.Value, LitersPer100KilometersTolerance);
+            Assert.Equal(FuelEfficiencyUnit.LiterPer100Kilometers, literper100kilometersQuantity.Unit);
+
+            var mileperukgallonQuantity = literper100kilometers.ToUnit(FuelEfficiencyUnit.MilePerUkGallon);
+            AssertEx.EqualTolerance(MilesPerUkGallonInOneLiterPer100Kilometers, (double)mileperukgallonQuantity.Value, MilesPerUkGallonTolerance);
+            Assert.Equal(FuelEfficiencyUnit.MilePerUkGallon, mileperukgallonQuantity.Unit);
+
+            var mileperusgallonQuantity = literper100kilometers.ToUnit(FuelEfficiencyUnit.MilePerUsGallon);
+            AssertEx.EqualTolerance(MilesPerUsGallonInOneLiterPer100Kilometers, (double)mileperusgallonQuantity.Value, MilesPerUsGallonTolerance);
+            Assert.Equal(FuelEfficiencyUnit.MilePerUsGallon, mileperusgallonQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromKilometersPerLiters(literper100kilometers.KilometersPerLiters).LitersPer100Kilometers, KilometersPerLitersTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromLitersPer100Kilometers(literper100kilometers.LitersPer100Kilometers).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromMilesPerUkGallon(literper100kilometers.MilesPerUkGallon).LitersPer100Kilometers, MilesPerUkGallonTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromMilesPerUsGallon(literper100kilometers.MilesPerUsGallon).LitersPer100Kilometers, MilesPerUsGallonTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            FuelEfficiency<double> v = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            AssertEx.EqualTolerance(-1, -v.LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(2, (FuelEfficiency<double>.FromLitersPer100Kilometers(3)-v).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(2, (v + v).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(10, (v*10).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(10, (10*v).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(2, (FuelEfficiency<double>.FromLitersPer100Kilometers(10)/5).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(2, FuelEfficiency<double>.FromLitersPer100Kilometers(10)/FuelEfficiency<double>.FromLitersPer100Kilometers(5), LitersPer100KilometersTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            FuelEfficiency<double> oneLiterPer100Kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> twoLitersPer100Kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(2);
+
+            Assert.True(oneLiterPer100Kilometers < twoLitersPer100Kilometers);
+            Assert.True(oneLiterPer100Kilometers <= twoLitersPer100Kilometers);
+            Assert.True(twoLitersPer100Kilometers > oneLiterPer100Kilometers);
+            Assert.True(twoLitersPer100Kilometers >= oneLiterPer100Kilometers);
+
+            Assert.False(oneLiterPer100Kilometers > twoLitersPer100Kilometers);
+            Assert.False(oneLiterPer100Kilometers >= twoLitersPer100Kilometers);
+            Assert.False(twoLitersPer100Kilometers < oneLiterPer100Kilometers);
+            Assert.False(twoLitersPer100Kilometers <= oneLiterPer100Kilometers);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            Assert.Equal(0, literper100kilometers.CompareTo(literper100kilometers));
+            Assert.True(literper100kilometers.CompareTo(FuelEfficiency<double>.Zero) > 0);
+            Assert.True(FuelEfficiency<double>.Zero.CompareTo(literper100kilometers) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            Assert.Throws<ArgumentException>(() => literper100kilometers.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            Assert.Throws<ArgumentNullException>(() => literper100kilometers.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            var b = FuelEfficiency<double>.FromLitersPer100Kilometers(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            var b = FuelEfficiency<double>.FromLitersPer100Kilometers(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            Assert.True(v.Equals(FuelEfficiency<double>.FromLitersPer100Kilometers(1), LitersPer100KilometersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(FuelEfficiency<double>.Zero, LitersPer100KilometersTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            Assert.False(literper100kilometers.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            Assert.False(literper100kilometers.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(FuelEfficiencyUnit.Undefined, FuelEfficiency<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(FuelEfficiencyUnit)).Cast<FuelEfficiencyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == FuelEfficiencyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(FuelEfficiency<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/HeatTransferCoefficientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/HeatTransferCoefficientTestsBase.g.cs
new file mode 100644
index 0000000000..ef09e22033
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/HeatTransferCoefficientTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of HeatTransferCoefficient.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class HeatTransferCoefficientTestsBase
+    {
+        protected abstract double BtusPerSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin { get; }
+        protected abstract double WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin { get; }
+        protected abstract double WattsPerSquareMeterKelvinInOneWattPerSquareMeterKelvin { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double BtusPerSquareFootDegreeFahrenheitTolerance { get { return 1e-5; } }
+        protected virtual double WattsPerSquareMeterCelsiusTolerance { get { return 1e-5; } }
+        protected virtual double WattsPerSquareMeterKelvinTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>((double)0.0, HeatTransferCoefficientUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>(double.PositiveInfinity, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>(double.NegativeInfinity, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>(double.NaN, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+        }
+
+        [Fact]
+        public void WattPerSquareMeterKelvinToHeatTransferCoefficientUnits()
+        {
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            AssertEx.EqualTolerance(BtusPerSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.BtusPerSquareFootDegreeFahrenheit, BtusPerSquareFootDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.WattsPerSquareMeterCelsius, WattsPerSquareMeterCelsiusTolerance);
+            AssertEx.EqualTolerance(WattsPerSquareMeterKelvinInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.From(1, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit).BtusPerSquareFootDegreeFahrenheit, BtusPerSquareFootDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.From(1, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius).WattsPerSquareMeterCelsius, WattsPerSquareMeterCelsiusTolerance);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.From(1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromWattsPerSquareMeterKelvin_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromWattsPerSquareMeterKelvin_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            AssertEx.EqualTolerance(BtusPerSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit), BtusPerSquareFootDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius), WattsPerSquareMeterCelsiusTolerance);
+            AssertEx.EqualTolerance(WattsPerSquareMeterKelvinInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin), WattsPerSquareMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+
+            var btupersquarefootdegreefahrenheitQuantity = wattpersquaremeterkelvin.ToUnit(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
+            AssertEx.EqualTolerance(BtusPerSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, (double)btupersquarefootdegreefahrenheitQuantity.Value, BtusPerSquareFootDegreeFahrenheitTolerance);
+            Assert.Equal(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, btupersquarefootdegreefahrenheitQuantity.Unit);
+
+            var wattpersquaremetercelsiusQuantity = wattpersquaremeterkelvin.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
+            AssertEx.EqualTolerance(WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, (double)wattpersquaremetercelsiusQuantity.Value, WattsPerSquareMeterCelsiusTolerance);
+            Assert.Equal(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, wattpersquaremetercelsiusQuantity.Unit);
+
+            var wattpersquaremeterkelvinQuantity = wattpersquaremeterkelvin.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
+            AssertEx.EqualTolerance(WattsPerSquareMeterKelvinInOneWattPerSquareMeterKelvin, (double)wattpersquaremeterkelvinQuantity.Value, WattsPerSquareMeterKelvinTolerance);
+            Assert.Equal(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, wattpersquaremeterkelvinQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.FromBtusPerSquareFootDegreeFahrenheit(wattpersquaremeterkelvin.BtusPerSquareFootDegreeFahrenheit).WattsPerSquareMeterKelvin, BtusPerSquareFootDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.FromWattsPerSquareMeterCelsius(wattpersquaremeterkelvin.WattsPerSquareMeterCelsius).WattsPerSquareMeterKelvin, WattsPerSquareMeterCelsiusTolerance);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(wattpersquaremeterkelvin.WattsPerSquareMeterKelvin).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            HeatTransferCoefficient<double> v = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            AssertEx.EqualTolerance(-1, -v.WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(3)-v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (v + v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(10, (v*10).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(10, (10*v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(10)/5).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(10)/HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(5), WattsPerSquareMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            HeatTransferCoefficient<double> oneWattPerSquareMeterKelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> twoWattsPerSquareMeterKelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(2);
+
+            Assert.True(oneWattPerSquareMeterKelvin < twoWattsPerSquareMeterKelvin);
+            Assert.True(oneWattPerSquareMeterKelvin <= twoWattsPerSquareMeterKelvin);
+            Assert.True(twoWattsPerSquareMeterKelvin > oneWattPerSquareMeterKelvin);
+            Assert.True(twoWattsPerSquareMeterKelvin >= oneWattPerSquareMeterKelvin);
+
+            Assert.False(oneWattPerSquareMeterKelvin > twoWattsPerSquareMeterKelvin);
+            Assert.False(oneWattPerSquareMeterKelvin >= twoWattsPerSquareMeterKelvin);
+            Assert.False(twoWattsPerSquareMeterKelvin < oneWattPerSquareMeterKelvin);
+            Assert.False(twoWattsPerSquareMeterKelvin <= oneWattPerSquareMeterKelvin);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            Assert.Equal(0, wattpersquaremeterkelvin.CompareTo(wattpersquaremeterkelvin));
+            Assert.True(wattpersquaremeterkelvin.CompareTo(HeatTransferCoefficient<double>.Zero) > 0);
+            Assert.True(HeatTransferCoefficient<double>.Zero.CompareTo(wattpersquaremeterkelvin) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            Assert.Throws<ArgumentException>(() => wattpersquaremeterkelvin.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            Assert.Throws<ArgumentNullException>(() => wattpersquaremeterkelvin.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            var b = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            var b = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            Assert.True(v.Equals(HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1), WattsPerSquareMeterKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(HeatTransferCoefficient<double>.Zero, WattsPerSquareMeterKelvinTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            Assert.False(wattpersquaremeterkelvin.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            Assert.False(wattpersquaremeterkelvin.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(HeatTransferCoefficientUnit.Undefined, HeatTransferCoefficient<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(HeatTransferCoefficientUnit)).Cast<HeatTransferCoefficientUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == HeatTransferCoefficientUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(HeatTransferCoefficient<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
index 7afaaf69e5..84ead37750 100644
--- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
@@ -34,110 +34,110 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
                 Assert.Equal(expectedValue, quantity.Value);
             }
 
-            Assertion(3, AccelerationUnit.StandardGravity, Quantity.From(3, AccelerationUnit.StandardGravity));
-            Assertion(3, AmountOfSubstanceUnit.PoundMole, Quantity.From(3, AmountOfSubstanceUnit.PoundMole));
-            Assertion(3, AmplitudeRatioUnit.DecibelVolt, Quantity.From(3, AmplitudeRatioUnit.DecibelVolt));
-            Assertion(3, AngleUnit.Revolution, Quantity.From(3, AngleUnit.Revolution));
-            Assertion(3, ApparentEnergyUnit.VoltampereHour, Quantity.From(3, ApparentEnergyUnit.VoltampereHour));
-            Assertion(3, ApparentPowerUnit.Voltampere, Quantity.From(3, ApparentPowerUnit.Voltampere));
-            Assertion(3, AreaUnit.UsSurveySquareFoot, Quantity.From(3, AreaUnit.UsSurveySquareFoot));
-            Assertion(3, AreaDensityUnit.KilogramPerSquareMeter, Quantity.From(3, AreaDensityUnit.KilogramPerSquareMeter));
-            Assertion(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth, Quantity.From(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth));
-            Assertion(3, BitRateUnit.TerabytePerSecond, Quantity.From(3, BitRateUnit.TerabytePerSecond));
-            Assertion(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, Quantity.From(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour));
-            Assertion(3, CapacitanceUnit.Picofarad, Quantity.From(3, CapacitanceUnit.Picofarad));
-            Assertion(3, CoefficientOfThermalExpansionUnit.InverseKelvin, Quantity.From(3, CoefficientOfThermalExpansionUnit.InverseKelvin));
-            Assertion(3, DensityUnit.TonnePerCubicMillimeter, Quantity.From(3, DensityUnit.TonnePerCubicMillimeter));
-            Assertion(3, DurationUnit.Year365, Quantity.From(3, DurationUnit.Year365));
-            Assertion(3, DynamicViscosityUnit.Reyn, Quantity.From(3, DynamicViscosityUnit.Reyn));
-            Assertion(3, ElectricAdmittanceUnit.Siemens, Quantity.From(3, ElectricAdmittanceUnit.Siemens));
-            Assertion(3, ElectricChargeUnit.MilliampereHour, Quantity.From(3, ElectricChargeUnit.MilliampereHour));
-            Assertion(3, ElectricChargeDensityUnit.CoulombPerCubicMeter, Quantity.From(3, ElectricChargeDensityUnit.CoulombPerCubicMeter));
-            Assertion(3, ElectricConductanceUnit.Siemens, Quantity.From(3, ElectricConductanceUnit.Siemens));
-            Assertion(3, ElectricConductivityUnit.SiemensPerMeter, Quantity.From(3, ElectricConductivityUnit.SiemensPerMeter));
-            Assertion(3, ElectricCurrentUnit.Picoampere, Quantity.From(3, ElectricCurrentUnit.Picoampere));
-            Assertion(3, ElectricCurrentDensityUnit.AmperePerSquareMeter, Quantity.From(3, ElectricCurrentDensityUnit.AmperePerSquareMeter));
-            Assertion(3, ElectricCurrentGradientUnit.AmperePerSecond, Quantity.From(3, ElectricCurrentGradientUnit.AmperePerSecond));
-            Assertion(3, ElectricFieldUnit.VoltPerMeter, Quantity.From(3, ElectricFieldUnit.VoltPerMeter));
-            Assertion(3, ElectricInductanceUnit.Nanohenry, Quantity.From(3, ElectricInductanceUnit.Nanohenry));
-            Assertion(3, ElectricPotentialUnit.Volt, Quantity.From(3, ElectricPotentialUnit.Volt));
-            Assertion(3, ElectricPotentialAcUnit.VoltAc, Quantity.From(3, ElectricPotentialAcUnit.VoltAc));
-            Assertion(3, ElectricPotentialChangeRateUnit.VoltPerSecond, Quantity.From(3, ElectricPotentialChangeRateUnit.VoltPerSecond));
-            Assertion(3, ElectricPotentialDcUnit.VoltDc, Quantity.From(3, ElectricPotentialDcUnit.VoltDc));
-            Assertion(3, ElectricResistanceUnit.Ohm, Quantity.From(3, ElectricResistanceUnit.Ohm));
-            Assertion(3, ElectricResistivityUnit.PicoohmMeter, Quantity.From(3, ElectricResistivityUnit.PicoohmMeter));
-            Assertion(3, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, Quantity.From(3, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
-            Assertion(3, EnergyUnit.WattHour, Quantity.From(3, EnergyUnit.WattHour));
-            Assertion(3, EntropyUnit.MegajoulePerKelvin, Quantity.From(3, EntropyUnit.MegajoulePerKelvin));
-            Assertion(3, ForceUnit.TonneForce, Quantity.From(3, ForceUnit.TonneForce));
-            Assertion(3, ForceChangeRateUnit.NewtonPerSecond, Quantity.From(3, ForceChangeRateUnit.NewtonPerSecond));
-            Assertion(3, ForcePerLengthUnit.TonneForcePerMillimeter, Quantity.From(3, ForcePerLengthUnit.TonneForcePerMillimeter));
-            Assertion(3, FrequencyUnit.Terahertz, Quantity.From(3, FrequencyUnit.Terahertz));
-            Assertion(3, FuelEfficiencyUnit.MilePerUsGallon, Quantity.From(3, FuelEfficiencyUnit.MilePerUsGallon));
-            Assertion(3, HeatFluxUnit.WattPerSquareMeter, Quantity.From(3, HeatFluxUnit.WattPerSquareMeter));
-            Assertion(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, Quantity.From(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
-            Assertion(3, IlluminanceUnit.Millilux, Quantity.From(3, IlluminanceUnit.Millilux));
-            Assertion(3, InformationUnit.Terabyte, Quantity.From(3, InformationUnit.Terabyte));
-            Assertion(3, IrradianceUnit.WattPerSquareMeter, Quantity.From(3, IrradianceUnit.WattPerSquareMeter));
-            Assertion(3, IrradiationUnit.WattHourPerSquareMeter, Quantity.From(3, IrradiationUnit.WattHourPerSquareMeter));
-            Assertion(3, KinematicViscosityUnit.Stokes, Quantity.From(3, KinematicViscosityUnit.Stokes));
-            Assertion(3, LapseRateUnit.DegreeCelsiusPerKilometer, Quantity.From(3, LapseRateUnit.DegreeCelsiusPerKilometer));
-            Assertion(3, LengthUnit.Yard, Quantity.From(3, LengthUnit.Yard));
-            Assertion(3, LevelUnit.Neper, Quantity.From(3, LevelUnit.Neper));
-            Assertion(3, LinearDensityUnit.PoundPerInch, Quantity.From(3, LinearDensityUnit.PoundPerInch));
-            Assertion(3, LinearPowerDensityUnit.WattPerMillimeter, Quantity.From(3, LinearPowerDensityUnit.WattPerMillimeter));
-            Assertion(3, LuminosityUnit.Watt, Quantity.From(3, LuminosityUnit.Watt));
-            Assertion(3, LuminousFluxUnit.Lumen, Quantity.From(3, LuminousFluxUnit.Lumen));
-            Assertion(3, LuminousIntensityUnit.Candela, Quantity.From(3, LuminousIntensityUnit.Candela));
-            Assertion(3, MagneticFieldUnit.Tesla, Quantity.From(3, MagneticFieldUnit.Tesla));
-            Assertion(3, MagneticFluxUnit.Weber, Quantity.From(3, MagneticFluxUnit.Weber));
-            Assertion(3, MagnetizationUnit.AmperePerMeter, Quantity.From(3, MagnetizationUnit.AmperePerMeter));
-            Assertion(3, MassUnit.Tonne, Quantity.From(3, MassUnit.Tonne));
-            Assertion(3, MassConcentrationUnit.TonnePerCubicMillimeter, Quantity.From(3, MassConcentrationUnit.TonnePerCubicMillimeter));
-            Assertion(3, MassFlowUnit.TonnePerHour, Quantity.From(3, MassFlowUnit.TonnePerHour));
-            Assertion(3, MassFluxUnit.KilogramPerSecondPerSquareMillimeter, Quantity.From(3, MassFluxUnit.KilogramPerSecondPerSquareMillimeter));
-            Assertion(3, MassFractionUnit.Percent, Quantity.From(3, MassFractionUnit.Percent));
-            Assertion(3, MassMomentOfInertiaUnit.TonneSquareMilimeter, Quantity.From(3, MassMomentOfInertiaUnit.TonneSquareMilimeter));
-            Assertion(3, MolarEnergyUnit.MegajoulePerMole, Quantity.From(3, MolarEnergyUnit.MegajoulePerMole));
-            Assertion(3, MolarEntropyUnit.MegajoulePerMoleKelvin, Quantity.From(3, MolarEntropyUnit.MegajoulePerMoleKelvin));
-            Assertion(3, MolarityUnit.PicomolesPerLiter, Quantity.From(3, MolarityUnit.PicomolesPerLiter));
-            Assertion(3, MolarMassUnit.PoundPerMole, Quantity.From(3, MolarMassUnit.PoundPerMole));
-            Assertion(3, PermeabilityUnit.HenryPerMeter, Quantity.From(3, PermeabilityUnit.HenryPerMeter));
-            Assertion(3, PermittivityUnit.FaradPerMeter, Quantity.From(3, PermittivityUnit.FaradPerMeter));
-            Assertion(3, PowerUnit.Watt, Quantity.From(3, PowerUnit.Watt));
-            Assertion(3, PowerDensityUnit.WattPerLiter, Quantity.From(3, PowerDensityUnit.WattPerLiter));
-            Assertion(3, PowerRatioUnit.DecibelWatt, Quantity.From(3, PowerRatioUnit.DecibelWatt));
-            Assertion(3, PressureUnit.Torr, Quantity.From(3, PressureUnit.Torr));
-            Assertion(3, PressureChangeRateUnit.PascalPerSecond, Quantity.From(3, PressureChangeRateUnit.PascalPerSecond));
-            Assertion(3, RatioUnit.Percent, Quantity.From(3, RatioUnit.Percent));
-            Assertion(3, RatioChangeRateUnit.PercentPerSecond, Quantity.From(3, RatioChangeRateUnit.PercentPerSecond));
-            Assertion(3, ReactiveEnergyUnit.VoltampereReactiveHour, Quantity.From(3, ReactiveEnergyUnit.VoltampereReactiveHour));
-            Assertion(3, ReactivePowerUnit.VoltampereReactive, Quantity.From(3, ReactivePowerUnit.VoltampereReactive));
-            Assertion(3, RelativeHumidityUnit.Percent, Quantity.From(3, RelativeHumidityUnit.Percent));
-            Assertion(3, RotationalAccelerationUnit.RevolutionPerSecondSquared, Quantity.From(3, RotationalAccelerationUnit.RevolutionPerSecondSquared));
-            Assertion(3, RotationalSpeedUnit.RevolutionPerSecond, Quantity.From(3, RotationalSpeedUnit.RevolutionPerSecond));
-            Assertion(3, RotationalStiffnessUnit.PoundForceFootPerDegrees, Quantity.From(3, RotationalStiffnessUnit.PoundForceFootPerDegrees));
-            Assertion(3, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, Quantity.From(3, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot));
-            Assertion(3, SolidAngleUnit.Steradian, Quantity.From(3, SolidAngleUnit.Steradian));
-            Assertion(3, SpecificEnergyUnit.WattHourPerKilogram, Quantity.From(3, SpecificEnergyUnit.WattHourPerKilogram));
-            Assertion(3, SpecificEntropyUnit.MegajoulePerKilogramKelvin, Quantity.From(3, SpecificEntropyUnit.MegajoulePerKilogramKelvin));
-            Assertion(3, SpecificVolumeUnit.MillicubicMeterPerKilogram, Quantity.From(3, SpecificVolumeUnit.MillicubicMeterPerKilogram));
-            Assertion(3, SpecificWeightUnit.TonneForcePerCubicMillimeter, Quantity.From(3, SpecificWeightUnit.TonneForcePerCubicMillimeter));
-            Assertion(3, SpeedUnit.YardPerSecond, Quantity.From(3, SpeedUnit.YardPerSecond));
-            Assertion(3, TemperatureUnit.SolarTemperature, Quantity.From(3, TemperatureUnit.SolarTemperature));
-            Assertion(3, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, Quantity.From(3, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond));
-            Assertion(3, TemperatureDeltaUnit.MillidegreeCelsius, Quantity.From(3, TemperatureDeltaUnit.MillidegreeCelsius));
-            Assertion(3, ThermalConductivityUnit.WattPerMeterKelvin, Quantity.From(3, ThermalConductivityUnit.WattPerMeterKelvin));
-            Assertion(3, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt, Quantity.From(3, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
-            Assertion(3, TorqueUnit.TonneForceMillimeter, Quantity.From(3, TorqueUnit.TonneForceMillimeter));
-            Assertion(3, TorquePerLengthUnit.TonneForceMillimeterPerMeter, Quantity.From(3, TorquePerLengthUnit.TonneForceMillimeterPerMeter));
-            Assertion(3, TurbidityUnit.NTU, Quantity.From(3, TurbidityUnit.NTU));
-            Assertion(3, VitaminAUnit.InternationalUnit, Quantity.From(3, VitaminAUnit.InternationalUnit));
-            Assertion(3, VolumeUnit.UsTeaspoon, Quantity.From(3, VolumeUnit.UsTeaspoon));
-            Assertion(3, VolumeConcentrationUnit.PicolitersPerMililiter, Quantity.From(3, VolumeConcentrationUnit.PicolitersPerMililiter));
-            Assertion(3, VolumeFlowUnit.UsGallonPerSecond, Quantity.From(3, VolumeFlowUnit.UsGallonPerSecond));
-            Assertion(3, VolumePerLengthUnit.OilBarrelPerFoot, Quantity.From(3, VolumePerLengthUnit.OilBarrelPerFoot));
-            Assertion(3, WarpingMomentOfInertiaUnit.MillimeterToTheSixth, Quantity.From(3, WarpingMomentOfInertiaUnit.MillimeterToTheSixth));
+            Assertion(3, AccelerationUnit.StandardGravity, Quantity.From<double>(3, AccelerationUnit.StandardGravity));
+            Assertion(3, AmountOfSubstanceUnit.PoundMole, Quantity.From<double>(3, AmountOfSubstanceUnit.PoundMole));
+            Assertion(3, AmplitudeRatioUnit.DecibelVolt, Quantity.From<double>(3, AmplitudeRatioUnit.DecibelVolt));
+            Assertion(3, AngleUnit.Revolution, Quantity.From<double>(3, AngleUnit.Revolution));
+            Assertion(3, ApparentEnergyUnit.VoltampereHour, Quantity.From<double>(3, ApparentEnergyUnit.VoltampereHour));
+            Assertion(3, ApparentPowerUnit.Voltampere, Quantity.From<double>(3, ApparentPowerUnit.Voltampere));
+            Assertion(3, AreaUnit.UsSurveySquareFoot, Quantity.From<double>(3, AreaUnit.UsSurveySquareFoot));
+            Assertion(3, AreaDensityUnit.KilogramPerSquareMeter, Quantity.From<double>(3, AreaDensityUnit.KilogramPerSquareMeter));
+            Assertion(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth, Quantity.From<double>(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth));
+            Assertion(3, BitRateUnit.TerabytePerSecond, Quantity.From<double>(3, BitRateUnit.TerabytePerSecond));
+            Assertion(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, Quantity.From<double>(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour));
+            Assertion(3, CapacitanceUnit.Picofarad, Quantity.From<double>(3, CapacitanceUnit.Picofarad));
+            Assertion(3, CoefficientOfThermalExpansionUnit.InverseKelvin, Quantity.From<double>(3, CoefficientOfThermalExpansionUnit.InverseKelvin));
+            Assertion(3, DensityUnit.TonnePerCubicMillimeter, Quantity.From<double>(3, DensityUnit.TonnePerCubicMillimeter));
+            Assertion(3, DurationUnit.Year365, Quantity.From<double>(3, DurationUnit.Year365));
+            Assertion(3, DynamicViscosityUnit.Reyn, Quantity.From<double>(3, DynamicViscosityUnit.Reyn));
+            Assertion(3, ElectricAdmittanceUnit.Siemens, Quantity.From<double>(3, ElectricAdmittanceUnit.Siemens));
+            Assertion(3, ElectricChargeUnit.MilliampereHour, Quantity.From<double>(3, ElectricChargeUnit.MilliampereHour));
+            Assertion(3, ElectricChargeDensityUnit.CoulombPerCubicMeter, Quantity.From<double>(3, ElectricChargeDensityUnit.CoulombPerCubicMeter));
+            Assertion(3, ElectricConductanceUnit.Siemens, Quantity.From<double>(3, ElectricConductanceUnit.Siemens));
+            Assertion(3, ElectricConductivityUnit.SiemensPerMeter, Quantity.From<double>(3, ElectricConductivityUnit.SiemensPerMeter));
+            Assertion(3, ElectricCurrentUnit.Picoampere, Quantity.From<double>(3, ElectricCurrentUnit.Picoampere));
+            Assertion(3, ElectricCurrentDensityUnit.AmperePerSquareMeter, Quantity.From<double>(3, ElectricCurrentDensityUnit.AmperePerSquareMeter));
+            Assertion(3, ElectricCurrentGradientUnit.AmperePerSecond, Quantity.From<double>(3, ElectricCurrentGradientUnit.AmperePerSecond));
+            Assertion(3, ElectricFieldUnit.VoltPerMeter, Quantity.From<double>(3, ElectricFieldUnit.VoltPerMeter));
+            Assertion(3, ElectricInductanceUnit.Nanohenry, Quantity.From<double>(3, ElectricInductanceUnit.Nanohenry));
+            Assertion(3, ElectricPotentialUnit.Volt, Quantity.From<double>(3, ElectricPotentialUnit.Volt));
+            Assertion(3, ElectricPotentialAcUnit.VoltAc, Quantity.From<double>(3, ElectricPotentialAcUnit.VoltAc));
+            Assertion(3, ElectricPotentialChangeRateUnit.VoltPerSecond, Quantity.From<double>(3, ElectricPotentialChangeRateUnit.VoltPerSecond));
+            Assertion(3, ElectricPotentialDcUnit.VoltDc, Quantity.From<double>(3, ElectricPotentialDcUnit.VoltDc));
+            Assertion(3, ElectricResistanceUnit.Ohm, Quantity.From<double>(3, ElectricResistanceUnit.Ohm));
+            Assertion(3, ElectricResistivityUnit.PicoohmMeter, Quantity.From<double>(3, ElectricResistivityUnit.PicoohmMeter));
+            Assertion(3, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, Quantity.From<double>(3, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
+            Assertion(3, EnergyUnit.WattHour, Quantity.From<double>(3, EnergyUnit.WattHour));
+            Assertion(3, EntropyUnit.MegajoulePerKelvin, Quantity.From<double>(3, EntropyUnit.MegajoulePerKelvin));
+            Assertion(3, ForceUnit.TonneForce, Quantity.From<double>(3, ForceUnit.TonneForce));
+            Assertion(3, ForceChangeRateUnit.NewtonPerSecond, Quantity.From<double>(3, ForceChangeRateUnit.NewtonPerSecond));
+            Assertion(3, ForcePerLengthUnit.TonneForcePerMillimeter, Quantity.From<double>(3, ForcePerLengthUnit.TonneForcePerMillimeter));
+            Assertion(3, FrequencyUnit.Terahertz, Quantity.From<double>(3, FrequencyUnit.Terahertz));
+            Assertion(3, FuelEfficiencyUnit.MilePerUsGallon, Quantity.From<double>(3, FuelEfficiencyUnit.MilePerUsGallon));
+            Assertion(3, HeatFluxUnit.WattPerSquareMeter, Quantity.From<double>(3, HeatFluxUnit.WattPerSquareMeter));
+            Assertion(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, Quantity.From<double>(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+            Assertion(3, IlluminanceUnit.Millilux, Quantity.From<double>(3, IlluminanceUnit.Millilux));
+            Assertion(3, InformationUnit.Terabyte, Quantity.From<double>(3, InformationUnit.Terabyte));
+            Assertion(3, IrradianceUnit.WattPerSquareMeter, Quantity.From<double>(3, IrradianceUnit.WattPerSquareMeter));
+            Assertion(3, IrradiationUnit.WattHourPerSquareMeter, Quantity.From<double>(3, IrradiationUnit.WattHourPerSquareMeter));
+            Assertion(3, KinematicViscosityUnit.Stokes, Quantity.From<double>(3, KinematicViscosityUnit.Stokes));
+            Assertion(3, LapseRateUnit.DegreeCelsiusPerKilometer, Quantity.From<double>(3, LapseRateUnit.DegreeCelsiusPerKilometer));
+            Assertion(3, LengthUnit.Yard, Quantity.From<double>(3, LengthUnit.Yard));
+            Assertion(3, LevelUnit.Neper, Quantity.From<double>(3, LevelUnit.Neper));
+            Assertion(3, LinearDensityUnit.PoundPerInch, Quantity.From<double>(3, LinearDensityUnit.PoundPerInch));
+            Assertion(3, LinearPowerDensityUnit.WattPerMillimeter, Quantity.From<double>(3, LinearPowerDensityUnit.WattPerMillimeter));
+            Assertion(3, LuminosityUnit.Watt, Quantity.From<double>(3, LuminosityUnit.Watt));
+            Assertion(3, LuminousFluxUnit.Lumen, Quantity.From<double>(3, LuminousFluxUnit.Lumen));
+            Assertion(3, LuminousIntensityUnit.Candela, Quantity.From<double>(3, LuminousIntensityUnit.Candela));
+            Assertion(3, MagneticFieldUnit.Tesla, Quantity.From<double>(3, MagneticFieldUnit.Tesla));
+            Assertion(3, MagneticFluxUnit.Weber, Quantity.From<double>(3, MagneticFluxUnit.Weber));
+            Assertion(3, MagnetizationUnit.AmperePerMeter, Quantity.From<double>(3, MagnetizationUnit.AmperePerMeter));
+            Assertion(3, MassUnit.Tonne, Quantity.From<double>(3, MassUnit.Tonne));
+            Assertion(3, MassConcentrationUnit.TonnePerCubicMillimeter, Quantity.From<double>(3, MassConcentrationUnit.TonnePerCubicMillimeter));
+            Assertion(3, MassFlowUnit.TonnePerHour, Quantity.From<double>(3, MassFlowUnit.TonnePerHour));
+            Assertion(3, MassFluxUnit.KilogramPerSecondPerSquareMillimeter, Quantity.From<double>(3, MassFluxUnit.KilogramPerSecondPerSquareMillimeter));
+            Assertion(3, MassFractionUnit.Percent, Quantity.From<double>(3, MassFractionUnit.Percent));
+            Assertion(3, MassMomentOfInertiaUnit.TonneSquareMilimeter, Quantity.From<double>(3, MassMomentOfInertiaUnit.TonneSquareMilimeter));
+            Assertion(3, MolarEnergyUnit.MegajoulePerMole, Quantity.From<double>(3, MolarEnergyUnit.MegajoulePerMole));
+            Assertion(3, MolarEntropyUnit.MegajoulePerMoleKelvin, Quantity.From<double>(3, MolarEntropyUnit.MegajoulePerMoleKelvin));
+            Assertion(3, MolarityUnit.PicomolesPerLiter, Quantity.From<double>(3, MolarityUnit.PicomolesPerLiter));
+            Assertion(3, MolarMassUnit.PoundPerMole, Quantity.From<double>(3, MolarMassUnit.PoundPerMole));
+            Assertion(3, PermeabilityUnit.HenryPerMeter, Quantity.From<double>(3, PermeabilityUnit.HenryPerMeter));
+            Assertion(3, PermittivityUnit.FaradPerMeter, Quantity.From<double>(3, PermittivityUnit.FaradPerMeter));
+            Assertion(3, PowerUnit.Watt, Quantity.From<double>(3, PowerUnit.Watt));
+            Assertion(3, PowerDensityUnit.WattPerLiter, Quantity.From<double>(3, PowerDensityUnit.WattPerLiter));
+            Assertion(3, PowerRatioUnit.DecibelWatt, Quantity.From<double>(3, PowerRatioUnit.DecibelWatt));
+            Assertion(3, PressureUnit.Torr, Quantity.From<double>(3, PressureUnit.Torr));
+            Assertion(3, PressureChangeRateUnit.PascalPerSecond, Quantity.From<double>(3, PressureChangeRateUnit.PascalPerSecond));
+            Assertion(3, RatioUnit.Percent, Quantity.From<double>(3, RatioUnit.Percent));
+            Assertion(3, RatioChangeRateUnit.PercentPerSecond, Quantity.From<double>(3, RatioChangeRateUnit.PercentPerSecond));
+            Assertion(3, ReactiveEnergyUnit.VoltampereReactiveHour, Quantity.From<double>(3, ReactiveEnergyUnit.VoltampereReactiveHour));
+            Assertion(3, ReactivePowerUnit.VoltampereReactive, Quantity.From<double>(3, ReactivePowerUnit.VoltampereReactive));
+            Assertion(3, RelativeHumidityUnit.Percent, Quantity.From<double>(3, RelativeHumidityUnit.Percent));
+            Assertion(3, RotationalAccelerationUnit.RevolutionPerSecondSquared, Quantity.From<double>(3, RotationalAccelerationUnit.RevolutionPerSecondSquared));
+            Assertion(3, RotationalSpeedUnit.RevolutionPerSecond, Quantity.From<double>(3, RotationalSpeedUnit.RevolutionPerSecond));
+            Assertion(3, RotationalStiffnessUnit.PoundForceFootPerDegrees, Quantity.From<double>(3, RotationalStiffnessUnit.PoundForceFootPerDegrees));
+            Assertion(3, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, Quantity.From<double>(3, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot));
+            Assertion(3, SolidAngleUnit.Steradian, Quantity.From<double>(3, SolidAngleUnit.Steradian));
+            Assertion(3, SpecificEnergyUnit.WattHourPerKilogram, Quantity.From<double>(3, SpecificEnergyUnit.WattHourPerKilogram));
+            Assertion(3, SpecificEntropyUnit.MegajoulePerKilogramKelvin, Quantity.From<double>(3, SpecificEntropyUnit.MegajoulePerKilogramKelvin));
+            Assertion(3, SpecificVolumeUnit.MillicubicMeterPerKilogram, Quantity.From<double>(3, SpecificVolumeUnit.MillicubicMeterPerKilogram));
+            Assertion(3, SpecificWeightUnit.TonneForcePerCubicMillimeter, Quantity.From<double>(3, SpecificWeightUnit.TonneForcePerCubicMillimeter));
+            Assertion(3, SpeedUnit.YardPerSecond, Quantity.From<double>(3, SpeedUnit.YardPerSecond));
+            Assertion(3, TemperatureUnit.SolarTemperature, Quantity.From<double>(3, TemperatureUnit.SolarTemperature));
+            Assertion(3, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, Quantity.From<double>(3, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond));
+            Assertion(3, TemperatureDeltaUnit.MillidegreeCelsius, Quantity.From<double>(3, TemperatureDeltaUnit.MillidegreeCelsius));
+            Assertion(3, ThermalConductivityUnit.WattPerMeterKelvin, Quantity.From<double>(3, ThermalConductivityUnit.WattPerMeterKelvin));
+            Assertion(3, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt, Quantity.From<double>(3, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
+            Assertion(3, TorqueUnit.TonneForceMillimeter, Quantity.From<double>(3, TorqueUnit.TonneForceMillimeter));
+            Assertion(3, TorquePerLengthUnit.TonneForceMillimeterPerMeter, Quantity.From<double>(3, TorquePerLengthUnit.TonneForceMillimeterPerMeter));
+            Assertion(3, TurbidityUnit.NTU, Quantity.From<double>(3, TurbidityUnit.NTU));
+            Assertion(3, VitaminAUnit.InternationalUnit, Quantity.From<double>(3, VitaminAUnit.InternationalUnit));
+            Assertion(3, VolumeUnit.UsTeaspoon, Quantity.From<double>(3, VolumeUnit.UsTeaspoon));
+            Assertion(3, VolumeConcentrationUnit.PicolitersPerMililiter, Quantity.From<double>(3, VolumeConcentrationUnit.PicolitersPerMililiter));
+            Assertion(3, VolumeFlowUnit.UsGallonPerSecond, Quantity.From<double>(3, VolumeFlowUnit.UsGallonPerSecond));
+            Assertion(3, VolumePerLengthUnit.OilBarrelPerFoot, Quantity.From<double>(3, VolumePerLengthUnit.OilBarrelPerFoot));
+            Assertion(3, WarpingMomentOfInertiaUnit.MillimeterToTheSixth, Quantity.From<double>(3, WarpingMomentOfInertiaUnit.MillimeterToTheSixth));
         }
 
         [Fact]
@@ -145,110 +145,110 @@ public void QuantityInfo_IsSameAsStaticInfoProperty()
         {
             void Assertion(QuantityInfo expected, IQuantity quantity) => Assert.Same(expected, quantity.QuantityInfo);
 
-            Assertion(Acceleration.Info, Acceleration.Zero);
-            Assertion(AmountOfSubstance.Info, AmountOfSubstance.Zero);
-            Assertion(AmplitudeRatio.Info, AmplitudeRatio.Zero);
-            Assertion(Angle.Info, Angle.Zero);
-            Assertion(ApparentEnergy.Info, ApparentEnergy.Zero);
-            Assertion(ApparentPower.Info, ApparentPower.Zero);
-            Assertion(Area.Info, Area.Zero);
-            Assertion(AreaDensity.Info, AreaDensity.Zero);
-            Assertion(AreaMomentOfInertia.Info, AreaMomentOfInertia.Zero);
-            Assertion(BitRate.Info, BitRate.Zero);
-            Assertion(BrakeSpecificFuelConsumption.Info, BrakeSpecificFuelConsumption.Zero);
-            Assertion(Capacitance.Info, Capacitance.Zero);
-            Assertion(CoefficientOfThermalExpansion.Info, CoefficientOfThermalExpansion.Zero);
-            Assertion(Density.Info, Density.Zero);
-            Assertion(Duration.Info, Duration.Zero);
-            Assertion(DynamicViscosity.Info, DynamicViscosity.Zero);
-            Assertion(ElectricAdmittance.Info, ElectricAdmittance.Zero);
-            Assertion(ElectricCharge.Info, ElectricCharge.Zero);
-            Assertion(ElectricChargeDensity.Info, ElectricChargeDensity.Zero);
-            Assertion(ElectricConductance.Info, ElectricConductance.Zero);
-            Assertion(ElectricConductivity.Info, ElectricConductivity.Zero);
-            Assertion(ElectricCurrent.Info, ElectricCurrent.Zero);
-            Assertion(ElectricCurrentDensity.Info, ElectricCurrentDensity.Zero);
-            Assertion(ElectricCurrentGradient.Info, ElectricCurrentGradient.Zero);
-            Assertion(ElectricField.Info, ElectricField.Zero);
-            Assertion(ElectricInductance.Info, ElectricInductance.Zero);
-            Assertion(ElectricPotential.Info, ElectricPotential.Zero);
-            Assertion(ElectricPotentialAc.Info, ElectricPotentialAc.Zero);
-            Assertion(ElectricPotentialChangeRate.Info, ElectricPotentialChangeRate.Zero);
-            Assertion(ElectricPotentialDc.Info, ElectricPotentialDc.Zero);
-            Assertion(ElectricResistance.Info, ElectricResistance.Zero);
-            Assertion(ElectricResistivity.Info, ElectricResistivity.Zero);
-            Assertion(ElectricSurfaceChargeDensity.Info, ElectricSurfaceChargeDensity.Zero);
-            Assertion(Energy.Info, Energy.Zero);
-            Assertion(Entropy.Info, Entropy.Zero);
-            Assertion(Force.Info, Force.Zero);
-            Assertion(ForceChangeRate.Info, ForceChangeRate.Zero);
-            Assertion(ForcePerLength.Info, ForcePerLength.Zero);
-            Assertion(Frequency.Info, Frequency.Zero);
-            Assertion(FuelEfficiency.Info, FuelEfficiency.Zero);
-            Assertion(HeatFlux.Info, HeatFlux.Zero);
-            Assertion(HeatTransferCoefficient.Info, HeatTransferCoefficient.Zero);
-            Assertion(Illuminance.Info, Illuminance.Zero);
-            Assertion(Information.Info, Information.Zero);
-            Assertion(Irradiance.Info, Irradiance.Zero);
-            Assertion(Irradiation.Info, Irradiation.Zero);
-            Assertion(KinematicViscosity.Info, KinematicViscosity.Zero);
-            Assertion(LapseRate.Info, LapseRate.Zero);
-            Assertion(Length.Info, Length.Zero);
-            Assertion(Level.Info, Level.Zero);
-            Assertion(LinearDensity.Info, LinearDensity.Zero);
-            Assertion(LinearPowerDensity.Info, LinearPowerDensity.Zero);
-            Assertion(Luminosity.Info, Luminosity.Zero);
-            Assertion(LuminousFlux.Info, LuminousFlux.Zero);
-            Assertion(LuminousIntensity.Info, LuminousIntensity.Zero);
-            Assertion(MagneticField.Info, MagneticField.Zero);
-            Assertion(MagneticFlux.Info, MagneticFlux.Zero);
-            Assertion(Magnetization.Info, Magnetization.Zero);
-            Assertion(Mass.Info, Mass.Zero);
-            Assertion(MassConcentration.Info, MassConcentration.Zero);
-            Assertion(MassFlow.Info, MassFlow.Zero);
-            Assertion(MassFlux.Info, MassFlux.Zero);
-            Assertion(MassFraction.Info, MassFraction.Zero);
-            Assertion(MassMomentOfInertia.Info, MassMomentOfInertia.Zero);
-            Assertion(MolarEnergy.Info, MolarEnergy.Zero);
-            Assertion(MolarEntropy.Info, MolarEntropy.Zero);
-            Assertion(Molarity.Info, Molarity.Zero);
-            Assertion(MolarMass.Info, MolarMass.Zero);
-            Assertion(Permeability.Info, Permeability.Zero);
-            Assertion(Permittivity.Info, Permittivity.Zero);
-            Assertion(Power.Info, Power.Zero);
-            Assertion(PowerDensity.Info, PowerDensity.Zero);
-            Assertion(PowerRatio.Info, PowerRatio.Zero);
-            Assertion(Pressure.Info, Pressure.Zero);
-            Assertion(PressureChangeRate.Info, PressureChangeRate.Zero);
-            Assertion(Ratio.Info, Ratio.Zero);
-            Assertion(RatioChangeRate.Info, RatioChangeRate.Zero);
-            Assertion(ReactiveEnergy.Info, ReactiveEnergy.Zero);
-            Assertion(ReactivePower.Info, ReactivePower.Zero);
-            Assertion(RelativeHumidity.Info, RelativeHumidity.Zero);
-            Assertion(RotationalAcceleration.Info, RotationalAcceleration.Zero);
-            Assertion(RotationalSpeed.Info, RotationalSpeed.Zero);
-            Assertion(RotationalStiffness.Info, RotationalStiffness.Zero);
-            Assertion(RotationalStiffnessPerLength.Info, RotationalStiffnessPerLength.Zero);
-            Assertion(SolidAngle.Info, SolidAngle.Zero);
-            Assertion(SpecificEnergy.Info, SpecificEnergy.Zero);
-            Assertion(SpecificEntropy.Info, SpecificEntropy.Zero);
-            Assertion(SpecificVolume.Info, SpecificVolume.Zero);
-            Assertion(SpecificWeight.Info, SpecificWeight.Zero);
-            Assertion(Speed.Info, Speed.Zero);
-            Assertion(Temperature.Info, Temperature.Zero);
-            Assertion(TemperatureChangeRate.Info, TemperatureChangeRate.Zero);
-            Assertion(TemperatureDelta.Info, TemperatureDelta.Zero);
-            Assertion(ThermalConductivity.Info, ThermalConductivity.Zero);
-            Assertion(ThermalResistance.Info, ThermalResistance.Zero);
-            Assertion(Torque.Info, Torque.Zero);
-            Assertion(TorquePerLength.Info, TorquePerLength.Zero);
-            Assertion(Turbidity.Info, Turbidity.Zero);
-            Assertion(VitaminA.Info, VitaminA.Zero);
-            Assertion(Volume.Info, Volume.Zero);
-            Assertion(VolumeConcentration.Info, VolumeConcentration.Zero);
-            Assertion(VolumeFlow.Info, VolumeFlow.Zero);
-            Assertion(VolumePerLength.Info, VolumePerLength.Zero);
-            Assertion(WarpingMomentOfInertia.Info, WarpingMomentOfInertia.Zero);
+            Assertion(Acceleration<double>.Info, Acceleration<double>.Zero);
+            Assertion(AmountOfSubstance<double>.Info, AmountOfSubstance<double>.Zero);
+            Assertion(AmplitudeRatio<double>.Info, AmplitudeRatio<double>.Zero);
+            Assertion(Angle<double>.Info, Angle<double>.Zero);
+            Assertion(ApparentEnergy<double>.Info, ApparentEnergy<double>.Zero);
+            Assertion(ApparentPower<double>.Info, ApparentPower<double>.Zero);
+            Assertion(Area<double>.Info, Area<double>.Zero);
+            Assertion(AreaDensity<double>.Info, AreaDensity<double>.Zero);
+            Assertion(AreaMomentOfInertia<double>.Info, AreaMomentOfInertia<double>.Zero);
+            Assertion(BitRate<double>.Info, BitRate<double>.Zero);
+            Assertion(BrakeSpecificFuelConsumption<double>.Info, BrakeSpecificFuelConsumption<double>.Zero);
+            Assertion(Capacitance<double>.Info, Capacitance<double>.Zero);
+            Assertion(CoefficientOfThermalExpansion<double>.Info, CoefficientOfThermalExpansion<double>.Zero);
+            Assertion(Density<double>.Info, Density<double>.Zero);
+            Assertion(Duration<double>.Info, Duration<double>.Zero);
+            Assertion(DynamicViscosity<double>.Info, DynamicViscosity<double>.Zero);
+            Assertion(ElectricAdmittance<double>.Info, ElectricAdmittance<double>.Zero);
+            Assertion(ElectricCharge<double>.Info, ElectricCharge<double>.Zero);
+            Assertion(ElectricChargeDensity<double>.Info, ElectricChargeDensity<double>.Zero);
+            Assertion(ElectricConductance<double>.Info, ElectricConductance<double>.Zero);
+            Assertion(ElectricConductivity<double>.Info, ElectricConductivity<double>.Zero);
+            Assertion(ElectricCurrent<double>.Info, ElectricCurrent<double>.Zero);
+            Assertion(ElectricCurrentDensity<double>.Info, ElectricCurrentDensity<double>.Zero);
+            Assertion(ElectricCurrentGradient<double>.Info, ElectricCurrentGradient<double>.Zero);
+            Assertion(ElectricField<double>.Info, ElectricField<double>.Zero);
+            Assertion(ElectricInductance<double>.Info, ElectricInductance<double>.Zero);
+            Assertion(ElectricPotential<double>.Info, ElectricPotential<double>.Zero);
+            Assertion(ElectricPotentialAc<double>.Info, ElectricPotentialAc<double>.Zero);
+            Assertion(ElectricPotentialChangeRate<double>.Info, ElectricPotentialChangeRate<double>.Zero);
+            Assertion(ElectricPotentialDc<double>.Info, ElectricPotentialDc<double>.Zero);
+            Assertion(ElectricResistance<double>.Info, ElectricResistance<double>.Zero);
+            Assertion(ElectricResistivity<double>.Info, ElectricResistivity<double>.Zero);
+            Assertion(ElectricSurfaceChargeDensity<double>.Info, ElectricSurfaceChargeDensity<double>.Zero);
+            Assertion(Energy<double>.Info, Energy<double>.Zero);
+            Assertion(Entropy<double>.Info, Entropy<double>.Zero);
+            Assertion(Force<double>.Info, Force<double>.Zero);
+            Assertion(ForceChangeRate<double>.Info, ForceChangeRate<double>.Zero);
+            Assertion(ForcePerLength<double>.Info, ForcePerLength<double>.Zero);
+            Assertion(Frequency<double>.Info, Frequency<double>.Zero);
+            Assertion(FuelEfficiency<double>.Info, FuelEfficiency<double>.Zero);
+            Assertion(HeatFlux<double>.Info, HeatFlux<double>.Zero);
+            Assertion(HeatTransferCoefficient<double>.Info, HeatTransferCoefficient<double>.Zero);
+            Assertion(Illuminance<double>.Info, Illuminance<double>.Zero);
+            Assertion(Information<double>.Info, Information<double>.Zero);
+            Assertion(Irradiance<double>.Info, Irradiance<double>.Zero);
+            Assertion(Irradiation<double>.Info, Irradiation<double>.Zero);
+            Assertion(KinematicViscosity<double>.Info, KinematicViscosity<double>.Zero);
+            Assertion(LapseRate<double>.Info, LapseRate<double>.Zero);
+            Assertion(Length<double>.Info, Length<double>.Zero);
+            Assertion(Level<double>.Info, Level<double>.Zero);
+            Assertion(LinearDensity<double>.Info, LinearDensity<double>.Zero);
+            Assertion(LinearPowerDensity<double>.Info, LinearPowerDensity<double>.Zero);
+            Assertion(Luminosity<double>.Info, Luminosity<double>.Zero);
+            Assertion(LuminousFlux<double>.Info, LuminousFlux<double>.Zero);
+            Assertion(LuminousIntensity<double>.Info, LuminousIntensity<double>.Zero);
+            Assertion(MagneticField<double>.Info, MagneticField<double>.Zero);
+            Assertion(MagneticFlux<double>.Info, MagneticFlux<double>.Zero);
+            Assertion(Magnetization<double>.Info, Magnetization<double>.Zero);
+            Assertion(Mass<double>.Info, Mass<double>.Zero);
+            Assertion(MassConcentration<double>.Info, MassConcentration<double>.Zero);
+            Assertion(MassFlow<double>.Info, MassFlow<double>.Zero);
+            Assertion(MassFlux<double>.Info, MassFlux<double>.Zero);
+            Assertion(MassFraction<double>.Info, MassFraction<double>.Zero);
+            Assertion(MassMomentOfInertia<double>.Info, MassMomentOfInertia<double>.Zero);
+            Assertion(MolarEnergy<double>.Info, MolarEnergy<double>.Zero);
+            Assertion(MolarEntropy<double>.Info, MolarEntropy<double>.Zero);
+            Assertion(Molarity<double>.Info, Molarity<double>.Zero);
+            Assertion(MolarMass<double>.Info, MolarMass<double>.Zero);
+            Assertion(Permeability<double>.Info, Permeability<double>.Zero);
+            Assertion(Permittivity<double>.Info, Permittivity<double>.Zero);
+            Assertion(Power<double>.Info, Power<double>.Zero);
+            Assertion(PowerDensity<double>.Info, PowerDensity<double>.Zero);
+            Assertion(PowerRatio<double>.Info, PowerRatio<double>.Zero);
+            Assertion(Pressure<double>.Info, Pressure<double>.Zero);
+            Assertion(PressureChangeRate<double>.Info, PressureChangeRate<double>.Zero);
+            Assertion(Ratio<double>.Info, Ratio<double>.Zero);
+            Assertion(RatioChangeRate<double>.Info, RatioChangeRate<double>.Zero);
+            Assertion(ReactiveEnergy<double>.Info, ReactiveEnergy<double>.Zero);
+            Assertion(ReactivePower<double>.Info, ReactivePower<double>.Zero);
+            Assertion(RelativeHumidity<double>.Info, RelativeHumidity<double>.Zero);
+            Assertion(RotationalAcceleration<double>.Info, RotationalAcceleration<double>.Zero);
+            Assertion(RotationalSpeed<double>.Info, RotationalSpeed<double>.Zero);
+            Assertion(RotationalStiffness<double>.Info, RotationalStiffness<double>.Zero);
+            Assertion(RotationalStiffnessPerLength<double>.Info, RotationalStiffnessPerLength<double>.Zero);
+            Assertion(SolidAngle<double>.Info, SolidAngle<double>.Zero);
+            Assertion(SpecificEnergy<double>.Info, SpecificEnergy<double>.Zero);
+            Assertion(SpecificEntropy<double>.Info, SpecificEntropy<double>.Zero);
+            Assertion(SpecificVolume<double>.Info, SpecificVolume<double>.Zero);
+            Assertion(SpecificWeight<double>.Info, SpecificWeight<double>.Zero);
+            Assertion(Speed<double>.Info, Speed<double>.Zero);
+            Assertion(Temperature<double>.Info, Temperature<double>.Zero);
+            Assertion(TemperatureChangeRate<double>.Info, TemperatureChangeRate<double>.Zero);
+            Assertion(TemperatureDelta<double>.Info, TemperatureDelta<double>.Zero);
+            Assertion(ThermalConductivity<double>.Info, ThermalConductivity<double>.Zero);
+            Assertion(ThermalResistance<double>.Info, ThermalResistance<double>.Zero);
+            Assertion(Torque<double>.Info, Torque<double>.Zero);
+            Assertion(TorquePerLength<double>.Info, TorquePerLength<double>.Zero);
+            Assertion(Turbidity<double>.Info, Turbidity<double>.Zero);
+            Assertion(VitaminA<double>.Info, VitaminA<double>.Zero);
+            Assertion(Volume<double>.Info, Volume<double>.Zero);
+            Assertion(VolumeConcentration<double>.Info, VolumeConcentration<double>.Zero);
+            Assertion(VolumeFlow<double>.Info, VolumeFlow<double>.Zero);
+            Assertion(VolumePerLength<double>.Info, VolumePerLength<double>.Zero);
+            Assertion(WarpingMomentOfInertia<double>.Info, WarpingMomentOfInertia<double>.Zero);
         }
 
         [Fact]
@@ -256,110 +256,110 @@ public void Type_EqualsStaticQuantityTypeProperty()
         {
             void Assertion(QuantityType expected, IQuantity quantity) => Assert.Equal(expected, quantity.Type);
 
-            Assertion(Acceleration.QuantityType, Acceleration.Zero);
-            Assertion(AmountOfSubstance.QuantityType, AmountOfSubstance.Zero);
-            Assertion(AmplitudeRatio.QuantityType, AmplitudeRatio.Zero);
-            Assertion(Angle.QuantityType, Angle.Zero);
-            Assertion(ApparentEnergy.QuantityType, ApparentEnergy.Zero);
-            Assertion(ApparentPower.QuantityType, ApparentPower.Zero);
-            Assertion(Area.QuantityType, Area.Zero);
-            Assertion(AreaDensity.QuantityType, AreaDensity.Zero);
-            Assertion(AreaMomentOfInertia.QuantityType, AreaMomentOfInertia.Zero);
-            Assertion(BitRate.QuantityType, BitRate.Zero);
-            Assertion(BrakeSpecificFuelConsumption.QuantityType, BrakeSpecificFuelConsumption.Zero);
-            Assertion(Capacitance.QuantityType, Capacitance.Zero);
-            Assertion(CoefficientOfThermalExpansion.QuantityType, CoefficientOfThermalExpansion.Zero);
-            Assertion(Density.QuantityType, Density.Zero);
-            Assertion(Duration.QuantityType, Duration.Zero);
-            Assertion(DynamicViscosity.QuantityType, DynamicViscosity.Zero);
-            Assertion(ElectricAdmittance.QuantityType, ElectricAdmittance.Zero);
-            Assertion(ElectricCharge.QuantityType, ElectricCharge.Zero);
-            Assertion(ElectricChargeDensity.QuantityType, ElectricChargeDensity.Zero);
-            Assertion(ElectricConductance.QuantityType, ElectricConductance.Zero);
-            Assertion(ElectricConductivity.QuantityType, ElectricConductivity.Zero);
-            Assertion(ElectricCurrent.QuantityType, ElectricCurrent.Zero);
-            Assertion(ElectricCurrentDensity.QuantityType, ElectricCurrentDensity.Zero);
-            Assertion(ElectricCurrentGradient.QuantityType, ElectricCurrentGradient.Zero);
-            Assertion(ElectricField.QuantityType, ElectricField.Zero);
-            Assertion(ElectricInductance.QuantityType, ElectricInductance.Zero);
-            Assertion(ElectricPotential.QuantityType, ElectricPotential.Zero);
-            Assertion(ElectricPotentialAc.QuantityType, ElectricPotentialAc.Zero);
-            Assertion(ElectricPotentialChangeRate.QuantityType, ElectricPotentialChangeRate.Zero);
-            Assertion(ElectricPotentialDc.QuantityType, ElectricPotentialDc.Zero);
-            Assertion(ElectricResistance.QuantityType, ElectricResistance.Zero);
-            Assertion(ElectricResistivity.QuantityType, ElectricResistivity.Zero);
-            Assertion(ElectricSurfaceChargeDensity.QuantityType, ElectricSurfaceChargeDensity.Zero);
-            Assertion(Energy.QuantityType, Energy.Zero);
-            Assertion(Entropy.QuantityType, Entropy.Zero);
-            Assertion(Force.QuantityType, Force.Zero);
-            Assertion(ForceChangeRate.QuantityType, ForceChangeRate.Zero);
-            Assertion(ForcePerLength.QuantityType, ForcePerLength.Zero);
-            Assertion(Frequency.QuantityType, Frequency.Zero);
-            Assertion(FuelEfficiency.QuantityType, FuelEfficiency.Zero);
-            Assertion(HeatFlux.QuantityType, HeatFlux.Zero);
-            Assertion(HeatTransferCoefficient.QuantityType, HeatTransferCoefficient.Zero);
-            Assertion(Illuminance.QuantityType, Illuminance.Zero);
-            Assertion(Information.QuantityType, Information.Zero);
-            Assertion(Irradiance.QuantityType, Irradiance.Zero);
-            Assertion(Irradiation.QuantityType, Irradiation.Zero);
-            Assertion(KinematicViscosity.QuantityType, KinematicViscosity.Zero);
-            Assertion(LapseRate.QuantityType, LapseRate.Zero);
-            Assertion(Length.QuantityType, Length.Zero);
-            Assertion(Level.QuantityType, Level.Zero);
-            Assertion(LinearDensity.QuantityType, LinearDensity.Zero);
-            Assertion(LinearPowerDensity.QuantityType, LinearPowerDensity.Zero);
-            Assertion(Luminosity.QuantityType, Luminosity.Zero);
-            Assertion(LuminousFlux.QuantityType, LuminousFlux.Zero);
-            Assertion(LuminousIntensity.QuantityType, LuminousIntensity.Zero);
-            Assertion(MagneticField.QuantityType, MagneticField.Zero);
-            Assertion(MagneticFlux.QuantityType, MagneticFlux.Zero);
-            Assertion(Magnetization.QuantityType, Magnetization.Zero);
-            Assertion(Mass.QuantityType, Mass.Zero);
-            Assertion(MassConcentration.QuantityType, MassConcentration.Zero);
-            Assertion(MassFlow.QuantityType, MassFlow.Zero);
-            Assertion(MassFlux.QuantityType, MassFlux.Zero);
-            Assertion(MassFraction.QuantityType, MassFraction.Zero);
-            Assertion(MassMomentOfInertia.QuantityType, MassMomentOfInertia.Zero);
-            Assertion(MolarEnergy.QuantityType, MolarEnergy.Zero);
-            Assertion(MolarEntropy.QuantityType, MolarEntropy.Zero);
-            Assertion(Molarity.QuantityType, Molarity.Zero);
-            Assertion(MolarMass.QuantityType, MolarMass.Zero);
-            Assertion(Permeability.QuantityType, Permeability.Zero);
-            Assertion(Permittivity.QuantityType, Permittivity.Zero);
-            Assertion(Power.QuantityType, Power.Zero);
-            Assertion(PowerDensity.QuantityType, PowerDensity.Zero);
-            Assertion(PowerRatio.QuantityType, PowerRatio.Zero);
-            Assertion(Pressure.QuantityType, Pressure.Zero);
-            Assertion(PressureChangeRate.QuantityType, PressureChangeRate.Zero);
-            Assertion(Ratio.QuantityType, Ratio.Zero);
-            Assertion(RatioChangeRate.QuantityType, RatioChangeRate.Zero);
-            Assertion(ReactiveEnergy.QuantityType, ReactiveEnergy.Zero);
-            Assertion(ReactivePower.QuantityType, ReactivePower.Zero);
-            Assertion(RelativeHumidity.QuantityType, RelativeHumidity.Zero);
-            Assertion(RotationalAcceleration.QuantityType, RotationalAcceleration.Zero);
-            Assertion(RotationalSpeed.QuantityType, RotationalSpeed.Zero);
-            Assertion(RotationalStiffness.QuantityType, RotationalStiffness.Zero);
-            Assertion(RotationalStiffnessPerLength.QuantityType, RotationalStiffnessPerLength.Zero);
-            Assertion(SolidAngle.QuantityType, SolidAngle.Zero);
-            Assertion(SpecificEnergy.QuantityType, SpecificEnergy.Zero);
-            Assertion(SpecificEntropy.QuantityType, SpecificEntropy.Zero);
-            Assertion(SpecificVolume.QuantityType, SpecificVolume.Zero);
-            Assertion(SpecificWeight.QuantityType, SpecificWeight.Zero);
-            Assertion(Speed.QuantityType, Speed.Zero);
-            Assertion(Temperature.QuantityType, Temperature.Zero);
-            Assertion(TemperatureChangeRate.QuantityType, TemperatureChangeRate.Zero);
-            Assertion(TemperatureDelta.QuantityType, TemperatureDelta.Zero);
-            Assertion(ThermalConductivity.QuantityType, ThermalConductivity.Zero);
-            Assertion(ThermalResistance.QuantityType, ThermalResistance.Zero);
-            Assertion(Torque.QuantityType, Torque.Zero);
-            Assertion(TorquePerLength.QuantityType, TorquePerLength.Zero);
-            Assertion(Turbidity.QuantityType, Turbidity.Zero);
-            Assertion(VitaminA.QuantityType, VitaminA.Zero);
-            Assertion(Volume.QuantityType, Volume.Zero);
-            Assertion(VolumeConcentration.QuantityType, VolumeConcentration.Zero);
-            Assertion(VolumeFlow.QuantityType, VolumeFlow.Zero);
-            Assertion(VolumePerLength.QuantityType, VolumePerLength.Zero);
-            Assertion(WarpingMomentOfInertia.QuantityType, WarpingMomentOfInertia.Zero);
+            Assertion(Acceleration<double>.QuantityType, Acceleration<double>.Zero);
+            Assertion(AmountOfSubstance<double>.QuantityType, AmountOfSubstance<double>.Zero);
+            Assertion(AmplitudeRatio<double>.QuantityType, AmplitudeRatio<double>.Zero);
+            Assertion(Angle<double>.QuantityType, Angle<double>.Zero);
+            Assertion(ApparentEnergy<double>.QuantityType, ApparentEnergy<double>.Zero);
+            Assertion(ApparentPower<double>.QuantityType, ApparentPower<double>.Zero);
+            Assertion(Area<double>.QuantityType, Area<double>.Zero);
+            Assertion(AreaDensity<double>.QuantityType, AreaDensity<double>.Zero);
+            Assertion(AreaMomentOfInertia<double>.QuantityType, AreaMomentOfInertia<double>.Zero);
+            Assertion(BitRate<double>.QuantityType, BitRate<double>.Zero);
+            Assertion(BrakeSpecificFuelConsumption<double>.QuantityType, BrakeSpecificFuelConsumption<double>.Zero);
+            Assertion(Capacitance<double>.QuantityType, Capacitance<double>.Zero);
+            Assertion(CoefficientOfThermalExpansion<double>.QuantityType, CoefficientOfThermalExpansion<double>.Zero);
+            Assertion(Density<double>.QuantityType, Density<double>.Zero);
+            Assertion(Duration<double>.QuantityType, Duration<double>.Zero);
+            Assertion(DynamicViscosity<double>.QuantityType, DynamicViscosity<double>.Zero);
+            Assertion(ElectricAdmittance<double>.QuantityType, ElectricAdmittance<double>.Zero);
+            Assertion(ElectricCharge<double>.QuantityType, ElectricCharge<double>.Zero);
+            Assertion(ElectricChargeDensity<double>.QuantityType, ElectricChargeDensity<double>.Zero);
+            Assertion(ElectricConductance<double>.QuantityType, ElectricConductance<double>.Zero);
+            Assertion(ElectricConductivity<double>.QuantityType, ElectricConductivity<double>.Zero);
+            Assertion(ElectricCurrent<double>.QuantityType, ElectricCurrent<double>.Zero);
+            Assertion(ElectricCurrentDensity<double>.QuantityType, ElectricCurrentDensity<double>.Zero);
+            Assertion(ElectricCurrentGradient<double>.QuantityType, ElectricCurrentGradient<double>.Zero);
+            Assertion(ElectricField<double>.QuantityType, ElectricField<double>.Zero);
+            Assertion(ElectricInductance<double>.QuantityType, ElectricInductance<double>.Zero);
+            Assertion(ElectricPotential<double>.QuantityType, ElectricPotential<double>.Zero);
+            Assertion(ElectricPotentialAc<double>.QuantityType, ElectricPotentialAc<double>.Zero);
+            Assertion(ElectricPotentialChangeRate<double>.QuantityType, ElectricPotentialChangeRate<double>.Zero);
+            Assertion(ElectricPotentialDc<double>.QuantityType, ElectricPotentialDc<double>.Zero);
+            Assertion(ElectricResistance<double>.QuantityType, ElectricResistance<double>.Zero);
+            Assertion(ElectricResistivity<double>.QuantityType, ElectricResistivity<double>.Zero);
+            Assertion(ElectricSurfaceChargeDensity<double>.QuantityType, ElectricSurfaceChargeDensity<double>.Zero);
+            Assertion(Energy<double>.QuantityType, Energy<double>.Zero);
+            Assertion(Entropy<double>.QuantityType, Entropy<double>.Zero);
+            Assertion(Force<double>.QuantityType, Force<double>.Zero);
+            Assertion(ForceChangeRate<double>.QuantityType, ForceChangeRate<double>.Zero);
+            Assertion(ForcePerLength<double>.QuantityType, ForcePerLength<double>.Zero);
+            Assertion(Frequency<double>.QuantityType, Frequency<double>.Zero);
+            Assertion(FuelEfficiency<double>.QuantityType, FuelEfficiency<double>.Zero);
+            Assertion(HeatFlux<double>.QuantityType, HeatFlux<double>.Zero);
+            Assertion(HeatTransferCoefficient<double>.QuantityType, HeatTransferCoefficient<double>.Zero);
+            Assertion(Illuminance<double>.QuantityType, Illuminance<double>.Zero);
+            Assertion(Information<double>.QuantityType, Information<double>.Zero);
+            Assertion(Irradiance<double>.QuantityType, Irradiance<double>.Zero);
+            Assertion(Irradiation<double>.QuantityType, Irradiation<double>.Zero);
+            Assertion(KinematicViscosity<double>.QuantityType, KinematicViscosity<double>.Zero);
+            Assertion(LapseRate<double>.QuantityType, LapseRate<double>.Zero);
+            Assertion(Length<double>.QuantityType, Length<double>.Zero);
+            Assertion(Level<double>.QuantityType, Level<double>.Zero);
+            Assertion(LinearDensity<double>.QuantityType, LinearDensity<double>.Zero);
+            Assertion(LinearPowerDensity<double>.QuantityType, LinearPowerDensity<double>.Zero);
+            Assertion(Luminosity<double>.QuantityType, Luminosity<double>.Zero);
+            Assertion(LuminousFlux<double>.QuantityType, LuminousFlux<double>.Zero);
+            Assertion(LuminousIntensity<double>.QuantityType, LuminousIntensity<double>.Zero);
+            Assertion(MagneticField<double>.QuantityType, MagneticField<double>.Zero);
+            Assertion(MagneticFlux<double>.QuantityType, MagneticFlux<double>.Zero);
+            Assertion(Magnetization<double>.QuantityType, Magnetization<double>.Zero);
+            Assertion(Mass<double>.QuantityType, Mass<double>.Zero);
+            Assertion(MassConcentration<double>.QuantityType, MassConcentration<double>.Zero);
+            Assertion(MassFlow<double>.QuantityType, MassFlow<double>.Zero);
+            Assertion(MassFlux<double>.QuantityType, MassFlux<double>.Zero);
+            Assertion(MassFraction<double>.QuantityType, MassFraction<double>.Zero);
+            Assertion(MassMomentOfInertia<double>.QuantityType, MassMomentOfInertia<double>.Zero);
+            Assertion(MolarEnergy<double>.QuantityType, MolarEnergy<double>.Zero);
+            Assertion(MolarEntropy<double>.QuantityType, MolarEntropy<double>.Zero);
+            Assertion(Molarity<double>.QuantityType, Molarity<double>.Zero);
+            Assertion(MolarMass<double>.QuantityType, MolarMass<double>.Zero);
+            Assertion(Permeability<double>.QuantityType, Permeability<double>.Zero);
+            Assertion(Permittivity<double>.QuantityType, Permittivity<double>.Zero);
+            Assertion(Power<double>.QuantityType, Power<double>.Zero);
+            Assertion(PowerDensity<double>.QuantityType, PowerDensity<double>.Zero);
+            Assertion(PowerRatio<double>.QuantityType, PowerRatio<double>.Zero);
+            Assertion(Pressure<double>.QuantityType, Pressure<double>.Zero);
+            Assertion(PressureChangeRate<double>.QuantityType, PressureChangeRate<double>.Zero);
+            Assertion(Ratio<double>.QuantityType, Ratio<double>.Zero);
+            Assertion(RatioChangeRate<double>.QuantityType, RatioChangeRate<double>.Zero);
+            Assertion(ReactiveEnergy<double>.QuantityType, ReactiveEnergy<double>.Zero);
+            Assertion(ReactivePower<double>.QuantityType, ReactivePower<double>.Zero);
+            Assertion(RelativeHumidity<double>.QuantityType, RelativeHumidity<double>.Zero);
+            Assertion(RotationalAcceleration<double>.QuantityType, RotationalAcceleration<double>.Zero);
+            Assertion(RotationalSpeed<double>.QuantityType, RotationalSpeed<double>.Zero);
+            Assertion(RotationalStiffness<double>.QuantityType, RotationalStiffness<double>.Zero);
+            Assertion(RotationalStiffnessPerLength<double>.QuantityType, RotationalStiffnessPerLength<double>.Zero);
+            Assertion(SolidAngle<double>.QuantityType, SolidAngle<double>.Zero);
+            Assertion(SpecificEnergy<double>.QuantityType, SpecificEnergy<double>.Zero);
+            Assertion(SpecificEntropy<double>.QuantityType, SpecificEntropy<double>.Zero);
+            Assertion(SpecificVolume<double>.QuantityType, SpecificVolume<double>.Zero);
+            Assertion(SpecificWeight<double>.QuantityType, SpecificWeight<double>.Zero);
+            Assertion(Speed<double>.QuantityType, Speed<double>.Zero);
+            Assertion(Temperature<double>.QuantityType, Temperature<double>.Zero);
+            Assertion(TemperatureChangeRate<double>.QuantityType, TemperatureChangeRate<double>.Zero);
+            Assertion(TemperatureDelta<double>.QuantityType, TemperatureDelta<double>.Zero);
+            Assertion(ThermalConductivity<double>.QuantityType, ThermalConductivity<double>.Zero);
+            Assertion(ThermalResistance<double>.QuantityType, ThermalResistance<double>.Zero);
+            Assertion(Torque<double>.QuantityType, Torque<double>.Zero);
+            Assertion(TorquePerLength<double>.QuantityType, TorquePerLength<double>.Zero);
+            Assertion(Turbidity<double>.QuantityType, Turbidity<double>.Zero);
+            Assertion(VitaminA<double>.QuantityType, VitaminA<double>.Zero);
+            Assertion(Volume<double>.QuantityType, Volume<double>.Zero);
+            Assertion(VolumeConcentration<double>.QuantityType, VolumeConcentration<double>.Zero);
+            Assertion(VolumeFlow<double>.QuantityType, VolumeFlow<double>.Zero);
+            Assertion(VolumePerLength<double>.QuantityType, VolumePerLength<double>.Zero);
+            Assertion(WarpingMomentOfInertia<double>.QuantityType, WarpingMomentOfInertia<double>.Zero);
         }
 
         [Fact]
@@ -367,110 +367,110 @@ public void Dimensions_IsSameAsStaticBaseDimensions()
         {
             void Assertion(BaseDimensions expected, IQuantity quantity) => Assert.Equal(expected, quantity.Dimensions);
 
-            Assertion(Acceleration.BaseDimensions, Acceleration.Zero);
-            Assertion(AmountOfSubstance.BaseDimensions, AmountOfSubstance.Zero);
-            Assertion(AmplitudeRatio.BaseDimensions, AmplitudeRatio.Zero);
-            Assertion(Angle.BaseDimensions, Angle.Zero);
-            Assertion(ApparentEnergy.BaseDimensions, ApparentEnergy.Zero);
-            Assertion(ApparentPower.BaseDimensions, ApparentPower.Zero);
-            Assertion(Area.BaseDimensions, Area.Zero);
-            Assertion(AreaDensity.BaseDimensions, AreaDensity.Zero);
-            Assertion(AreaMomentOfInertia.BaseDimensions, AreaMomentOfInertia.Zero);
-            Assertion(BitRate.BaseDimensions, BitRate.Zero);
-            Assertion(BrakeSpecificFuelConsumption.BaseDimensions, BrakeSpecificFuelConsumption.Zero);
-            Assertion(Capacitance.BaseDimensions, Capacitance.Zero);
-            Assertion(CoefficientOfThermalExpansion.BaseDimensions, CoefficientOfThermalExpansion.Zero);
-            Assertion(Density.BaseDimensions, Density.Zero);
-            Assertion(Duration.BaseDimensions, Duration.Zero);
-            Assertion(DynamicViscosity.BaseDimensions, DynamicViscosity.Zero);
-            Assertion(ElectricAdmittance.BaseDimensions, ElectricAdmittance.Zero);
-            Assertion(ElectricCharge.BaseDimensions, ElectricCharge.Zero);
-            Assertion(ElectricChargeDensity.BaseDimensions, ElectricChargeDensity.Zero);
-            Assertion(ElectricConductance.BaseDimensions, ElectricConductance.Zero);
-            Assertion(ElectricConductivity.BaseDimensions, ElectricConductivity.Zero);
-            Assertion(ElectricCurrent.BaseDimensions, ElectricCurrent.Zero);
-            Assertion(ElectricCurrentDensity.BaseDimensions, ElectricCurrentDensity.Zero);
-            Assertion(ElectricCurrentGradient.BaseDimensions, ElectricCurrentGradient.Zero);
-            Assertion(ElectricField.BaseDimensions, ElectricField.Zero);
-            Assertion(ElectricInductance.BaseDimensions, ElectricInductance.Zero);
-            Assertion(ElectricPotential.BaseDimensions, ElectricPotential.Zero);
-            Assertion(ElectricPotentialAc.BaseDimensions, ElectricPotentialAc.Zero);
-            Assertion(ElectricPotentialChangeRate.BaseDimensions, ElectricPotentialChangeRate.Zero);
-            Assertion(ElectricPotentialDc.BaseDimensions, ElectricPotentialDc.Zero);
-            Assertion(ElectricResistance.BaseDimensions, ElectricResistance.Zero);
-            Assertion(ElectricResistivity.BaseDimensions, ElectricResistivity.Zero);
-            Assertion(ElectricSurfaceChargeDensity.BaseDimensions, ElectricSurfaceChargeDensity.Zero);
-            Assertion(Energy.BaseDimensions, Energy.Zero);
-            Assertion(Entropy.BaseDimensions, Entropy.Zero);
-            Assertion(Force.BaseDimensions, Force.Zero);
-            Assertion(ForceChangeRate.BaseDimensions, ForceChangeRate.Zero);
-            Assertion(ForcePerLength.BaseDimensions, ForcePerLength.Zero);
-            Assertion(Frequency.BaseDimensions, Frequency.Zero);
-            Assertion(FuelEfficiency.BaseDimensions, FuelEfficiency.Zero);
-            Assertion(HeatFlux.BaseDimensions, HeatFlux.Zero);
-            Assertion(HeatTransferCoefficient.BaseDimensions, HeatTransferCoefficient.Zero);
-            Assertion(Illuminance.BaseDimensions, Illuminance.Zero);
-            Assertion(Information.BaseDimensions, Information.Zero);
-            Assertion(Irradiance.BaseDimensions, Irradiance.Zero);
-            Assertion(Irradiation.BaseDimensions, Irradiation.Zero);
-            Assertion(KinematicViscosity.BaseDimensions, KinematicViscosity.Zero);
-            Assertion(LapseRate.BaseDimensions, LapseRate.Zero);
-            Assertion(Length.BaseDimensions, Length.Zero);
-            Assertion(Level.BaseDimensions, Level.Zero);
-            Assertion(LinearDensity.BaseDimensions, LinearDensity.Zero);
-            Assertion(LinearPowerDensity.BaseDimensions, LinearPowerDensity.Zero);
-            Assertion(Luminosity.BaseDimensions, Luminosity.Zero);
-            Assertion(LuminousFlux.BaseDimensions, LuminousFlux.Zero);
-            Assertion(LuminousIntensity.BaseDimensions, LuminousIntensity.Zero);
-            Assertion(MagneticField.BaseDimensions, MagneticField.Zero);
-            Assertion(MagneticFlux.BaseDimensions, MagneticFlux.Zero);
-            Assertion(Magnetization.BaseDimensions, Magnetization.Zero);
-            Assertion(Mass.BaseDimensions, Mass.Zero);
-            Assertion(MassConcentration.BaseDimensions, MassConcentration.Zero);
-            Assertion(MassFlow.BaseDimensions, MassFlow.Zero);
-            Assertion(MassFlux.BaseDimensions, MassFlux.Zero);
-            Assertion(MassFraction.BaseDimensions, MassFraction.Zero);
-            Assertion(MassMomentOfInertia.BaseDimensions, MassMomentOfInertia.Zero);
-            Assertion(MolarEnergy.BaseDimensions, MolarEnergy.Zero);
-            Assertion(MolarEntropy.BaseDimensions, MolarEntropy.Zero);
-            Assertion(Molarity.BaseDimensions, Molarity.Zero);
-            Assertion(MolarMass.BaseDimensions, MolarMass.Zero);
-            Assertion(Permeability.BaseDimensions, Permeability.Zero);
-            Assertion(Permittivity.BaseDimensions, Permittivity.Zero);
-            Assertion(Power.BaseDimensions, Power.Zero);
-            Assertion(PowerDensity.BaseDimensions, PowerDensity.Zero);
-            Assertion(PowerRatio.BaseDimensions, PowerRatio.Zero);
-            Assertion(Pressure.BaseDimensions, Pressure.Zero);
-            Assertion(PressureChangeRate.BaseDimensions, PressureChangeRate.Zero);
-            Assertion(Ratio.BaseDimensions, Ratio.Zero);
-            Assertion(RatioChangeRate.BaseDimensions, RatioChangeRate.Zero);
-            Assertion(ReactiveEnergy.BaseDimensions, ReactiveEnergy.Zero);
-            Assertion(ReactivePower.BaseDimensions, ReactivePower.Zero);
-            Assertion(RelativeHumidity.BaseDimensions, RelativeHumidity.Zero);
-            Assertion(RotationalAcceleration.BaseDimensions, RotationalAcceleration.Zero);
-            Assertion(RotationalSpeed.BaseDimensions, RotationalSpeed.Zero);
-            Assertion(RotationalStiffness.BaseDimensions, RotationalStiffness.Zero);
-            Assertion(RotationalStiffnessPerLength.BaseDimensions, RotationalStiffnessPerLength.Zero);
-            Assertion(SolidAngle.BaseDimensions, SolidAngle.Zero);
-            Assertion(SpecificEnergy.BaseDimensions, SpecificEnergy.Zero);
-            Assertion(SpecificEntropy.BaseDimensions, SpecificEntropy.Zero);
-            Assertion(SpecificVolume.BaseDimensions, SpecificVolume.Zero);
-            Assertion(SpecificWeight.BaseDimensions, SpecificWeight.Zero);
-            Assertion(Speed.BaseDimensions, Speed.Zero);
-            Assertion(Temperature.BaseDimensions, Temperature.Zero);
-            Assertion(TemperatureChangeRate.BaseDimensions, TemperatureChangeRate.Zero);
-            Assertion(TemperatureDelta.BaseDimensions, TemperatureDelta.Zero);
-            Assertion(ThermalConductivity.BaseDimensions, ThermalConductivity.Zero);
-            Assertion(ThermalResistance.BaseDimensions, ThermalResistance.Zero);
-            Assertion(Torque.BaseDimensions, Torque.Zero);
-            Assertion(TorquePerLength.BaseDimensions, TorquePerLength.Zero);
-            Assertion(Turbidity.BaseDimensions, Turbidity.Zero);
-            Assertion(VitaminA.BaseDimensions, VitaminA.Zero);
-            Assertion(Volume.BaseDimensions, Volume.Zero);
-            Assertion(VolumeConcentration.BaseDimensions, VolumeConcentration.Zero);
-            Assertion(VolumeFlow.BaseDimensions, VolumeFlow.Zero);
-            Assertion(VolumePerLength.BaseDimensions, VolumePerLength.Zero);
-            Assertion(WarpingMomentOfInertia.BaseDimensions, WarpingMomentOfInertia.Zero);
+            Assertion(Acceleration<double>.BaseDimensions, Acceleration<double>.Zero);
+            Assertion(AmountOfSubstance<double>.BaseDimensions, AmountOfSubstance<double>.Zero);
+            Assertion(AmplitudeRatio<double>.BaseDimensions, AmplitudeRatio<double>.Zero);
+            Assertion(Angle<double>.BaseDimensions, Angle<double>.Zero);
+            Assertion(ApparentEnergy<double>.BaseDimensions, ApparentEnergy<double>.Zero);
+            Assertion(ApparentPower<double>.BaseDimensions, ApparentPower<double>.Zero);
+            Assertion(Area<double>.BaseDimensions, Area<double>.Zero);
+            Assertion(AreaDensity<double>.BaseDimensions, AreaDensity<double>.Zero);
+            Assertion(AreaMomentOfInertia<double>.BaseDimensions, AreaMomentOfInertia<double>.Zero);
+            Assertion(BitRate<double>.BaseDimensions, BitRate<double>.Zero);
+            Assertion(BrakeSpecificFuelConsumption<double>.BaseDimensions, BrakeSpecificFuelConsumption<double>.Zero);
+            Assertion(Capacitance<double>.BaseDimensions, Capacitance<double>.Zero);
+            Assertion(CoefficientOfThermalExpansion<double>.BaseDimensions, CoefficientOfThermalExpansion<double>.Zero);
+            Assertion(Density<double>.BaseDimensions, Density<double>.Zero);
+            Assertion(Duration<double>.BaseDimensions, Duration<double>.Zero);
+            Assertion(DynamicViscosity<double>.BaseDimensions, DynamicViscosity<double>.Zero);
+            Assertion(ElectricAdmittance<double>.BaseDimensions, ElectricAdmittance<double>.Zero);
+            Assertion(ElectricCharge<double>.BaseDimensions, ElectricCharge<double>.Zero);
+            Assertion(ElectricChargeDensity<double>.BaseDimensions, ElectricChargeDensity<double>.Zero);
+            Assertion(ElectricConductance<double>.BaseDimensions, ElectricConductance<double>.Zero);
+            Assertion(ElectricConductivity<double>.BaseDimensions, ElectricConductivity<double>.Zero);
+            Assertion(ElectricCurrent<double>.BaseDimensions, ElectricCurrent<double>.Zero);
+            Assertion(ElectricCurrentDensity<double>.BaseDimensions, ElectricCurrentDensity<double>.Zero);
+            Assertion(ElectricCurrentGradient<double>.BaseDimensions, ElectricCurrentGradient<double>.Zero);
+            Assertion(ElectricField<double>.BaseDimensions, ElectricField<double>.Zero);
+            Assertion(ElectricInductance<double>.BaseDimensions, ElectricInductance<double>.Zero);
+            Assertion(ElectricPotential<double>.BaseDimensions, ElectricPotential<double>.Zero);
+            Assertion(ElectricPotentialAc<double>.BaseDimensions, ElectricPotentialAc<double>.Zero);
+            Assertion(ElectricPotentialChangeRate<double>.BaseDimensions, ElectricPotentialChangeRate<double>.Zero);
+            Assertion(ElectricPotentialDc<double>.BaseDimensions, ElectricPotentialDc<double>.Zero);
+            Assertion(ElectricResistance<double>.BaseDimensions, ElectricResistance<double>.Zero);
+            Assertion(ElectricResistivity<double>.BaseDimensions, ElectricResistivity<double>.Zero);
+            Assertion(ElectricSurfaceChargeDensity<double>.BaseDimensions, ElectricSurfaceChargeDensity<double>.Zero);
+            Assertion(Energy<double>.BaseDimensions, Energy<double>.Zero);
+            Assertion(Entropy<double>.BaseDimensions, Entropy<double>.Zero);
+            Assertion(Force<double>.BaseDimensions, Force<double>.Zero);
+            Assertion(ForceChangeRate<double>.BaseDimensions, ForceChangeRate<double>.Zero);
+            Assertion(ForcePerLength<double>.BaseDimensions, ForcePerLength<double>.Zero);
+            Assertion(Frequency<double>.BaseDimensions, Frequency<double>.Zero);
+            Assertion(FuelEfficiency<double>.BaseDimensions, FuelEfficiency<double>.Zero);
+            Assertion(HeatFlux<double>.BaseDimensions, HeatFlux<double>.Zero);
+            Assertion(HeatTransferCoefficient<double>.BaseDimensions, HeatTransferCoefficient<double>.Zero);
+            Assertion(Illuminance<double>.BaseDimensions, Illuminance<double>.Zero);
+            Assertion(Information<double>.BaseDimensions, Information<double>.Zero);
+            Assertion(Irradiance<double>.BaseDimensions, Irradiance<double>.Zero);
+            Assertion(Irradiation<double>.BaseDimensions, Irradiation<double>.Zero);
+            Assertion(KinematicViscosity<double>.BaseDimensions, KinematicViscosity<double>.Zero);
+            Assertion(LapseRate<double>.BaseDimensions, LapseRate<double>.Zero);
+            Assertion(Length<double>.BaseDimensions, Length<double>.Zero);
+            Assertion(Level<double>.BaseDimensions, Level<double>.Zero);
+            Assertion(LinearDensity<double>.BaseDimensions, LinearDensity<double>.Zero);
+            Assertion(LinearPowerDensity<double>.BaseDimensions, LinearPowerDensity<double>.Zero);
+            Assertion(Luminosity<double>.BaseDimensions, Luminosity<double>.Zero);
+            Assertion(LuminousFlux<double>.BaseDimensions, LuminousFlux<double>.Zero);
+            Assertion(LuminousIntensity<double>.BaseDimensions, LuminousIntensity<double>.Zero);
+            Assertion(MagneticField<double>.BaseDimensions, MagneticField<double>.Zero);
+            Assertion(MagneticFlux<double>.BaseDimensions, MagneticFlux<double>.Zero);
+            Assertion(Magnetization<double>.BaseDimensions, Magnetization<double>.Zero);
+            Assertion(Mass<double>.BaseDimensions, Mass<double>.Zero);
+            Assertion(MassConcentration<double>.BaseDimensions, MassConcentration<double>.Zero);
+            Assertion(MassFlow<double>.BaseDimensions, MassFlow<double>.Zero);
+            Assertion(MassFlux<double>.BaseDimensions, MassFlux<double>.Zero);
+            Assertion(MassFraction<double>.BaseDimensions, MassFraction<double>.Zero);
+            Assertion(MassMomentOfInertia<double>.BaseDimensions, MassMomentOfInertia<double>.Zero);
+            Assertion(MolarEnergy<double>.BaseDimensions, MolarEnergy<double>.Zero);
+            Assertion(MolarEntropy<double>.BaseDimensions, MolarEntropy<double>.Zero);
+            Assertion(Molarity<double>.BaseDimensions, Molarity<double>.Zero);
+            Assertion(MolarMass<double>.BaseDimensions, MolarMass<double>.Zero);
+            Assertion(Permeability<double>.BaseDimensions, Permeability<double>.Zero);
+            Assertion(Permittivity<double>.BaseDimensions, Permittivity<double>.Zero);
+            Assertion(Power<double>.BaseDimensions, Power<double>.Zero);
+            Assertion(PowerDensity<double>.BaseDimensions, PowerDensity<double>.Zero);
+            Assertion(PowerRatio<double>.BaseDimensions, PowerRatio<double>.Zero);
+            Assertion(Pressure<double>.BaseDimensions, Pressure<double>.Zero);
+            Assertion(PressureChangeRate<double>.BaseDimensions, PressureChangeRate<double>.Zero);
+            Assertion(Ratio<double>.BaseDimensions, Ratio<double>.Zero);
+            Assertion(RatioChangeRate<double>.BaseDimensions, RatioChangeRate<double>.Zero);
+            Assertion(ReactiveEnergy<double>.BaseDimensions, ReactiveEnergy<double>.Zero);
+            Assertion(ReactivePower<double>.BaseDimensions, ReactivePower<double>.Zero);
+            Assertion(RelativeHumidity<double>.BaseDimensions, RelativeHumidity<double>.Zero);
+            Assertion(RotationalAcceleration<double>.BaseDimensions, RotationalAcceleration<double>.Zero);
+            Assertion(RotationalSpeed<double>.BaseDimensions, RotationalSpeed<double>.Zero);
+            Assertion(RotationalStiffness<double>.BaseDimensions, RotationalStiffness<double>.Zero);
+            Assertion(RotationalStiffnessPerLength<double>.BaseDimensions, RotationalStiffnessPerLength<double>.Zero);
+            Assertion(SolidAngle<double>.BaseDimensions, SolidAngle<double>.Zero);
+            Assertion(SpecificEnergy<double>.BaseDimensions, SpecificEnergy<double>.Zero);
+            Assertion(SpecificEntropy<double>.BaseDimensions, SpecificEntropy<double>.Zero);
+            Assertion(SpecificVolume<double>.BaseDimensions, SpecificVolume<double>.Zero);
+            Assertion(SpecificWeight<double>.BaseDimensions, SpecificWeight<double>.Zero);
+            Assertion(Speed<double>.BaseDimensions, Speed<double>.Zero);
+            Assertion(Temperature<double>.BaseDimensions, Temperature<double>.Zero);
+            Assertion(TemperatureChangeRate<double>.BaseDimensions, TemperatureChangeRate<double>.Zero);
+            Assertion(TemperatureDelta<double>.BaseDimensions, TemperatureDelta<double>.Zero);
+            Assertion(ThermalConductivity<double>.BaseDimensions, ThermalConductivity<double>.Zero);
+            Assertion(ThermalResistance<double>.BaseDimensions, ThermalResistance<double>.Zero);
+            Assertion(Torque<double>.BaseDimensions, Torque<double>.Zero);
+            Assertion(TorquePerLength<double>.BaseDimensions, TorquePerLength<double>.Zero);
+            Assertion(Turbidity<double>.BaseDimensions, Turbidity<double>.Zero);
+            Assertion(VitaminA<double>.BaseDimensions, VitaminA<double>.Zero);
+            Assertion(Volume<double>.BaseDimensions, Volume<double>.Zero);
+            Assertion(VolumeConcentration<double>.BaseDimensions, VolumeConcentration<double>.Zero);
+            Assertion(VolumeFlow<double>.BaseDimensions, VolumeFlow<double>.Zero);
+            Assertion(VolumePerLength<double>.BaseDimensions, VolumePerLength<double>.Zero);
+            Assertion(WarpingMomentOfInertia<double>.BaseDimensions, WarpingMomentOfInertia<double>.Zero);
         }
     }
 }
diff --git a/UnitsNet.Tests/GeneratedCode/IlluminanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/IlluminanceTestsBase.g.cs
new file mode 100644
index 0000000000..f35ce71806
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/IlluminanceTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Illuminance.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class IlluminanceTestsBase
+    {
+        protected abstract double KiloluxInOneLux { get; }
+        protected abstract double LuxInOneLux { get; }
+        protected abstract double MegaluxInOneLux { get; }
+        protected abstract double MilliluxInOneLux { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KiloluxTolerance { get { return 1e-5; } }
+        protected virtual double LuxTolerance { get { return 1e-5; } }
+        protected virtual double MegaluxTolerance { get { return 1e-5; } }
+        protected virtual double MilliluxTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>((double)0.0, IlluminanceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>(double.PositiveInfinity, IlluminanceUnit.Lux));
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>(double.NegativeInfinity, IlluminanceUnit.Lux));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>(double.NaN, IlluminanceUnit.Lux));
+        }
+
+        [Fact]
+        public void LuxToIlluminanceUnits()
+        {
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            AssertEx.EqualTolerance(KiloluxInOneLux, lux.Kilolux, KiloluxTolerance);
+            AssertEx.EqualTolerance(LuxInOneLux, lux.Lux, LuxTolerance);
+            AssertEx.EqualTolerance(MegaluxInOneLux, lux.Megalux, MegaluxTolerance);
+            AssertEx.EqualTolerance(MilliluxInOneLux, lux.Millilux, MilliluxTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Illuminance<double>.From(1, IlluminanceUnit.Kilolux).Kilolux, KiloluxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.From(1, IlluminanceUnit.Lux).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.From(1, IlluminanceUnit.Megalux).Megalux, MegaluxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.From(1, IlluminanceUnit.Millilux).Millilux, MilliluxTolerance);
+        }
+
+        [Fact]
+        public void FromLux_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Illuminance<double>.FromLux(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Illuminance<double>.FromLux(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromLux_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Illuminance<double>.FromLux(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var lux = Illuminance<double>.FromLux(1);
+            AssertEx.EqualTolerance(KiloluxInOneLux, lux.As(IlluminanceUnit.Kilolux), KiloluxTolerance);
+            AssertEx.EqualTolerance(LuxInOneLux, lux.As(IlluminanceUnit.Lux), LuxTolerance);
+            AssertEx.EqualTolerance(MegaluxInOneLux, lux.As(IlluminanceUnit.Megalux), MegaluxTolerance);
+            AssertEx.EqualTolerance(MilliluxInOneLux, lux.As(IlluminanceUnit.Millilux), MilliluxTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var lux = Illuminance<double>.FromLux(1);
+
+            var kiloluxQuantity = lux.ToUnit(IlluminanceUnit.Kilolux);
+            AssertEx.EqualTolerance(KiloluxInOneLux, (double)kiloluxQuantity.Value, KiloluxTolerance);
+            Assert.Equal(IlluminanceUnit.Kilolux, kiloluxQuantity.Unit);
+
+            var luxQuantity = lux.ToUnit(IlluminanceUnit.Lux);
+            AssertEx.EqualTolerance(LuxInOneLux, (double)luxQuantity.Value, LuxTolerance);
+            Assert.Equal(IlluminanceUnit.Lux, luxQuantity.Unit);
+
+            var megaluxQuantity = lux.ToUnit(IlluminanceUnit.Megalux);
+            AssertEx.EqualTolerance(MegaluxInOneLux, (double)megaluxQuantity.Value, MegaluxTolerance);
+            Assert.Equal(IlluminanceUnit.Megalux, megaluxQuantity.Unit);
+
+            var milliluxQuantity = lux.ToUnit(IlluminanceUnit.Millilux);
+            AssertEx.EqualTolerance(MilliluxInOneLux, (double)milliluxQuantity.Value, MilliluxTolerance);
+            Assert.Equal(IlluminanceUnit.Millilux, milliluxQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromKilolux(lux.Kilolux).Lux, KiloluxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromLux(lux.Lux).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromMegalux(lux.Megalux).Lux, MegaluxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromMillilux(lux.Millilux).Lux, MilliluxTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Illuminance<double> v = Illuminance<double>.FromLux(1);
+            AssertEx.EqualTolerance(-1, -v.Lux, LuxTolerance);
+            AssertEx.EqualTolerance(2, (Illuminance<double>.FromLux(3)-v).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(2, (Illuminance<double>.FromLux(10)/5).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(2, Illuminance<double>.FromLux(10)/Illuminance<double>.FromLux(5), LuxTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Illuminance<double> oneLux = Illuminance<double>.FromLux(1);
+            Illuminance<double> twoLux = Illuminance<double>.FromLux(2);
+
+            Assert.True(oneLux < twoLux);
+            Assert.True(oneLux <= twoLux);
+            Assert.True(twoLux > oneLux);
+            Assert.True(twoLux >= oneLux);
+
+            Assert.False(oneLux > twoLux);
+            Assert.False(oneLux >= twoLux);
+            Assert.False(twoLux < oneLux);
+            Assert.False(twoLux <= oneLux);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            Assert.Equal(0, lux.CompareTo(lux));
+            Assert.True(lux.CompareTo(Illuminance<double>.Zero) > 0);
+            Assert.True(Illuminance<double>.Zero.CompareTo(lux) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            Assert.Throws<ArgumentException>(() => lux.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            Assert.Throws<ArgumentNullException>(() => lux.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Illuminance<double>.FromLux(1);
+            var b = Illuminance<double>.FromLux(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Illuminance<double>.FromLux(1);
+            var b = Illuminance<double>.FromLux(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Illuminance<double>.FromLux(1);
+            Assert.True(v.Equals(Illuminance<double>.FromLux(1), LuxTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Illuminance<double>.Zero, LuxTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            Assert.False(lux.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            Assert.False(lux.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(IlluminanceUnit.Undefined, Illuminance<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(IlluminanceUnit)).Cast<IlluminanceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == IlluminanceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Illuminance<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs
new file mode 100644
index 0000000000..87da61ec68
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs
@@ -0,0 +1,313 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of KinematicViscosity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class KinematicViscosityTestsBase
+    {
+        protected abstract double CentistokesInOneSquareMeterPerSecond { get; }
+        protected abstract double DecistokesInOneSquareMeterPerSecond { get; }
+        protected abstract double KilostokesInOneSquareMeterPerSecond { get; }
+        protected abstract double MicrostokesInOneSquareMeterPerSecond { get; }
+        protected abstract double MillistokesInOneSquareMeterPerSecond { get; }
+        protected abstract double NanostokesInOneSquareMeterPerSecond { get; }
+        protected abstract double SquareMetersPerSecondInOneSquareMeterPerSecond { get; }
+        protected abstract double StokesInOneSquareMeterPerSecond { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CentistokesTolerance { get { return 1e-5; } }
+        protected virtual double DecistokesTolerance { get { return 1e-5; } }
+        protected virtual double KilostokesTolerance { get { return 1e-5; } }
+        protected virtual double MicrostokesTolerance { get { return 1e-5; } }
+        protected virtual double MillistokesTolerance { get { return 1e-5; } }
+        protected virtual double NanostokesTolerance { get { return 1e-5; } }
+        protected virtual double SquareMetersPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double StokesTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>((double)0.0, KinematicViscosityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>(double.PositiveInfinity, KinematicViscosityUnit.SquareMeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>(double.NegativeInfinity, KinematicViscosityUnit.SquareMeterPerSecond));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>(double.NaN, KinematicViscosityUnit.SquareMeterPerSecond));
+        }
+
+        [Fact]
+        public void SquareMeterPerSecondToKinematicViscosityUnits()
+        {
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, squaremeterpersecond.Centistokes, CentistokesTolerance);
+            AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, squaremeterpersecond.Decistokes, DecistokesTolerance);
+            AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, squaremeterpersecond.Kilostokes, KilostokesTolerance);
+            AssertEx.EqualTolerance(MicrostokesInOneSquareMeterPerSecond, squaremeterpersecond.Microstokes, MicrostokesTolerance);
+            AssertEx.EqualTolerance(MillistokesInOneSquareMeterPerSecond, squaremeterpersecond.Millistokes, MillistokesTolerance);
+            AssertEx.EqualTolerance(NanostokesInOneSquareMeterPerSecond, squaremeterpersecond.Nanostokes, NanostokesTolerance);
+            AssertEx.EqualTolerance(SquareMetersPerSecondInOneSquareMeterPerSecond, squaremeterpersecond.SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(StokesInOneSquareMeterPerSecond, squaremeterpersecond.Stokes, StokesTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.Centistokes).Centistokes, CentistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.Decistokes).Decistokes, DecistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.Kilostokes).Kilostokes, KilostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.Microstokes).Microstokes, MicrostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.Millistokes).Millistokes, MillistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.Nanostokes).Nanostokes, NanostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.SquareMeterPerSecond).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.From(1, KinematicViscosityUnit.Stokes).Stokes, StokesTolerance);
+        }
+
+        [Fact]
+        public void FromSquareMetersPerSecond_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => KinematicViscosity<double>.FromSquareMetersPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => KinematicViscosity<double>.FromSquareMetersPerSecond(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromSquareMetersPerSecond_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => KinematicViscosity<double>.FromSquareMetersPerSecond(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Centistokes), CentistokesTolerance);
+            AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Decistokes), DecistokesTolerance);
+            AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Kilostokes), KilostokesTolerance);
+            AssertEx.EqualTolerance(MicrostokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Microstokes), MicrostokesTolerance);
+            AssertEx.EqualTolerance(MillistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Millistokes), MillistokesTolerance);
+            AssertEx.EqualTolerance(NanostokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Nanostokes), NanostokesTolerance);
+            AssertEx.EqualTolerance(SquareMetersPerSecondInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.SquareMeterPerSecond), SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(StokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Stokes), StokesTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+
+            var centistokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Centistokes);
+            AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, (double)centistokesQuantity.Value, CentistokesTolerance);
+            Assert.Equal(KinematicViscosityUnit.Centistokes, centistokesQuantity.Unit);
+
+            var decistokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Decistokes);
+            AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, (double)decistokesQuantity.Value, DecistokesTolerance);
+            Assert.Equal(KinematicViscosityUnit.Decistokes, decistokesQuantity.Unit);
+
+            var kilostokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Kilostokes);
+            AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, (double)kilostokesQuantity.Value, KilostokesTolerance);
+            Assert.Equal(KinematicViscosityUnit.Kilostokes, kilostokesQuantity.Unit);
+
+            var microstokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Microstokes);
+            AssertEx.EqualTolerance(MicrostokesInOneSquareMeterPerSecond, (double)microstokesQuantity.Value, MicrostokesTolerance);
+            Assert.Equal(KinematicViscosityUnit.Microstokes, microstokesQuantity.Unit);
+
+            var millistokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Millistokes);
+            AssertEx.EqualTolerance(MillistokesInOneSquareMeterPerSecond, (double)millistokesQuantity.Value, MillistokesTolerance);
+            Assert.Equal(KinematicViscosityUnit.Millistokes, millistokesQuantity.Unit);
+
+            var nanostokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Nanostokes);
+            AssertEx.EqualTolerance(NanostokesInOneSquareMeterPerSecond, (double)nanostokesQuantity.Value, NanostokesTolerance);
+            Assert.Equal(KinematicViscosityUnit.Nanostokes, nanostokesQuantity.Unit);
+
+            var squaremeterpersecondQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond);
+            AssertEx.EqualTolerance(SquareMetersPerSecondInOneSquareMeterPerSecond, (double)squaremeterpersecondQuantity.Value, SquareMetersPerSecondTolerance);
+            Assert.Equal(KinematicViscosityUnit.SquareMeterPerSecond, squaremeterpersecondQuantity.Unit);
+
+            var stokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Stokes);
+            AssertEx.EqualTolerance(StokesInOneSquareMeterPerSecond, (double)stokesQuantity.Value, StokesTolerance);
+            Assert.Equal(KinematicViscosityUnit.Stokes, stokesQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromCentistokes(squaremeterpersecond.Centistokes).SquareMetersPerSecond, CentistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromDecistokes(squaremeterpersecond.Decistokes).SquareMetersPerSecond, DecistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromKilostokes(squaremeterpersecond.Kilostokes).SquareMetersPerSecond, KilostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromMicrostokes(squaremeterpersecond.Microstokes).SquareMetersPerSecond, MicrostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromMillistokes(squaremeterpersecond.Millistokes).SquareMetersPerSecond, MillistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromNanostokes(squaremeterpersecond.Nanostokes).SquareMetersPerSecond, NanostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromSquareMetersPerSecond(squaremeterpersecond.SquareMetersPerSecond).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromStokes(squaremeterpersecond.Stokes).SquareMetersPerSecond, StokesTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            KinematicViscosity<double> v = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            AssertEx.EqualTolerance(-1, -v.SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (KinematicViscosity<double>.FromSquareMetersPerSecond(3)-v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (v + v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (v*10).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (10*v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (KinematicViscosity<double>.FromSquareMetersPerSecond(10)/5).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, KinematicViscosity<double>.FromSquareMetersPerSecond(10)/KinematicViscosity<double>.FromSquareMetersPerSecond(5), SquareMetersPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            KinematicViscosity<double> oneSquareMeterPerSecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> twoSquareMetersPerSecond = KinematicViscosity<double>.FromSquareMetersPerSecond(2);
+
+            Assert.True(oneSquareMeterPerSecond < twoSquareMetersPerSecond);
+            Assert.True(oneSquareMeterPerSecond <= twoSquareMetersPerSecond);
+            Assert.True(twoSquareMetersPerSecond > oneSquareMeterPerSecond);
+            Assert.True(twoSquareMetersPerSecond >= oneSquareMeterPerSecond);
+
+            Assert.False(oneSquareMeterPerSecond > twoSquareMetersPerSecond);
+            Assert.False(oneSquareMeterPerSecond >= twoSquareMetersPerSecond);
+            Assert.False(twoSquareMetersPerSecond < oneSquareMeterPerSecond);
+            Assert.False(twoSquareMetersPerSecond <= oneSquareMeterPerSecond);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            Assert.Equal(0, squaremeterpersecond.CompareTo(squaremeterpersecond));
+            Assert.True(squaremeterpersecond.CompareTo(KinematicViscosity<double>.Zero) > 0);
+            Assert.True(KinematicViscosity<double>.Zero.CompareTo(squaremeterpersecond) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            Assert.Throws<ArgumentException>(() => squaremeterpersecond.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            Assert.Throws<ArgumentNullException>(() => squaremeterpersecond.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            var b = KinematicViscosity<double>.FromSquareMetersPerSecond(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            var b = KinematicViscosity<double>.FromSquareMetersPerSecond(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            Assert.True(v.Equals(KinematicViscosity<double>.FromSquareMetersPerSecond(1), SquareMetersPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(KinematicViscosity<double>.Zero, SquareMetersPerSecondTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            Assert.False(squaremeterpersecond.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            Assert.False(squaremeterpersecond.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(KinematicViscosityUnit.Undefined, KinematicViscosity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(KinematicViscosityUnit)).Cast<KinematicViscosityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == KinematicViscosityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(KinematicViscosity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/LapseRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LapseRateTestsBase.g.cs
new file mode 100644
index 0000000000..b7c323a250
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/LapseRateTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of LapseRate.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class LapseRateTestsBase
+    {
+        protected abstract double DegreesCelciusPerKilometerInOneDegreeCelsiusPerKilometer { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DegreesCelciusPerKilometerTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>((double)0.0, LapseRateUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>(double.PositiveInfinity, LapseRateUnit.DegreeCelsiusPerKilometer));
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>(double.NegativeInfinity, LapseRateUnit.DegreeCelsiusPerKilometer));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>(double.NaN, LapseRateUnit.DegreeCelsiusPerKilometer));
+        }
+
+        [Fact]
+        public void DegreeCelsiusPerKilometerToLapseRateUnits()
+        {
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            AssertEx.EqualTolerance(DegreesCelciusPerKilometerInOneDegreeCelsiusPerKilometer, degreecelsiusperkilometer.DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, LapseRate<double>.From(1, LapseRateUnit.DegreeCelsiusPerKilometer).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+        }
+
+        [Fact]
+        public void FromDegreesCelciusPerKilometer_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LapseRate<double>.FromDegreesCelciusPerKilometer(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LapseRate<double>.FromDegreesCelciusPerKilometer(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromDegreesCelciusPerKilometer_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LapseRate<double>.FromDegreesCelciusPerKilometer(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            AssertEx.EqualTolerance(DegreesCelciusPerKilometerInOneDegreeCelsiusPerKilometer, degreecelsiusperkilometer.As(LapseRateUnit.DegreeCelsiusPerKilometer), DegreesCelciusPerKilometerTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+
+            var degreecelsiusperkilometerQuantity = degreecelsiusperkilometer.ToUnit(LapseRateUnit.DegreeCelsiusPerKilometer);
+            AssertEx.EqualTolerance(DegreesCelciusPerKilometerInOneDegreeCelsiusPerKilometer, (double)degreecelsiusperkilometerQuantity.Value, DegreesCelciusPerKilometerTolerance);
+            Assert.Equal(LapseRateUnit.DegreeCelsiusPerKilometer, degreecelsiusperkilometerQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            AssertEx.EqualTolerance(1, LapseRate<double>.FromDegreesCelciusPerKilometer(degreecelsiusperkilometer.DegreesCelciusPerKilometer).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            LapseRate<double> v = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            AssertEx.EqualTolerance(-1, -v.DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(2, (LapseRate<double>.FromDegreesCelciusPerKilometer(3)-v).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(2, (v + v).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(10, (v*10).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(10, (10*v).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(2, (LapseRate<double>.FromDegreesCelciusPerKilometer(10)/5).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(2, LapseRate<double>.FromDegreesCelciusPerKilometer(10)/LapseRate<double>.FromDegreesCelciusPerKilometer(5), DegreesCelciusPerKilometerTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            LapseRate<double> oneDegreeCelsiusPerKilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> twoDegreesCelciusPerKilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(2);
+
+            Assert.True(oneDegreeCelsiusPerKilometer < twoDegreesCelciusPerKilometer);
+            Assert.True(oneDegreeCelsiusPerKilometer <= twoDegreesCelciusPerKilometer);
+            Assert.True(twoDegreesCelciusPerKilometer > oneDegreeCelsiusPerKilometer);
+            Assert.True(twoDegreesCelciusPerKilometer >= oneDegreeCelsiusPerKilometer);
+
+            Assert.False(oneDegreeCelsiusPerKilometer > twoDegreesCelciusPerKilometer);
+            Assert.False(oneDegreeCelsiusPerKilometer >= twoDegreesCelciusPerKilometer);
+            Assert.False(twoDegreesCelciusPerKilometer < oneDegreeCelsiusPerKilometer);
+            Assert.False(twoDegreesCelciusPerKilometer <= oneDegreeCelsiusPerKilometer);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            Assert.Equal(0, degreecelsiusperkilometer.CompareTo(degreecelsiusperkilometer));
+            Assert.True(degreecelsiusperkilometer.CompareTo(LapseRate<double>.Zero) > 0);
+            Assert.True(LapseRate<double>.Zero.CompareTo(degreecelsiusperkilometer) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            Assert.Throws<ArgumentException>(() => degreecelsiusperkilometer.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            Assert.Throws<ArgumentNullException>(() => degreecelsiusperkilometer.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            var b = LapseRate<double>.FromDegreesCelciusPerKilometer(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            var b = LapseRate<double>.FromDegreesCelciusPerKilometer(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            Assert.True(v.Equals(LapseRate<double>.FromDegreesCelciusPerKilometer(1), DegreesCelciusPerKilometerTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LapseRate<double>.Zero, DegreesCelciusPerKilometerTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            Assert.False(degreecelsiusperkilometer.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            Assert.False(degreecelsiusperkilometer.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(LapseRateUnit.Undefined, LapseRate<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(LapseRateUnit)).Cast<LapseRateUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == LapseRateUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(LapseRate<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs
new file mode 100644
index 0000000000..db105a567c
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs
@@ -0,0 +1,257 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Level.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class LevelTestsBase
+    {
+        protected abstract double DecibelsInOneDecibel { get; }
+        protected abstract double NepersInOneDecibel { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DecibelsTolerance { get { return 1e-5; } }
+        protected virtual double NepersTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Level<double>((double)0.0, LevelUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Level<double>(double.PositiveInfinity, LevelUnit.Decibel));
+            Assert.Throws<ArgumentException>(() => new Level<double>(double.NegativeInfinity, LevelUnit.Decibel));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Level<double>(double.NaN, LevelUnit.Decibel));
+        }
+
+        [Fact]
+        public void DecibelToLevelUnits()
+        {
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            AssertEx.EqualTolerance(DecibelsInOneDecibel, decibel.Decibels, DecibelsTolerance);
+            AssertEx.EqualTolerance(NepersInOneDecibel, decibel.Nepers, NepersTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Level<double>.From(1, LevelUnit.Decibel).Decibels, DecibelsTolerance);
+            AssertEx.EqualTolerance(1, Level<double>.From(1, LevelUnit.Neper).Nepers, NepersTolerance);
+        }
+
+        [Fact]
+        public void FromDecibels_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Level<double>.FromDecibels(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Level<double>.FromDecibels(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromDecibels_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Level<double>.FromDecibels(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var decibel = Level<double>.FromDecibels(1);
+            AssertEx.EqualTolerance(DecibelsInOneDecibel, decibel.As(LevelUnit.Decibel), DecibelsTolerance);
+            AssertEx.EqualTolerance(NepersInOneDecibel, decibel.As(LevelUnit.Neper), NepersTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var decibel = Level<double>.FromDecibels(1);
+
+            var decibelQuantity = decibel.ToUnit(LevelUnit.Decibel);
+            AssertEx.EqualTolerance(DecibelsInOneDecibel, (double)decibelQuantity.Value, DecibelsTolerance);
+            Assert.Equal(LevelUnit.Decibel, decibelQuantity.Unit);
+
+            var neperQuantity = decibel.ToUnit(LevelUnit.Neper);
+            AssertEx.EqualTolerance(NepersInOneDecibel, (double)neperQuantity.Value, NepersTolerance);
+            Assert.Equal(LevelUnit.Neper, neperQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            AssertEx.EqualTolerance(1, Level<double>.FromDecibels(decibel.Decibels).Decibels, DecibelsTolerance);
+            AssertEx.EqualTolerance(1, Level<double>.FromNepers(decibel.Nepers).Decibels, NepersTolerance);
+        }
+
+        [Fact]
+        public void LogarithmicArithmeticOperators()
+        {
+            Level<double> v = Level<double>.FromDecibels(40);
+            AssertEx.EqualTolerance(-40, -v.Decibels, NepersTolerance);
+            AssertLogarithmicAddition();
+            AssertLogarithmicSubtraction();
+            AssertEx.EqualTolerance(50, (v*10).Decibels, NepersTolerance);
+            AssertEx.EqualTolerance(50, (10*v).Decibels, NepersTolerance);
+            AssertEx.EqualTolerance(35, (v/5).Decibels, NepersTolerance);
+            AssertEx.EqualTolerance(35, v/Level<double>.FromDecibels(5), NepersTolerance);
+        }
+
+        protected abstract void AssertLogarithmicAddition();
+
+        protected abstract void AssertLogarithmicSubtraction();
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Level<double> oneDecibel = Level<double>.FromDecibels(1);
+            Level<double> twoDecibels = Level<double>.FromDecibels(2);
+
+            Assert.True(oneDecibel < twoDecibels);
+            Assert.True(oneDecibel <= twoDecibels);
+            Assert.True(twoDecibels > oneDecibel);
+            Assert.True(twoDecibels >= oneDecibel);
+
+            Assert.False(oneDecibel > twoDecibels);
+            Assert.False(oneDecibel >= twoDecibels);
+            Assert.False(twoDecibels < oneDecibel);
+            Assert.False(twoDecibels <= oneDecibel);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            Assert.Equal(0, decibel.CompareTo(decibel));
+            Assert.True(decibel.CompareTo(Level<double>.Zero) > 0);
+            Assert.True(Level<double>.Zero.CompareTo(decibel) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            Assert.Throws<ArgumentException>(() => decibel.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            Assert.Throws<ArgumentNullException>(() => decibel.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Level<double>.FromDecibels(1);
+            var b = Level<double>.FromDecibels(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Level<double>.FromDecibels(1);
+            var b = Level<double>.FromDecibels(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Level<double>.FromDecibels(1);
+            Assert.True(v.Equals(Level<double>.FromDecibels(1), DecibelsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Level<double>.Zero, DecibelsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            Assert.False(decibel.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            Assert.False(decibel.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(LevelUnit.Undefined, Level<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(LevelUnit)).Cast<LevelUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == LevelUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Level<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/LinearDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LinearDensityTestsBase.g.cs
new file mode 100644
index 0000000000..8ac620432a
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/LinearDensityTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of LinearDensity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class LinearDensityTestsBase
+    {
+        protected abstract double GramsPerMeterInOneKilogramPerMeter { get; }
+        protected abstract double KilogramsPerMeterInOneKilogramPerMeter { get; }
+        protected abstract double PoundsPerFootInOneKilogramPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double GramsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double KilogramsPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double PoundsPerFootTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>((double)0.0, LinearDensityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>(double.PositiveInfinity, LinearDensityUnit.KilogramPerMeter));
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>(double.NegativeInfinity, LinearDensityUnit.KilogramPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>(double.NaN, LinearDensityUnit.KilogramPerMeter));
+        }
+
+        [Fact]
+        public void KilogramPerMeterToLinearDensityUnits()
+        {
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            AssertEx.EqualTolerance(GramsPerMeterInOneKilogramPerMeter, kilogrampermeter.GramsPerMeter, GramsPerMeterTolerance);
+            AssertEx.EqualTolerance(KilogramsPerMeterInOneKilogramPerMeter, kilogrampermeter.KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(PoundsPerFootInOneKilogramPerMeter, kilogrampermeter.PoundsPerFoot, PoundsPerFootTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, LinearDensity<double>.From(1, LinearDensityUnit.GramPerMeter).GramsPerMeter, GramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.From(1, LinearDensityUnit.KilogramPerMeter).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.From(1, LinearDensityUnit.PoundPerFoot).PoundsPerFoot, PoundsPerFootTolerance);
+        }
+
+        [Fact]
+        public void FromKilogramsPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LinearDensity<double>.FromKilogramsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LinearDensity<double>.FromKilogramsPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromKilogramsPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LinearDensity<double>.FromKilogramsPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            AssertEx.EqualTolerance(GramsPerMeterInOneKilogramPerMeter, kilogrampermeter.As(LinearDensityUnit.GramPerMeter), GramsPerMeterTolerance);
+            AssertEx.EqualTolerance(KilogramsPerMeterInOneKilogramPerMeter, kilogrampermeter.As(LinearDensityUnit.KilogramPerMeter), KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(PoundsPerFootInOneKilogramPerMeter, kilogrampermeter.As(LinearDensityUnit.PoundPerFoot), PoundsPerFootTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+
+            var grampermeterQuantity = kilogrampermeter.ToUnit(LinearDensityUnit.GramPerMeter);
+            AssertEx.EqualTolerance(GramsPerMeterInOneKilogramPerMeter, (double)grampermeterQuantity.Value, GramsPerMeterTolerance);
+            Assert.Equal(LinearDensityUnit.GramPerMeter, grampermeterQuantity.Unit);
+
+            var kilogrampermeterQuantity = kilogrampermeter.ToUnit(LinearDensityUnit.KilogramPerMeter);
+            AssertEx.EqualTolerance(KilogramsPerMeterInOneKilogramPerMeter, (double)kilogrampermeterQuantity.Value, KilogramsPerMeterTolerance);
+            Assert.Equal(LinearDensityUnit.KilogramPerMeter, kilogrampermeterQuantity.Unit);
+
+            var poundperfootQuantity = kilogrampermeter.ToUnit(LinearDensityUnit.PoundPerFoot);
+            AssertEx.EqualTolerance(PoundsPerFootInOneKilogramPerMeter, (double)poundperfootQuantity.Value, PoundsPerFootTolerance);
+            Assert.Equal(LinearDensityUnit.PoundPerFoot, poundperfootQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromGramsPerMeter(kilogrampermeter.GramsPerMeter).KilogramsPerMeter, GramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromKilogramsPerMeter(kilogrampermeter.KilogramsPerMeter).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromPoundsPerFoot(kilogrampermeter.PoundsPerFoot).KilogramsPerMeter, PoundsPerFootTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            LinearDensity<double> v = LinearDensity<double>.FromKilogramsPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (LinearDensity<double>.FromKilogramsPerMeter(3)-v).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (LinearDensity<double>.FromKilogramsPerMeter(10)/5).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, LinearDensity<double>.FromKilogramsPerMeter(10)/LinearDensity<double>.FromKilogramsPerMeter(5), KilogramsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            LinearDensity<double> oneKilogramPerMeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            LinearDensity<double> twoKilogramsPerMeter = LinearDensity<double>.FromKilogramsPerMeter(2);
+
+            Assert.True(oneKilogramPerMeter < twoKilogramsPerMeter);
+            Assert.True(oneKilogramPerMeter <= twoKilogramsPerMeter);
+            Assert.True(twoKilogramsPerMeter > oneKilogramPerMeter);
+            Assert.True(twoKilogramsPerMeter >= oneKilogramPerMeter);
+
+            Assert.False(oneKilogramPerMeter > twoKilogramsPerMeter);
+            Assert.False(oneKilogramPerMeter >= twoKilogramsPerMeter);
+            Assert.False(twoKilogramsPerMeter < oneKilogramPerMeter);
+            Assert.False(twoKilogramsPerMeter <= oneKilogramPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            Assert.Equal(0, kilogrampermeter.CompareTo(kilogrampermeter));
+            Assert.True(kilogrampermeter.CompareTo(LinearDensity<double>.Zero) > 0);
+            Assert.True(LinearDensity<double>.Zero.CompareTo(kilogrampermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            Assert.Throws<ArgumentException>(() => kilogrampermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => kilogrampermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = LinearDensity<double>.FromKilogramsPerMeter(1);
+            var b = LinearDensity<double>.FromKilogramsPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = LinearDensity<double>.FromKilogramsPerMeter(1);
+            var b = LinearDensity<double>.FromKilogramsPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = LinearDensity<double>.FromKilogramsPerMeter(1);
+            Assert.True(v.Equals(LinearDensity<double>.FromKilogramsPerMeter(1), KilogramsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LinearDensity<double>.Zero, KilogramsPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            Assert.False(kilogrampermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            Assert.False(kilogrampermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(LinearDensityUnit.Undefined, LinearDensity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(LinearDensityUnit)).Cast<LinearDensityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == LinearDensityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(LinearDensity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/LuminosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LuminosityTestsBase.g.cs
new file mode 100644
index 0000000000..7d52a193f9
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/LuminosityTestsBase.g.cs
@@ -0,0 +1,373 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Luminosity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class LuminosityTestsBase
+    {
+        protected abstract double DecawattsInOneWatt { get; }
+        protected abstract double DeciwattsInOneWatt { get; }
+        protected abstract double FemtowattsInOneWatt { get; }
+        protected abstract double GigawattsInOneWatt { get; }
+        protected abstract double KilowattsInOneWatt { get; }
+        protected abstract double MegawattsInOneWatt { get; }
+        protected abstract double MicrowattsInOneWatt { get; }
+        protected abstract double MilliwattsInOneWatt { get; }
+        protected abstract double NanowattsInOneWatt { get; }
+        protected abstract double PetawattsInOneWatt { get; }
+        protected abstract double PicowattsInOneWatt { get; }
+        protected abstract double SolarLuminositiesInOneWatt { get; }
+        protected abstract double TerawattsInOneWatt { get; }
+        protected abstract double WattsInOneWatt { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DecawattsTolerance { get { return 1e-5; } }
+        protected virtual double DeciwattsTolerance { get { return 1e-5; } }
+        protected virtual double FemtowattsTolerance { get { return 1e-5; } }
+        protected virtual double GigawattsTolerance { get { return 1e-5; } }
+        protected virtual double KilowattsTolerance { get { return 1e-5; } }
+        protected virtual double MegawattsTolerance { get { return 1e-5; } }
+        protected virtual double MicrowattsTolerance { get { return 1e-5; } }
+        protected virtual double MilliwattsTolerance { get { return 1e-5; } }
+        protected virtual double NanowattsTolerance { get { return 1e-5; } }
+        protected virtual double PetawattsTolerance { get { return 1e-5; } }
+        protected virtual double PicowattsTolerance { get { return 1e-5; } }
+        protected virtual double SolarLuminositiesTolerance { get { return 1e-5; } }
+        protected virtual double TerawattsTolerance { get { return 1e-5; } }
+        protected virtual double WattsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>((double)0.0, LuminosityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>(double.PositiveInfinity, LuminosityUnit.Watt));
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>(double.NegativeInfinity, LuminosityUnit.Watt));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>(double.NaN, LuminosityUnit.Watt));
+        }
+
+        [Fact]
+        public void WattToLuminosityUnits()
+        {
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            AssertEx.EqualTolerance(DecawattsInOneWatt, watt.Decawatts, DecawattsTolerance);
+            AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.Deciwatts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.Femtowatts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(GigawattsInOneWatt, watt.Gigawatts, GigawattsTolerance);
+            AssertEx.EqualTolerance(KilowattsInOneWatt, watt.Kilowatts, KilowattsTolerance);
+            AssertEx.EqualTolerance(MegawattsInOneWatt, watt.Megawatts, MegawattsTolerance);
+            AssertEx.EqualTolerance(MicrowattsInOneWatt, watt.Microwatts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(MilliwattsInOneWatt, watt.Milliwatts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(NanowattsInOneWatt, watt.Nanowatts, NanowattsTolerance);
+            AssertEx.EqualTolerance(PetawattsInOneWatt, watt.Petawatts, PetawattsTolerance);
+            AssertEx.EqualTolerance(PicowattsInOneWatt, watt.Picowatts, PicowattsTolerance);
+            AssertEx.EqualTolerance(SolarLuminositiesInOneWatt, watt.SolarLuminosities, SolarLuminositiesTolerance);
+            AssertEx.EqualTolerance(TerawattsInOneWatt, watt.Terawatts, TerawattsTolerance);
+            AssertEx.EqualTolerance(WattsInOneWatt, watt.Watts, WattsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Decawatt).Decawatts, DecawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Deciwatt).Deciwatts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Femtowatt).Femtowatts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Gigawatt).Gigawatts, GigawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Kilowatt).Kilowatts, KilowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Megawatt).Megawatts, MegawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Microwatt).Microwatts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Milliwatt).Milliwatts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Nanowatt).Nanowatts, NanowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Petawatt).Petawatts, PetawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Picowatt).Picowatts, PicowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.SolarLuminosity).SolarLuminosities, SolarLuminositiesTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Terawatt).Terawatts, TerawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.From(1, LuminosityUnit.Watt).Watts, WattsTolerance);
+        }
+
+        [Fact]
+        public void FromWatts_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Luminosity<double>.FromWatts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Luminosity<double>.FromWatts(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromWatts_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Luminosity<double>.FromWatts(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var watt = Luminosity<double>.FromWatts(1);
+            AssertEx.EqualTolerance(DecawattsInOneWatt, watt.As(LuminosityUnit.Decawatt), DecawattsTolerance);
+            AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.As(LuminosityUnit.Deciwatt), DeciwattsTolerance);
+            AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.As(LuminosityUnit.Femtowatt), FemtowattsTolerance);
+            AssertEx.EqualTolerance(GigawattsInOneWatt, watt.As(LuminosityUnit.Gigawatt), GigawattsTolerance);
+            AssertEx.EqualTolerance(KilowattsInOneWatt, watt.As(LuminosityUnit.Kilowatt), KilowattsTolerance);
+            AssertEx.EqualTolerance(MegawattsInOneWatt, watt.As(LuminosityUnit.Megawatt), MegawattsTolerance);
+            AssertEx.EqualTolerance(MicrowattsInOneWatt, watt.As(LuminosityUnit.Microwatt), MicrowattsTolerance);
+            AssertEx.EqualTolerance(MilliwattsInOneWatt, watt.As(LuminosityUnit.Milliwatt), MilliwattsTolerance);
+            AssertEx.EqualTolerance(NanowattsInOneWatt, watt.As(LuminosityUnit.Nanowatt), NanowattsTolerance);
+            AssertEx.EqualTolerance(PetawattsInOneWatt, watt.As(LuminosityUnit.Petawatt), PetawattsTolerance);
+            AssertEx.EqualTolerance(PicowattsInOneWatt, watt.As(LuminosityUnit.Picowatt), PicowattsTolerance);
+            AssertEx.EqualTolerance(SolarLuminositiesInOneWatt, watt.As(LuminosityUnit.SolarLuminosity), SolarLuminositiesTolerance);
+            AssertEx.EqualTolerance(TerawattsInOneWatt, watt.As(LuminosityUnit.Terawatt), TerawattsTolerance);
+            AssertEx.EqualTolerance(WattsInOneWatt, watt.As(LuminosityUnit.Watt), WattsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var watt = Luminosity<double>.FromWatts(1);
+
+            var decawattQuantity = watt.ToUnit(LuminosityUnit.Decawatt);
+            AssertEx.EqualTolerance(DecawattsInOneWatt, (double)decawattQuantity.Value, DecawattsTolerance);
+            Assert.Equal(LuminosityUnit.Decawatt, decawattQuantity.Unit);
+
+            var deciwattQuantity = watt.ToUnit(LuminosityUnit.Deciwatt);
+            AssertEx.EqualTolerance(DeciwattsInOneWatt, (double)deciwattQuantity.Value, DeciwattsTolerance);
+            Assert.Equal(LuminosityUnit.Deciwatt, deciwattQuantity.Unit);
+
+            var femtowattQuantity = watt.ToUnit(LuminosityUnit.Femtowatt);
+            AssertEx.EqualTolerance(FemtowattsInOneWatt, (double)femtowattQuantity.Value, FemtowattsTolerance);
+            Assert.Equal(LuminosityUnit.Femtowatt, femtowattQuantity.Unit);
+
+            var gigawattQuantity = watt.ToUnit(LuminosityUnit.Gigawatt);
+            AssertEx.EqualTolerance(GigawattsInOneWatt, (double)gigawattQuantity.Value, GigawattsTolerance);
+            Assert.Equal(LuminosityUnit.Gigawatt, gigawattQuantity.Unit);
+
+            var kilowattQuantity = watt.ToUnit(LuminosityUnit.Kilowatt);
+            AssertEx.EqualTolerance(KilowattsInOneWatt, (double)kilowattQuantity.Value, KilowattsTolerance);
+            Assert.Equal(LuminosityUnit.Kilowatt, kilowattQuantity.Unit);
+
+            var megawattQuantity = watt.ToUnit(LuminosityUnit.Megawatt);
+            AssertEx.EqualTolerance(MegawattsInOneWatt, (double)megawattQuantity.Value, MegawattsTolerance);
+            Assert.Equal(LuminosityUnit.Megawatt, megawattQuantity.Unit);
+
+            var microwattQuantity = watt.ToUnit(LuminosityUnit.Microwatt);
+            AssertEx.EqualTolerance(MicrowattsInOneWatt, (double)microwattQuantity.Value, MicrowattsTolerance);
+            Assert.Equal(LuminosityUnit.Microwatt, microwattQuantity.Unit);
+
+            var milliwattQuantity = watt.ToUnit(LuminosityUnit.Milliwatt);
+            AssertEx.EqualTolerance(MilliwattsInOneWatt, (double)milliwattQuantity.Value, MilliwattsTolerance);
+            Assert.Equal(LuminosityUnit.Milliwatt, milliwattQuantity.Unit);
+
+            var nanowattQuantity = watt.ToUnit(LuminosityUnit.Nanowatt);
+            AssertEx.EqualTolerance(NanowattsInOneWatt, (double)nanowattQuantity.Value, NanowattsTolerance);
+            Assert.Equal(LuminosityUnit.Nanowatt, nanowattQuantity.Unit);
+
+            var petawattQuantity = watt.ToUnit(LuminosityUnit.Petawatt);
+            AssertEx.EqualTolerance(PetawattsInOneWatt, (double)petawattQuantity.Value, PetawattsTolerance);
+            Assert.Equal(LuminosityUnit.Petawatt, petawattQuantity.Unit);
+
+            var picowattQuantity = watt.ToUnit(LuminosityUnit.Picowatt);
+            AssertEx.EqualTolerance(PicowattsInOneWatt, (double)picowattQuantity.Value, PicowattsTolerance);
+            Assert.Equal(LuminosityUnit.Picowatt, picowattQuantity.Unit);
+
+            var solarluminosityQuantity = watt.ToUnit(LuminosityUnit.SolarLuminosity);
+            AssertEx.EqualTolerance(SolarLuminositiesInOneWatt, (double)solarluminosityQuantity.Value, SolarLuminositiesTolerance);
+            Assert.Equal(LuminosityUnit.SolarLuminosity, solarluminosityQuantity.Unit);
+
+            var terawattQuantity = watt.ToUnit(LuminosityUnit.Terawatt);
+            AssertEx.EqualTolerance(TerawattsInOneWatt, (double)terawattQuantity.Value, TerawattsTolerance);
+            Assert.Equal(LuminosityUnit.Terawatt, terawattQuantity.Unit);
+
+            var wattQuantity = watt.ToUnit(LuminosityUnit.Watt);
+            AssertEx.EqualTolerance(WattsInOneWatt, (double)wattQuantity.Value, WattsTolerance);
+            Assert.Equal(LuminosityUnit.Watt, wattQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromSolarLuminosities(watt.SolarLuminosities).Watts, SolarLuminositiesTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromWatts(watt.Watts).Watts, WattsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Luminosity<double> v = Luminosity<double>.FromWatts(1);
+            AssertEx.EqualTolerance(-1, -v.Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (Luminosity<double>.FromWatts(3)-v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (Luminosity<double>.FromWatts(10)/5).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, Luminosity<double>.FromWatts(10)/Luminosity<double>.FromWatts(5), WattsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Luminosity<double> oneWatt = Luminosity<double>.FromWatts(1);
+            Luminosity<double> twoWatts = Luminosity<double>.FromWatts(2);
+
+            Assert.True(oneWatt < twoWatts);
+            Assert.True(oneWatt <= twoWatts);
+            Assert.True(twoWatts > oneWatt);
+            Assert.True(twoWatts >= oneWatt);
+
+            Assert.False(oneWatt > twoWatts);
+            Assert.False(oneWatt >= twoWatts);
+            Assert.False(twoWatts < oneWatt);
+            Assert.False(twoWatts <= oneWatt);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            Assert.Equal(0, watt.CompareTo(watt));
+            Assert.True(watt.CompareTo(Luminosity<double>.Zero) > 0);
+            Assert.True(Luminosity<double>.Zero.CompareTo(watt) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            Assert.Throws<ArgumentException>(() => watt.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            Assert.Throws<ArgumentNullException>(() => watt.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Luminosity<double>.FromWatts(1);
+            var b = Luminosity<double>.FromWatts(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Luminosity<double>.FromWatts(1);
+            var b = Luminosity<double>.FromWatts(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Luminosity<double>.FromWatts(1);
+            Assert.True(v.Equals(Luminosity<double>.FromWatts(1), WattsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Luminosity<double>.Zero, WattsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            Assert.False(watt.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            Assert.False(watt.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(LuminosityUnit.Undefined, Luminosity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(LuminosityUnit)).Cast<LuminosityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == LuminosityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Luminosity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/LuminousFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LuminousFluxTestsBase.g.cs
new file mode 100644
index 0000000000..852c12f0a4
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/LuminousFluxTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of LuminousFlux.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class LuminousFluxTestsBase
+    {
+        protected abstract double LumensInOneLumen { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double LumensTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>((double)0.0, LuminousFluxUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>(double.PositiveInfinity, LuminousFluxUnit.Lumen));
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>(double.NegativeInfinity, LuminousFluxUnit.Lumen));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>(double.NaN, LuminousFluxUnit.Lumen));
+        }
+
+        [Fact]
+        public void LumenToLuminousFluxUnits()
+        {
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            AssertEx.EqualTolerance(LumensInOneLumen, lumen.Lumens, LumensTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, LuminousFlux<double>.From(1, LuminousFluxUnit.Lumen).Lumens, LumensTolerance);
+        }
+
+        [Fact]
+        public void FromLumens_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LuminousFlux<double>.FromLumens(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LuminousFlux<double>.FromLumens(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromLumens_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LuminousFlux<double>.FromLumens(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var lumen = LuminousFlux<double>.FromLumens(1);
+            AssertEx.EqualTolerance(LumensInOneLumen, lumen.As(LuminousFluxUnit.Lumen), LumensTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var lumen = LuminousFlux<double>.FromLumens(1);
+
+            var lumenQuantity = lumen.ToUnit(LuminousFluxUnit.Lumen);
+            AssertEx.EqualTolerance(LumensInOneLumen, (double)lumenQuantity.Value, LumensTolerance);
+            Assert.Equal(LuminousFluxUnit.Lumen, lumenQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            AssertEx.EqualTolerance(1, LuminousFlux<double>.FromLumens(lumen.Lumens).Lumens, LumensTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            LuminousFlux<double> v = LuminousFlux<double>.FromLumens(1);
+            AssertEx.EqualTolerance(-1, -v.Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(2, (LuminousFlux<double>.FromLumens(3)-v).Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(2, (LuminousFlux<double>.FromLumens(10)/5).Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(2, LuminousFlux<double>.FromLumens(10)/LuminousFlux<double>.FromLumens(5), LumensTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            LuminousFlux<double> oneLumen = LuminousFlux<double>.FromLumens(1);
+            LuminousFlux<double> twoLumens = LuminousFlux<double>.FromLumens(2);
+
+            Assert.True(oneLumen < twoLumens);
+            Assert.True(oneLumen <= twoLumens);
+            Assert.True(twoLumens > oneLumen);
+            Assert.True(twoLumens >= oneLumen);
+
+            Assert.False(oneLumen > twoLumens);
+            Assert.False(oneLumen >= twoLumens);
+            Assert.False(twoLumens < oneLumen);
+            Assert.False(twoLumens <= oneLumen);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            Assert.Equal(0, lumen.CompareTo(lumen));
+            Assert.True(lumen.CompareTo(LuminousFlux<double>.Zero) > 0);
+            Assert.True(LuminousFlux<double>.Zero.CompareTo(lumen) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            Assert.Throws<ArgumentException>(() => lumen.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            Assert.Throws<ArgumentNullException>(() => lumen.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = LuminousFlux<double>.FromLumens(1);
+            var b = LuminousFlux<double>.FromLumens(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = LuminousFlux<double>.FromLumens(1);
+            var b = LuminousFlux<double>.FromLumens(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = LuminousFlux<double>.FromLumens(1);
+            Assert.True(v.Equals(LuminousFlux<double>.FromLumens(1), LumensTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LuminousFlux<double>.Zero, LumensTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            Assert.False(lumen.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            Assert.False(lumen.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(LuminousFluxUnit.Undefined, LuminousFlux<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(LuminousFluxUnit)).Cast<LuminousFluxUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == LuminousFluxUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(LuminousFlux<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/LuminousIntensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LuminousIntensityTestsBase.g.cs
new file mode 100644
index 0000000000..9f6b26e5be
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/LuminousIntensityTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of LuminousIntensity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class LuminousIntensityTestsBase
+    {
+        protected abstract double CandelaInOneCandela { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CandelaTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>((double)0.0, LuminousIntensityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>(double.PositiveInfinity, LuminousIntensityUnit.Candela));
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>(double.NegativeInfinity, LuminousIntensityUnit.Candela));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>(double.NaN, LuminousIntensityUnit.Candela));
+        }
+
+        [Fact]
+        public void CandelaToLuminousIntensityUnits()
+        {
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            AssertEx.EqualTolerance(CandelaInOneCandela, candela.Candela, CandelaTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, LuminousIntensity<double>.From(1, LuminousIntensityUnit.Candela).Candela, CandelaTolerance);
+        }
+
+        [Fact]
+        public void FromCandela_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LuminousIntensity<double>.FromCandela(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LuminousIntensity<double>.FromCandela(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromCandela_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => LuminousIntensity<double>.FromCandela(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var candela = LuminousIntensity<double>.FromCandela(1);
+            AssertEx.EqualTolerance(CandelaInOneCandela, candela.As(LuminousIntensityUnit.Candela), CandelaTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var candela = LuminousIntensity<double>.FromCandela(1);
+
+            var candelaQuantity = candela.ToUnit(LuminousIntensityUnit.Candela);
+            AssertEx.EqualTolerance(CandelaInOneCandela, (double)candelaQuantity.Value, CandelaTolerance);
+            Assert.Equal(LuminousIntensityUnit.Candela, candelaQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            AssertEx.EqualTolerance(1, LuminousIntensity<double>.FromCandela(candela.Candela).Candela, CandelaTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            LuminousIntensity<double> v = LuminousIntensity<double>.FromCandela(1);
+            AssertEx.EqualTolerance(-1, -v.Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(2, (LuminousIntensity<double>.FromCandela(3)-v).Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(2, (LuminousIntensity<double>.FromCandela(10)/5).Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(2, LuminousIntensity<double>.FromCandela(10)/LuminousIntensity<double>.FromCandela(5), CandelaTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            LuminousIntensity<double> oneCandela = LuminousIntensity<double>.FromCandela(1);
+            LuminousIntensity<double> twoCandela = LuminousIntensity<double>.FromCandela(2);
+
+            Assert.True(oneCandela < twoCandela);
+            Assert.True(oneCandela <= twoCandela);
+            Assert.True(twoCandela > oneCandela);
+            Assert.True(twoCandela >= oneCandela);
+
+            Assert.False(oneCandela > twoCandela);
+            Assert.False(oneCandela >= twoCandela);
+            Assert.False(twoCandela < oneCandela);
+            Assert.False(twoCandela <= oneCandela);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            Assert.Equal(0, candela.CompareTo(candela));
+            Assert.True(candela.CompareTo(LuminousIntensity<double>.Zero) > 0);
+            Assert.True(LuminousIntensity<double>.Zero.CompareTo(candela) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            Assert.Throws<ArgumentException>(() => candela.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            Assert.Throws<ArgumentNullException>(() => candela.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = LuminousIntensity<double>.FromCandela(1);
+            var b = LuminousIntensity<double>.FromCandela(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = LuminousIntensity<double>.FromCandela(1);
+            var b = LuminousIntensity<double>.FromCandela(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = LuminousIntensity<double>.FromCandela(1);
+            Assert.True(v.Equals(LuminousIntensity<double>.FromCandela(1), CandelaTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LuminousIntensity<double>.Zero, CandelaTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            Assert.False(candela.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            Assert.False(candela.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(LuminousIntensityUnit.Undefined, LuminousIntensity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(LuminousIntensityUnit)).Cast<LuminousIntensityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == LuminousIntensityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(LuminousIntensity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/MagneticFieldTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MagneticFieldTestsBase.g.cs
new file mode 100644
index 0000000000..0067049bda
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MagneticFieldTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of MagneticField.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MagneticFieldTestsBase
+    {
+        protected abstract double MicroteslasInOneTesla { get; }
+        protected abstract double MilliteslasInOneTesla { get; }
+        protected abstract double NanoteslasInOneTesla { get; }
+        protected abstract double TeslasInOneTesla { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double MicroteslasTolerance { get { return 1e-5; } }
+        protected virtual double MilliteslasTolerance { get { return 1e-5; } }
+        protected virtual double NanoteslasTolerance { get { return 1e-5; } }
+        protected virtual double TeslasTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>((double)0.0, MagneticFieldUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>(double.PositiveInfinity, MagneticFieldUnit.Tesla));
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>(double.NegativeInfinity, MagneticFieldUnit.Tesla));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>(double.NaN, MagneticFieldUnit.Tesla));
+        }
+
+        [Fact]
+        public void TeslaToMagneticFieldUnits()
+        {
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            AssertEx.EqualTolerance(MicroteslasInOneTesla, tesla.Microteslas, MicroteslasTolerance);
+            AssertEx.EqualTolerance(MilliteslasInOneTesla, tesla.Milliteslas, MilliteslasTolerance);
+            AssertEx.EqualTolerance(NanoteslasInOneTesla, tesla.Nanoteslas, NanoteslasTolerance);
+            AssertEx.EqualTolerance(TeslasInOneTesla, tesla.Teslas, TeslasTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, MagneticField<double>.From(1, MagneticFieldUnit.Microtesla).Microteslas, MicroteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.From(1, MagneticFieldUnit.Millitesla).Milliteslas, MilliteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.From(1, MagneticFieldUnit.Nanotesla).Nanoteslas, NanoteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.From(1, MagneticFieldUnit.Tesla).Teslas, TeslasTolerance);
+        }
+
+        [Fact]
+        public void FromTeslas_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MagneticField<double>.FromTeslas(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MagneticField<double>.FromTeslas(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromTeslas_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MagneticField<double>.FromTeslas(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var tesla = MagneticField<double>.FromTeslas(1);
+            AssertEx.EqualTolerance(MicroteslasInOneTesla, tesla.As(MagneticFieldUnit.Microtesla), MicroteslasTolerance);
+            AssertEx.EqualTolerance(MilliteslasInOneTesla, tesla.As(MagneticFieldUnit.Millitesla), MilliteslasTolerance);
+            AssertEx.EqualTolerance(NanoteslasInOneTesla, tesla.As(MagneticFieldUnit.Nanotesla), NanoteslasTolerance);
+            AssertEx.EqualTolerance(TeslasInOneTesla, tesla.As(MagneticFieldUnit.Tesla), TeslasTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var tesla = MagneticField<double>.FromTeslas(1);
+
+            var microteslaQuantity = tesla.ToUnit(MagneticFieldUnit.Microtesla);
+            AssertEx.EqualTolerance(MicroteslasInOneTesla, (double)microteslaQuantity.Value, MicroteslasTolerance);
+            Assert.Equal(MagneticFieldUnit.Microtesla, microteslaQuantity.Unit);
+
+            var milliteslaQuantity = tesla.ToUnit(MagneticFieldUnit.Millitesla);
+            AssertEx.EqualTolerance(MilliteslasInOneTesla, (double)milliteslaQuantity.Value, MilliteslasTolerance);
+            Assert.Equal(MagneticFieldUnit.Millitesla, milliteslaQuantity.Unit);
+
+            var nanoteslaQuantity = tesla.ToUnit(MagneticFieldUnit.Nanotesla);
+            AssertEx.EqualTolerance(NanoteslasInOneTesla, (double)nanoteslaQuantity.Value, NanoteslasTolerance);
+            Assert.Equal(MagneticFieldUnit.Nanotesla, nanoteslaQuantity.Unit);
+
+            var teslaQuantity = tesla.ToUnit(MagneticFieldUnit.Tesla);
+            AssertEx.EqualTolerance(TeslasInOneTesla, (double)teslaQuantity.Value, TeslasTolerance);
+            Assert.Equal(MagneticFieldUnit.Tesla, teslaQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromMicroteslas(tesla.Microteslas).Teslas, MicroteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromMilliteslas(tesla.Milliteslas).Teslas, MilliteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromNanoteslas(tesla.Nanoteslas).Teslas, NanoteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromTeslas(tesla.Teslas).Teslas, TeslasTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            MagneticField<double> v = MagneticField<double>.FromTeslas(1);
+            AssertEx.EqualTolerance(-1, -v.Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(2, (MagneticField<double>.FromTeslas(3)-v).Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(2, (MagneticField<double>.FromTeslas(10)/5).Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(2, MagneticField<double>.FromTeslas(10)/MagneticField<double>.FromTeslas(5), TeslasTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            MagneticField<double> oneTesla = MagneticField<double>.FromTeslas(1);
+            MagneticField<double> twoTeslas = MagneticField<double>.FromTeslas(2);
+
+            Assert.True(oneTesla < twoTeslas);
+            Assert.True(oneTesla <= twoTeslas);
+            Assert.True(twoTeslas > oneTesla);
+            Assert.True(twoTeslas >= oneTesla);
+
+            Assert.False(oneTesla > twoTeslas);
+            Assert.False(oneTesla >= twoTeslas);
+            Assert.False(twoTeslas < oneTesla);
+            Assert.False(twoTeslas <= oneTesla);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            Assert.Equal(0, tesla.CompareTo(tesla));
+            Assert.True(tesla.CompareTo(MagneticField<double>.Zero) > 0);
+            Assert.True(MagneticField<double>.Zero.CompareTo(tesla) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            Assert.Throws<ArgumentException>(() => tesla.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            Assert.Throws<ArgumentNullException>(() => tesla.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = MagneticField<double>.FromTeslas(1);
+            var b = MagneticField<double>.FromTeslas(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = MagneticField<double>.FromTeslas(1);
+            var b = MagneticField<double>.FromTeslas(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = MagneticField<double>.FromTeslas(1);
+            Assert.True(v.Equals(MagneticField<double>.FromTeslas(1), TeslasTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MagneticField<double>.Zero, TeslasTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            Assert.False(tesla.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            Assert.False(tesla.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(MagneticFieldUnit.Undefined, MagneticField<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(MagneticFieldUnit)).Cast<MagneticFieldUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == MagneticFieldUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(MagneticField<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/MagneticFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MagneticFluxTestsBase.g.cs
new file mode 100644
index 0000000000..12aa29b873
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MagneticFluxTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of MagneticFlux.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MagneticFluxTestsBase
+    {
+        protected abstract double WebersInOneWeber { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double WebersTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>((double)0.0, MagneticFluxUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>(double.PositiveInfinity, MagneticFluxUnit.Weber));
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>(double.NegativeInfinity, MagneticFluxUnit.Weber));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>(double.NaN, MagneticFluxUnit.Weber));
+        }
+
+        [Fact]
+        public void WeberToMagneticFluxUnits()
+        {
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            AssertEx.EqualTolerance(WebersInOneWeber, weber.Webers, WebersTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, MagneticFlux<double>.From(1, MagneticFluxUnit.Weber).Webers, WebersTolerance);
+        }
+
+        [Fact]
+        public void FromWebers_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MagneticFlux<double>.FromWebers(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MagneticFlux<double>.FromWebers(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromWebers_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MagneticFlux<double>.FromWebers(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var weber = MagneticFlux<double>.FromWebers(1);
+            AssertEx.EqualTolerance(WebersInOneWeber, weber.As(MagneticFluxUnit.Weber), WebersTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var weber = MagneticFlux<double>.FromWebers(1);
+
+            var weberQuantity = weber.ToUnit(MagneticFluxUnit.Weber);
+            AssertEx.EqualTolerance(WebersInOneWeber, (double)weberQuantity.Value, WebersTolerance);
+            Assert.Equal(MagneticFluxUnit.Weber, weberQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            AssertEx.EqualTolerance(1, MagneticFlux<double>.FromWebers(weber.Webers).Webers, WebersTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            MagneticFlux<double> v = MagneticFlux<double>.FromWebers(1);
+            AssertEx.EqualTolerance(-1, -v.Webers, WebersTolerance);
+            AssertEx.EqualTolerance(2, (MagneticFlux<double>.FromWebers(3)-v).Webers, WebersTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Webers, WebersTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Webers, WebersTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Webers, WebersTolerance);
+            AssertEx.EqualTolerance(2, (MagneticFlux<double>.FromWebers(10)/5).Webers, WebersTolerance);
+            AssertEx.EqualTolerance(2, MagneticFlux<double>.FromWebers(10)/MagneticFlux<double>.FromWebers(5), WebersTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            MagneticFlux<double> oneWeber = MagneticFlux<double>.FromWebers(1);
+            MagneticFlux<double> twoWebers = MagneticFlux<double>.FromWebers(2);
+
+            Assert.True(oneWeber < twoWebers);
+            Assert.True(oneWeber <= twoWebers);
+            Assert.True(twoWebers > oneWeber);
+            Assert.True(twoWebers >= oneWeber);
+
+            Assert.False(oneWeber > twoWebers);
+            Assert.False(oneWeber >= twoWebers);
+            Assert.False(twoWebers < oneWeber);
+            Assert.False(twoWebers <= oneWeber);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            Assert.Equal(0, weber.CompareTo(weber));
+            Assert.True(weber.CompareTo(MagneticFlux<double>.Zero) > 0);
+            Assert.True(MagneticFlux<double>.Zero.CompareTo(weber) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            Assert.Throws<ArgumentException>(() => weber.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            Assert.Throws<ArgumentNullException>(() => weber.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = MagneticFlux<double>.FromWebers(1);
+            var b = MagneticFlux<double>.FromWebers(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = MagneticFlux<double>.FromWebers(1);
+            var b = MagneticFlux<double>.FromWebers(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = MagneticFlux<double>.FromWebers(1);
+            Assert.True(v.Equals(MagneticFlux<double>.FromWebers(1), WebersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MagneticFlux<double>.Zero, WebersTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            Assert.False(weber.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            Assert.False(weber.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(MagneticFluxUnit.Undefined, MagneticFlux<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(MagneticFluxUnit)).Cast<MagneticFluxUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == MagneticFluxUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(MagneticFlux<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/MagnetizationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MagnetizationTestsBase.g.cs
new file mode 100644
index 0000000000..f0dd0f5091
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MagnetizationTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Magnetization.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MagnetizationTestsBase
+    {
+        protected abstract double AmperesPerMeterInOneAmperePerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double AmperesPerMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>((double)0.0, MagnetizationUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>(double.PositiveInfinity, MagnetizationUnit.AmperePerMeter));
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>(double.NegativeInfinity, MagnetizationUnit.AmperePerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>(double.NaN, MagnetizationUnit.AmperePerMeter));
+        }
+
+        [Fact]
+        public void AmperePerMeterToMagnetizationUnits()
+        {
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            AssertEx.EqualTolerance(AmperesPerMeterInOneAmperePerMeter, amperepermeter.AmperesPerMeter, AmperesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Magnetization<double>.From(1, MagnetizationUnit.AmperePerMeter).AmperesPerMeter, AmperesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromAmperesPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Magnetization<double>.FromAmperesPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Magnetization<double>.FromAmperesPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromAmperesPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Magnetization<double>.FromAmperesPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            AssertEx.EqualTolerance(AmperesPerMeterInOneAmperePerMeter, amperepermeter.As(MagnetizationUnit.AmperePerMeter), AmperesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+
+            var amperepermeterQuantity = amperepermeter.ToUnit(MagnetizationUnit.AmperePerMeter);
+            AssertEx.EqualTolerance(AmperesPerMeterInOneAmperePerMeter, (double)amperepermeterQuantity.Value, AmperesPerMeterTolerance);
+            Assert.Equal(MagnetizationUnit.AmperePerMeter, amperepermeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            AssertEx.EqualTolerance(1, Magnetization<double>.FromAmperesPerMeter(amperepermeter.AmperesPerMeter).AmperesPerMeter, AmperesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Magnetization<double> v = Magnetization<double>.FromAmperesPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Magnetization<double>.FromAmperesPerMeter(3)-v).AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Magnetization<double>.FromAmperesPerMeter(10)/5).AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, Magnetization<double>.FromAmperesPerMeter(10)/Magnetization<double>.FromAmperesPerMeter(5), AmperesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Magnetization<double> oneAmperePerMeter = Magnetization<double>.FromAmperesPerMeter(1);
+            Magnetization<double> twoAmperesPerMeter = Magnetization<double>.FromAmperesPerMeter(2);
+
+            Assert.True(oneAmperePerMeter < twoAmperesPerMeter);
+            Assert.True(oneAmperePerMeter <= twoAmperesPerMeter);
+            Assert.True(twoAmperesPerMeter > oneAmperePerMeter);
+            Assert.True(twoAmperesPerMeter >= oneAmperePerMeter);
+
+            Assert.False(oneAmperePerMeter > twoAmperesPerMeter);
+            Assert.False(oneAmperePerMeter >= twoAmperesPerMeter);
+            Assert.False(twoAmperesPerMeter < oneAmperePerMeter);
+            Assert.False(twoAmperesPerMeter <= oneAmperePerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            Assert.Equal(0, amperepermeter.CompareTo(amperepermeter));
+            Assert.True(amperepermeter.CompareTo(Magnetization<double>.Zero) > 0);
+            Assert.True(Magnetization<double>.Zero.CompareTo(amperepermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            Assert.Throws<ArgumentException>(() => amperepermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => amperepermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Magnetization<double>.FromAmperesPerMeter(1);
+            var b = Magnetization<double>.FromAmperesPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Magnetization<double>.FromAmperesPerMeter(1);
+            var b = Magnetization<double>.FromAmperesPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Magnetization<double>.FromAmperesPerMeter(1);
+            Assert.True(v.Equals(Magnetization<double>.FromAmperesPerMeter(1), AmperesPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Magnetization<double>.Zero, AmperesPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            Assert.False(amperepermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            Assert.False(amperepermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(MagnetizationUnit.Undefined, Magnetization<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(MagnetizationUnit)).Cast<MagnetizationUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == MagnetizationUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Magnetization<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/MassFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFluxTestsBase.g.cs
new file mode 100644
index 0000000000..308cb6141a
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MassFluxTestsBase.g.cs
@@ -0,0 +1,253 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of MassFlux.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MassFluxTestsBase
+    {
+        protected abstract double GramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter { get; }
+        protected abstract double KilogramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double GramsPerSecondPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double KilogramsPerSecondPerSquareMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>((double)0.0, MassFluxUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>(double.PositiveInfinity, MassFluxUnit.KilogramPerSecondPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>(double.NegativeInfinity, MassFluxUnit.KilogramPerSecondPerSquareMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>(double.NaN, MassFluxUnit.KilogramPerSecondPerSquareMeter));
+        }
+
+        [Fact]
+        public void KilogramPerSecondPerSquareMeterToMassFluxUnits()
+        {
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            AssertEx.EqualTolerance(GramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(KilogramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, MassFlux<double>.From(1, MassFluxUnit.GramPerSecondPerSquareMeter).GramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.From(1, MassFluxUnit.KilogramPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void FromKilogramsPerSecondPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromKilogramsPerSecondPerSquareMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            AssertEx.EqualTolerance(GramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.As(MassFluxUnit.GramPerSecondPerSquareMeter), GramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(KilogramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.As(MassFluxUnit.KilogramPerSecondPerSquareMeter), KilogramsPerSecondPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+
+            var grampersecondpersquaremeterQuantity = kilogrampersecondpersquaremeter.ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter);
+            AssertEx.EqualTolerance(GramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter, (double)grampersecondpersquaremeterQuantity.Value, GramsPerSecondPerSquareMeterTolerance);
+            Assert.Equal(MassFluxUnit.GramPerSecondPerSquareMeter, grampersecondpersquaremeterQuantity.Unit);
+
+            var kilogrampersecondpersquaremeterQuantity = kilogrampersecondpersquaremeter.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter);
+            AssertEx.EqualTolerance(KilogramsPerSecondPerSquareMeterInOneKilogramPerSecondPerSquareMeter, (double)kilogrampersecondpersquaremeterQuantity.Value, KilogramsPerSecondPerSquareMeterTolerance);
+            Assert.Equal(MassFluxUnit.KilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromGramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            MassFlux<double> v = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            AssertEx.EqualTolerance(-1, -v.KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(3)-v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(10)/5).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(10)/MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(5), KilogramsPerSecondPerSquareMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            MassFlux<double> oneKilogramPerSecondPerSquareMeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> twoKilogramsPerSecondPerSquareMeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
+
+            Assert.True(oneKilogramPerSecondPerSquareMeter < twoKilogramsPerSecondPerSquareMeter);
+            Assert.True(oneKilogramPerSecondPerSquareMeter <= twoKilogramsPerSecondPerSquareMeter);
+            Assert.True(twoKilogramsPerSecondPerSquareMeter > oneKilogramPerSecondPerSquareMeter);
+            Assert.True(twoKilogramsPerSecondPerSquareMeter >= oneKilogramPerSecondPerSquareMeter);
+
+            Assert.False(oneKilogramPerSecondPerSquareMeter > twoKilogramsPerSecondPerSquareMeter);
+            Assert.False(oneKilogramPerSecondPerSquareMeter >= twoKilogramsPerSecondPerSquareMeter);
+            Assert.False(twoKilogramsPerSecondPerSquareMeter < oneKilogramPerSecondPerSquareMeter);
+            Assert.False(twoKilogramsPerSecondPerSquareMeter <= oneKilogramPerSecondPerSquareMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            Assert.Equal(0, kilogrampersecondpersquaremeter.CompareTo(kilogrampersecondpersquaremeter));
+            Assert.True(kilogrampersecondpersquaremeter.CompareTo(MassFlux<double>.Zero) > 0);
+            Assert.True(MassFlux<double>.Zero.CompareTo(kilogrampersecondpersquaremeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            Assert.Throws<ArgumentException>(() => kilogrampersecondpersquaremeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            Assert.Throws<ArgumentNullException>(() => kilogrampersecondpersquaremeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            var b = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            var b = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            Assert.True(v.Equals(MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1), KilogramsPerSecondPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MassFlux<double>.Zero, KilogramsPerSecondPerSquareMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            Assert.False(kilogrampersecondpersquaremeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            Assert.False(kilogrampersecondpersquaremeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(MassFluxUnit.Undefined, MassFlux<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(MassFluxUnit)).Cast<MassFluxUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == MassFluxUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(MassFlux<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/MolarEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarEnergyTestsBase.g.cs
new file mode 100644
index 0000000000..568b38f9b5
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MolarEnergyTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of MolarEnergy.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MolarEnergyTestsBase
+    {
+        protected abstract double JoulesPerMoleInOneJoulePerMole { get; }
+        protected abstract double KilojoulesPerMoleInOneJoulePerMole { get; }
+        protected abstract double MegajoulesPerMoleInOneJoulePerMole { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double JoulesPerMoleTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerMoleTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesPerMoleTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>((double)0.0, MolarEnergyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>(double.PositiveInfinity, MolarEnergyUnit.JoulePerMole));
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>(double.NegativeInfinity, MolarEnergyUnit.JoulePerMole));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>(double.NaN, MolarEnergyUnit.JoulePerMole));
+        }
+
+        [Fact]
+        public void JoulePerMoleToMolarEnergyUnits()
+        {
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            AssertEx.EqualTolerance(JoulesPerMoleInOneJoulePerMole, joulepermole.JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerMoleInOneJoulePerMole, joulepermole.KilojoulesPerMole, KilojoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerMoleInOneJoulePerMole, joulepermole.MegajoulesPerMole, MegajoulesPerMoleTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.From(1, MolarEnergyUnit.JoulePerMole).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.From(1, MolarEnergyUnit.KilojoulePerMole).KilojoulesPerMole, KilojoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.From(1, MolarEnergyUnit.MegajoulePerMole).MegajoulesPerMole, MegajoulesPerMoleTolerance);
+        }
+
+        [Fact]
+        public void FromJoulesPerMole_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MolarEnergy<double>.FromJoulesPerMole(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MolarEnergy<double>.FromJoulesPerMole(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromJoulesPerMole_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MolarEnergy<double>.FromJoulesPerMole(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            AssertEx.EqualTolerance(JoulesPerMoleInOneJoulePerMole, joulepermole.As(MolarEnergyUnit.JoulePerMole), JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerMoleInOneJoulePerMole, joulepermole.As(MolarEnergyUnit.KilojoulePerMole), KilojoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerMoleInOneJoulePerMole, joulepermole.As(MolarEnergyUnit.MegajoulePerMole), MegajoulesPerMoleTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+
+            var joulepermoleQuantity = joulepermole.ToUnit(MolarEnergyUnit.JoulePerMole);
+            AssertEx.EqualTolerance(JoulesPerMoleInOneJoulePerMole, (double)joulepermoleQuantity.Value, JoulesPerMoleTolerance);
+            Assert.Equal(MolarEnergyUnit.JoulePerMole, joulepermoleQuantity.Unit);
+
+            var kilojoulepermoleQuantity = joulepermole.ToUnit(MolarEnergyUnit.KilojoulePerMole);
+            AssertEx.EqualTolerance(KilojoulesPerMoleInOneJoulePerMole, (double)kilojoulepermoleQuantity.Value, KilojoulesPerMoleTolerance);
+            Assert.Equal(MolarEnergyUnit.KilojoulePerMole, kilojoulepermoleQuantity.Unit);
+
+            var megajoulepermoleQuantity = joulepermole.ToUnit(MolarEnergyUnit.MegajoulePerMole);
+            AssertEx.EqualTolerance(MegajoulesPerMoleInOneJoulePerMole, (double)megajoulepermoleQuantity.Value, MegajoulesPerMoleTolerance);
+            Assert.Equal(MolarEnergyUnit.MegajoulePerMole, megajoulepermoleQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.FromJoulesPerMole(joulepermole.JoulesPerMole).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.FromKilojoulesPerMole(joulepermole.KilojoulesPerMole).JoulesPerMole, KilojoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.FromMegajoulesPerMole(joulepermole.MegajoulesPerMole).JoulesPerMole, MegajoulesPerMoleTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            MolarEnergy<double> v = MolarEnergy<double>.FromJoulesPerMole(1);
+            AssertEx.EqualTolerance(-1, -v.JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(2, (MolarEnergy<double>.FromJoulesPerMole(3)-v).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(2, (v + v).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(10, (v*10).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(10, (10*v).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(2, (MolarEnergy<double>.FromJoulesPerMole(10)/5).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(2, MolarEnergy<double>.FromJoulesPerMole(10)/MolarEnergy<double>.FromJoulesPerMole(5), JoulesPerMoleTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            MolarEnergy<double> oneJoulePerMole = MolarEnergy<double>.FromJoulesPerMole(1);
+            MolarEnergy<double> twoJoulesPerMole = MolarEnergy<double>.FromJoulesPerMole(2);
+
+            Assert.True(oneJoulePerMole < twoJoulesPerMole);
+            Assert.True(oneJoulePerMole <= twoJoulesPerMole);
+            Assert.True(twoJoulesPerMole > oneJoulePerMole);
+            Assert.True(twoJoulesPerMole >= oneJoulePerMole);
+
+            Assert.False(oneJoulePerMole > twoJoulesPerMole);
+            Assert.False(oneJoulePerMole >= twoJoulesPerMole);
+            Assert.False(twoJoulesPerMole < oneJoulePerMole);
+            Assert.False(twoJoulesPerMole <= oneJoulePerMole);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            Assert.Equal(0, joulepermole.CompareTo(joulepermole));
+            Assert.True(joulepermole.CompareTo(MolarEnergy<double>.Zero) > 0);
+            Assert.True(MolarEnergy<double>.Zero.CompareTo(joulepermole) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            Assert.Throws<ArgumentException>(() => joulepermole.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            Assert.Throws<ArgumentNullException>(() => joulepermole.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = MolarEnergy<double>.FromJoulesPerMole(1);
+            var b = MolarEnergy<double>.FromJoulesPerMole(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = MolarEnergy<double>.FromJoulesPerMole(1);
+            var b = MolarEnergy<double>.FromJoulesPerMole(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = MolarEnergy<double>.FromJoulesPerMole(1);
+            Assert.True(v.Equals(MolarEnergy<double>.FromJoulesPerMole(1), JoulesPerMoleTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MolarEnergy<double>.Zero, JoulesPerMoleTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            Assert.False(joulepermole.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            Assert.False(joulepermole.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(MolarEnergyUnit.Undefined, MolarEnergy<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(MolarEnergyUnit)).Cast<MolarEnergyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == MolarEnergyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(MolarEnergy<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/MolarEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarEntropyTestsBase.g.cs
new file mode 100644
index 0000000000..76be9874cb
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MolarEntropyTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of MolarEntropy.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MolarEntropyTestsBase
+    {
+        protected abstract double JoulesPerMoleKelvinInOneJoulePerMoleKelvin { get; }
+        protected abstract double KilojoulesPerMoleKelvinInOneJoulePerMoleKelvin { get; }
+        protected abstract double MegajoulesPerMoleKelvinInOneJoulePerMoleKelvin { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double JoulesPerMoleKelvinTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerMoleKelvinTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesPerMoleKelvinTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>((double)0.0, MolarEntropyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>(double.PositiveInfinity, MolarEntropyUnit.JoulePerMoleKelvin));
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>(double.NegativeInfinity, MolarEntropyUnit.JoulePerMoleKelvin));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>(double.NaN, MolarEntropyUnit.JoulePerMoleKelvin));
+        }
+
+        [Fact]
+        public void JoulePerMoleKelvinToMolarEntropyUnits()
+        {
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            AssertEx.EqualTolerance(JoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.KilojoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.MegajoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.From(1, MolarEntropyUnit.JoulePerMoleKelvin).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.From(1, MolarEntropyUnit.KilojoulePerMoleKelvin).KilojoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.From(1, MolarEntropyUnit.MegajoulePerMoleKelvin).MegajoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromJoulesPerMoleKelvin_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MolarEntropy<double>.FromJoulesPerMoleKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MolarEntropy<double>.FromJoulesPerMoleKelvin(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromJoulesPerMoleKelvin_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => MolarEntropy<double>.FromJoulesPerMoleKelvin(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            AssertEx.EqualTolerance(JoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.As(MolarEntropyUnit.JoulePerMoleKelvin), JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.As(MolarEntropyUnit.KilojoulePerMoleKelvin), KilojoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.As(MolarEntropyUnit.MegajoulePerMoleKelvin), MegajoulesPerMoleKelvinTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+
+            var joulepermolekelvinQuantity = joulepermolekelvin.ToUnit(MolarEntropyUnit.JoulePerMoleKelvin);
+            AssertEx.EqualTolerance(JoulesPerMoleKelvinInOneJoulePerMoleKelvin, (double)joulepermolekelvinQuantity.Value, JoulesPerMoleKelvinTolerance);
+            Assert.Equal(MolarEntropyUnit.JoulePerMoleKelvin, joulepermolekelvinQuantity.Unit);
+
+            var kilojoulepermolekelvinQuantity = joulepermolekelvin.ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin);
+            AssertEx.EqualTolerance(KilojoulesPerMoleKelvinInOneJoulePerMoleKelvin, (double)kilojoulepermolekelvinQuantity.Value, KilojoulesPerMoleKelvinTolerance);
+            Assert.Equal(MolarEntropyUnit.KilojoulePerMoleKelvin, kilojoulepermolekelvinQuantity.Unit);
+
+            var megajoulepermolekelvinQuantity = joulepermolekelvin.ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin);
+            AssertEx.EqualTolerance(MegajoulesPerMoleKelvinInOneJoulePerMoleKelvin, (double)megajoulepermolekelvinQuantity.Value, MegajoulesPerMoleKelvinTolerance);
+            Assert.Equal(MolarEntropyUnit.MegajoulePerMoleKelvin, megajoulepermolekelvinQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.FromJoulesPerMoleKelvin(joulepermolekelvin.JoulesPerMoleKelvin).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.FromKilojoulesPerMoleKelvin(joulepermolekelvin.KilojoulesPerMoleKelvin).JoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.FromMegajoulesPerMoleKelvin(joulepermolekelvin.MegajoulesPerMoleKelvin).JoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            MolarEntropy<double> v = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            AssertEx.EqualTolerance(-1, -v.JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(2, (MolarEntropy<double>.FromJoulesPerMoleKelvin(3)-v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(2, (v + v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(10, (v*10).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(10, (10*v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(2, (MolarEntropy<double>.FromJoulesPerMoleKelvin(10)/5).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(2, MolarEntropy<double>.FromJoulesPerMoleKelvin(10)/MolarEntropy<double>.FromJoulesPerMoleKelvin(5), JoulesPerMoleKelvinTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            MolarEntropy<double> oneJoulePerMoleKelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> twoJoulesPerMoleKelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(2);
+
+            Assert.True(oneJoulePerMoleKelvin < twoJoulesPerMoleKelvin);
+            Assert.True(oneJoulePerMoleKelvin <= twoJoulesPerMoleKelvin);
+            Assert.True(twoJoulesPerMoleKelvin > oneJoulePerMoleKelvin);
+            Assert.True(twoJoulesPerMoleKelvin >= oneJoulePerMoleKelvin);
+
+            Assert.False(oneJoulePerMoleKelvin > twoJoulesPerMoleKelvin);
+            Assert.False(oneJoulePerMoleKelvin >= twoJoulesPerMoleKelvin);
+            Assert.False(twoJoulesPerMoleKelvin < oneJoulePerMoleKelvin);
+            Assert.False(twoJoulesPerMoleKelvin <= oneJoulePerMoleKelvin);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            Assert.Equal(0, joulepermolekelvin.CompareTo(joulepermolekelvin));
+            Assert.True(joulepermolekelvin.CompareTo(MolarEntropy<double>.Zero) > 0);
+            Assert.True(MolarEntropy<double>.Zero.CompareTo(joulepermolekelvin) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            Assert.Throws<ArgumentException>(() => joulepermolekelvin.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            Assert.Throws<ArgumentNullException>(() => joulepermolekelvin.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            var b = MolarEntropy<double>.FromJoulesPerMoleKelvin(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            var b = MolarEntropy<double>.FromJoulesPerMoleKelvin(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            Assert.True(v.Equals(MolarEntropy<double>.FromJoulesPerMoleKelvin(1), JoulesPerMoleKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MolarEntropy<double>.Zero, JoulesPerMoleKelvinTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            Assert.False(joulepermolekelvin.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            Assert.False(joulepermolekelvin.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(MolarEntropyUnit.Undefined, MolarEntropy<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(MolarEntropyUnit)).Cast<MolarEntropyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == MolarEntropyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(MolarEntropy<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/MolarityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarityTestsBase.g.cs
new file mode 100644
index 0000000000..3ce6d3bd96
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MolarityTestsBase.g.cs
@@ -0,0 +1,313 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Molarity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MolarityTestsBase
+    {
+        protected abstract double CentimolesPerLiterInOneMolesPerCubicMeter { get; }
+        protected abstract double DecimolesPerLiterInOneMolesPerCubicMeter { get; }
+        protected abstract double MicromolesPerLiterInOneMolesPerCubicMeter { get; }
+        protected abstract double MillimolesPerLiterInOneMolesPerCubicMeter { get; }
+        protected abstract double MolesPerCubicMeterInOneMolesPerCubicMeter { get; }
+        protected abstract double MolesPerLiterInOneMolesPerCubicMeter { get; }
+        protected abstract double NanomolesPerLiterInOneMolesPerCubicMeter { get; }
+        protected abstract double PicomolesPerLiterInOneMolesPerCubicMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CentimolesPerLiterTolerance { get { return 1e-5; } }
+        protected virtual double DecimolesPerLiterTolerance { get { return 1e-5; } }
+        protected virtual double MicromolesPerLiterTolerance { get { return 1e-5; } }
+        protected virtual double MillimolesPerLiterTolerance { get { return 1e-5; } }
+        protected virtual double MolesPerCubicMeterTolerance { get { return 1e-5; } }
+        protected virtual double MolesPerLiterTolerance { get { return 1e-5; } }
+        protected virtual double NanomolesPerLiterTolerance { get { return 1e-5; } }
+        protected virtual double PicomolesPerLiterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Molarity<double>((double)0.0, MolarityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Molarity<double>(double.PositiveInfinity, MolarityUnit.MolesPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new Molarity<double>(double.NegativeInfinity, MolarityUnit.MolesPerCubicMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Molarity<double>(double.NaN, MolarityUnit.MolesPerCubicMeter));
+        }
+
+        [Fact]
+        public void MolesPerCubicMeterToMolarityUnits()
+        {
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            AssertEx.EqualTolerance(CentimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.CentimolesPerLiter, CentimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(DecimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.DecimolesPerLiter, DecimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(MicromolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.MicromolesPerLiter, MicromolesPerLiterTolerance);
+            AssertEx.EqualTolerance(MillimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.MillimolesPerLiter, MillimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(MolesPerCubicMeterInOneMolesPerCubicMeter, molespercubicmeter.MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(MolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.MolesPerLiter, MolesPerLiterTolerance);
+            AssertEx.EqualTolerance(NanomolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.NanomolesPerLiter, NanomolesPerLiterTolerance);
+            AssertEx.EqualTolerance(PicomolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.PicomolesPerLiter, PicomolesPerLiterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.CentimolesPerLiter).CentimolesPerLiter, CentimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.DecimolesPerLiter).DecimolesPerLiter, DecimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.MicromolesPerLiter).MicromolesPerLiter, MicromolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.MillimolesPerLiter).MillimolesPerLiter, MillimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.MolesPerCubicMeter).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.MolesPerLiter).MolesPerLiter, MolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.NanomolesPerLiter).NanomolesPerLiter, NanomolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.From(1, MolarityUnit.PicomolesPerLiter).PicomolesPerLiter, PicomolesPerLiterTolerance);
+        }
+
+        [Fact]
+        public void FromMolesPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Molarity<double>.FromMolesPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Molarity<double>.FromMolesPerCubicMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromMolesPerCubicMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Molarity<double>.FromMolesPerCubicMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            AssertEx.EqualTolerance(CentimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.CentimolesPerLiter), CentimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(DecimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.DecimolesPerLiter), DecimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(MicromolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.MicromolesPerLiter), MicromolesPerLiterTolerance);
+            AssertEx.EqualTolerance(MillimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.MillimolesPerLiter), MillimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(MolesPerCubicMeterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.MolesPerCubicMeter), MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(MolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.MolesPerLiter), MolesPerLiterTolerance);
+            AssertEx.EqualTolerance(NanomolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.NanomolesPerLiter), NanomolesPerLiterTolerance);
+            AssertEx.EqualTolerance(PicomolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.PicomolesPerLiter), PicomolesPerLiterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+
+            var centimolesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.CentimolesPerLiter);
+            AssertEx.EqualTolerance(CentimolesPerLiterInOneMolesPerCubicMeter, (double)centimolesperliterQuantity.Value, CentimolesPerLiterTolerance);
+            Assert.Equal(MolarityUnit.CentimolesPerLiter, centimolesperliterQuantity.Unit);
+
+            var decimolesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.DecimolesPerLiter);
+            AssertEx.EqualTolerance(DecimolesPerLiterInOneMolesPerCubicMeter, (double)decimolesperliterQuantity.Value, DecimolesPerLiterTolerance);
+            Assert.Equal(MolarityUnit.DecimolesPerLiter, decimolesperliterQuantity.Unit);
+
+            var micromolesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.MicromolesPerLiter);
+            AssertEx.EqualTolerance(MicromolesPerLiterInOneMolesPerCubicMeter, (double)micromolesperliterQuantity.Value, MicromolesPerLiterTolerance);
+            Assert.Equal(MolarityUnit.MicromolesPerLiter, micromolesperliterQuantity.Unit);
+
+            var millimolesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.MillimolesPerLiter);
+            AssertEx.EqualTolerance(MillimolesPerLiterInOneMolesPerCubicMeter, (double)millimolesperliterQuantity.Value, MillimolesPerLiterTolerance);
+            Assert.Equal(MolarityUnit.MillimolesPerLiter, millimolesperliterQuantity.Unit);
+
+            var molespercubicmeterQuantity = molespercubicmeter.ToUnit(MolarityUnit.MolesPerCubicMeter);
+            AssertEx.EqualTolerance(MolesPerCubicMeterInOneMolesPerCubicMeter, (double)molespercubicmeterQuantity.Value, MolesPerCubicMeterTolerance);
+            Assert.Equal(MolarityUnit.MolesPerCubicMeter, molespercubicmeterQuantity.Unit);
+
+            var molesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.MolesPerLiter);
+            AssertEx.EqualTolerance(MolesPerLiterInOneMolesPerCubicMeter, (double)molesperliterQuantity.Value, MolesPerLiterTolerance);
+            Assert.Equal(MolarityUnit.MolesPerLiter, molesperliterQuantity.Unit);
+
+            var nanomolesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.NanomolesPerLiter);
+            AssertEx.EqualTolerance(NanomolesPerLiterInOneMolesPerCubicMeter, (double)nanomolesperliterQuantity.Value, NanomolesPerLiterTolerance);
+            Assert.Equal(MolarityUnit.NanomolesPerLiter, nanomolesperliterQuantity.Unit);
+
+            var picomolesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.PicomolesPerLiter);
+            AssertEx.EqualTolerance(PicomolesPerLiterInOneMolesPerCubicMeter, (double)picomolesperliterQuantity.Value, PicomolesPerLiterTolerance);
+            Assert.Equal(MolarityUnit.PicomolesPerLiter, picomolesperliterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromCentimolesPerLiter(molespercubicmeter.CentimolesPerLiter).MolesPerCubicMeter, CentimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromDecimolesPerLiter(molespercubicmeter.DecimolesPerLiter).MolesPerCubicMeter, DecimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMicromolesPerLiter(molespercubicmeter.MicromolesPerLiter).MolesPerCubicMeter, MicromolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMillimolesPerLiter(molespercubicmeter.MillimolesPerLiter).MolesPerCubicMeter, MillimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMolesPerCubicMeter(molespercubicmeter.MolesPerCubicMeter).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMolesPerLiter(molespercubicmeter.MolesPerLiter).MolesPerCubicMeter, MolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromNanomolesPerLiter(molespercubicmeter.NanomolesPerLiter).MolesPerCubicMeter, NanomolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromPicomolesPerLiter(molespercubicmeter.PicomolesPerLiter).MolesPerCubicMeter, PicomolesPerLiterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Molarity<double> v = Molarity<double>.FromMolesPerCubicMeter(1);
+            AssertEx.EqualTolerance(-1, -v.MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (Molarity<double>.FromMolesPerCubicMeter(3)-v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (Molarity<double>.FromMolesPerCubicMeter(10)/5).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, Molarity<double>.FromMolesPerCubicMeter(10)/Molarity<double>.FromMolesPerCubicMeter(5), MolesPerCubicMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Molarity<double> oneMolesPerCubicMeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            Molarity<double> twoMolesPerCubicMeter = Molarity<double>.FromMolesPerCubicMeter(2);
+
+            Assert.True(oneMolesPerCubicMeter < twoMolesPerCubicMeter);
+            Assert.True(oneMolesPerCubicMeter <= twoMolesPerCubicMeter);
+            Assert.True(twoMolesPerCubicMeter > oneMolesPerCubicMeter);
+            Assert.True(twoMolesPerCubicMeter >= oneMolesPerCubicMeter);
+
+            Assert.False(oneMolesPerCubicMeter > twoMolesPerCubicMeter);
+            Assert.False(oneMolesPerCubicMeter >= twoMolesPerCubicMeter);
+            Assert.False(twoMolesPerCubicMeter < oneMolesPerCubicMeter);
+            Assert.False(twoMolesPerCubicMeter <= oneMolesPerCubicMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            Assert.Equal(0, molespercubicmeter.CompareTo(molespercubicmeter));
+            Assert.True(molespercubicmeter.CompareTo(Molarity<double>.Zero) > 0);
+            Assert.True(Molarity<double>.Zero.CompareTo(molespercubicmeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            Assert.Throws<ArgumentException>(() => molespercubicmeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            Assert.Throws<ArgumentNullException>(() => molespercubicmeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Molarity<double>.FromMolesPerCubicMeter(1);
+            var b = Molarity<double>.FromMolesPerCubicMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Molarity<double>.FromMolesPerCubicMeter(1);
+            var b = Molarity<double>.FromMolesPerCubicMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Molarity<double>.FromMolesPerCubicMeter(1);
+            Assert.True(v.Equals(Molarity<double>.FromMolesPerCubicMeter(1), MolesPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Molarity<double>.Zero, MolesPerCubicMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            Assert.False(molespercubicmeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            Assert.False(molespercubicmeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(MolarityUnit.Undefined, Molarity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(MolarityUnit)).Cast<MolarityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == MolarityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Molarity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/PermeabilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PermeabilityTestsBase.g.cs
new file mode 100644
index 0000000000..6624b8bd08
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/PermeabilityTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Permeability.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class PermeabilityTestsBase
+    {
+        protected abstract double HenriesPerMeterInOneHenryPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double HenriesPerMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Permeability<double>((double)0.0, PermeabilityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Permeability<double>(double.PositiveInfinity, PermeabilityUnit.HenryPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permeability<double>(double.NegativeInfinity, PermeabilityUnit.HenryPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Permeability<double>(double.NaN, PermeabilityUnit.HenryPerMeter));
+        }
+
+        [Fact]
+        public void HenryPerMeterToPermeabilityUnits()
+        {
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            AssertEx.EqualTolerance(HenriesPerMeterInOneHenryPerMeter, henrypermeter.HenriesPerMeter, HenriesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Permeability<double>.From(1, PermeabilityUnit.HenryPerMeter).HenriesPerMeter, HenriesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromHenriesPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Permeability<double>.FromHenriesPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Permeability<double>.FromHenriesPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromHenriesPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Permeability<double>.FromHenriesPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            AssertEx.EqualTolerance(HenriesPerMeterInOneHenryPerMeter, henrypermeter.As(PermeabilityUnit.HenryPerMeter), HenriesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+
+            var henrypermeterQuantity = henrypermeter.ToUnit(PermeabilityUnit.HenryPerMeter);
+            AssertEx.EqualTolerance(HenriesPerMeterInOneHenryPerMeter, (double)henrypermeterQuantity.Value, HenriesPerMeterTolerance);
+            Assert.Equal(PermeabilityUnit.HenryPerMeter, henrypermeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            AssertEx.EqualTolerance(1, Permeability<double>.FromHenriesPerMeter(henrypermeter.HenriesPerMeter).HenriesPerMeter, HenriesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Permeability<double> v = Permeability<double>.FromHenriesPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permeability<double>.FromHenriesPerMeter(3)-v).HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permeability<double>.FromHenriesPerMeter(10)/5).HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, Permeability<double>.FromHenriesPerMeter(10)/Permeability<double>.FromHenriesPerMeter(5), HenriesPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Permeability<double> oneHenryPerMeter = Permeability<double>.FromHenriesPerMeter(1);
+            Permeability<double> twoHenriesPerMeter = Permeability<double>.FromHenriesPerMeter(2);
+
+            Assert.True(oneHenryPerMeter < twoHenriesPerMeter);
+            Assert.True(oneHenryPerMeter <= twoHenriesPerMeter);
+            Assert.True(twoHenriesPerMeter > oneHenryPerMeter);
+            Assert.True(twoHenriesPerMeter >= oneHenryPerMeter);
+
+            Assert.False(oneHenryPerMeter > twoHenriesPerMeter);
+            Assert.False(oneHenryPerMeter >= twoHenriesPerMeter);
+            Assert.False(twoHenriesPerMeter < oneHenryPerMeter);
+            Assert.False(twoHenriesPerMeter <= oneHenryPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            Assert.Equal(0, henrypermeter.CompareTo(henrypermeter));
+            Assert.True(henrypermeter.CompareTo(Permeability<double>.Zero) > 0);
+            Assert.True(Permeability<double>.Zero.CompareTo(henrypermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            Assert.Throws<ArgumentException>(() => henrypermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => henrypermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Permeability<double>.FromHenriesPerMeter(1);
+            var b = Permeability<double>.FromHenriesPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Permeability<double>.FromHenriesPerMeter(1);
+            var b = Permeability<double>.FromHenriesPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Permeability<double>.FromHenriesPerMeter(1);
+            Assert.True(v.Equals(Permeability<double>.FromHenriesPerMeter(1), HenriesPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Permeability<double>.Zero, HenriesPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            Assert.False(henrypermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            Assert.False(henrypermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(PermeabilityUnit.Undefined, Permeability<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(PermeabilityUnit)).Cast<PermeabilityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == PermeabilityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Permeability<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/PermittivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PermittivityTestsBase.g.cs
new file mode 100644
index 0000000000..6be88ecb46
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/PermittivityTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Permittivity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class PermittivityTestsBase
+    {
+        protected abstract double FaradsPerMeterInOneFaradPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double FaradsPerMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>((double)0.0, PermittivityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>(double.PositiveInfinity, PermittivityUnit.FaradPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>(double.NegativeInfinity, PermittivityUnit.FaradPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>(double.NaN, PermittivityUnit.FaradPerMeter));
+        }
+
+        [Fact]
+        public void FaradPerMeterToPermittivityUnits()
+        {
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            AssertEx.EqualTolerance(FaradsPerMeterInOneFaradPerMeter, faradpermeter.FaradsPerMeter, FaradsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Permittivity<double>.From(1, PermittivityUnit.FaradPerMeter).FaradsPerMeter, FaradsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromFaradsPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Permittivity<double>.FromFaradsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Permittivity<double>.FromFaradsPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromFaradsPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Permittivity<double>.FromFaradsPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            AssertEx.EqualTolerance(FaradsPerMeterInOneFaradPerMeter, faradpermeter.As(PermittivityUnit.FaradPerMeter), FaradsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+
+            var faradpermeterQuantity = faradpermeter.ToUnit(PermittivityUnit.FaradPerMeter);
+            AssertEx.EqualTolerance(FaradsPerMeterInOneFaradPerMeter, (double)faradpermeterQuantity.Value, FaradsPerMeterTolerance);
+            Assert.Equal(PermittivityUnit.FaradPerMeter, faradpermeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            AssertEx.EqualTolerance(1, Permittivity<double>.FromFaradsPerMeter(faradpermeter.FaradsPerMeter).FaradsPerMeter, FaradsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Permittivity<double> v = Permittivity<double>.FromFaradsPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permittivity<double>.FromFaradsPerMeter(3)-v).FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permittivity<double>.FromFaradsPerMeter(10)/5).FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, Permittivity<double>.FromFaradsPerMeter(10)/Permittivity<double>.FromFaradsPerMeter(5), FaradsPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Permittivity<double> oneFaradPerMeter = Permittivity<double>.FromFaradsPerMeter(1);
+            Permittivity<double> twoFaradsPerMeter = Permittivity<double>.FromFaradsPerMeter(2);
+
+            Assert.True(oneFaradPerMeter < twoFaradsPerMeter);
+            Assert.True(oneFaradPerMeter <= twoFaradsPerMeter);
+            Assert.True(twoFaradsPerMeter > oneFaradPerMeter);
+            Assert.True(twoFaradsPerMeter >= oneFaradPerMeter);
+
+            Assert.False(oneFaradPerMeter > twoFaradsPerMeter);
+            Assert.False(oneFaradPerMeter >= twoFaradsPerMeter);
+            Assert.False(twoFaradsPerMeter < oneFaradPerMeter);
+            Assert.False(twoFaradsPerMeter <= oneFaradPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            Assert.Equal(0, faradpermeter.CompareTo(faradpermeter));
+            Assert.True(faradpermeter.CompareTo(Permittivity<double>.Zero) > 0);
+            Assert.True(Permittivity<double>.Zero.CompareTo(faradpermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            Assert.Throws<ArgumentException>(() => faradpermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => faradpermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Permittivity<double>.FromFaradsPerMeter(1);
+            var b = Permittivity<double>.FromFaradsPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Permittivity<double>.FromFaradsPerMeter(1);
+            var b = Permittivity<double>.FromFaradsPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Permittivity<double>.FromFaradsPerMeter(1);
+            Assert.True(v.Equals(Permittivity<double>.FromFaradsPerMeter(1), FaradsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Permittivity<double>.Zero, FaradsPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            Assert.False(faradpermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            Assert.False(faradpermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(PermittivityUnit.Undefined, Permittivity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(PermittivityUnit)).Cast<PermittivityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == PermittivityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Permittivity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs
new file mode 100644
index 0000000000..0f46c40044
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs
@@ -0,0 +1,257 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of PowerRatio.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class PowerRatioTestsBase
+    {
+        protected abstract double DecibelMilliwattsInOneDecibelWatt { get; }
+        protected abstract double DecibelWattsInOneDecibelWatt { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DecibelMilliwattsTolerance { get { return 1e-5; } }
+        protected virtual double DecibelWattsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>((double)0.0, PowerRatioUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>(double.PositiveInfinity, PowerRatioUnit.DecibelWatt));
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>(double.NegativeInfinity, PowerRatioUnit.DecibelWatt));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>(double.NaN, PowerRatioUnit.DecibelWatt));
+        }
+
+        [Fact]
+        public void DecibelWattToPowerRatioUnits()
+        {
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            AssertEx.EqualTolerance(DecibelMilliwattsInOneDecibelWatt, decibelwatt.DecibelMilliwatts, DecibelMilliwattsTolerance);
+            AssertEx.EqualTolerance(DecibelWattsInOneDecibelWatt, decibelwatt.DecibelWatts, DecibelWattsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, PowerRatio<double>.From(1, PowerRatioUnit.DecibelMilliwatt).DecibelMilliwatts, DecibelMilliwattsTolerance);
+            AssertEx.EqualTolerance(1, PowerRatio<double>.From(1, PowerRatioUnit.DecibelWatt).DecibelWatts, DecibelWattsTolerance);
+        }
+
+        [Fact]
+        public void FromDecibelWatts_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => PowerRatio<double>.FromDecibelWatts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => PowerRatio<double>.FromDecibelWatts(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromDecibelWatts_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => PowerRatio<double>.FromDecibelWatts(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            AssertEx.EqualTolerance(DecibelMilliwattsInOneDecibelWatt, decibelwatt.As(PowerRatioUnit.DecibelMilliwatt), DecibelMilliwattsTolerance);
+            AssertEx.EqualTolerance(DecibelWattsInOneDecibelWatt, decibelwatt.As(PowerRatioUnit.DecibelWatt), DecibelWattsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+
+            var decibelmilliwattQuantity = decibelwatt.ToUnit(PowerRatioUnit.DecibelMilliwatt);
+            AssertEx.EqualTolerance(DecibelMilliwattsInOneDecibelWatt, (double)decibelmilliwattQuantity.Value, DecibelMilliwattsTolerance);
+            Assert.Equal(PowerRatioUnit.DecibelMilliwatt, decibelmilliwattQuantity.Unit);
+
+            var decibelwattQuantity = decibelwatt.ToUnit(PowerRatioUnit.DecibelWatt);
+            AssertEx.EqualTolerance(DecibelWattsInOneDecibelWatt, (double)decibelwattQuantity.Value, DecibelWattsTolerance);
+            Assert.Equal(PowerRatioUnit.DecibelWatt, decibelwattQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            AssertEx.EqualTolerance(1, PowerRatio<double>.FromDecibelMilliwatts(decibelwatt.DecibelMilliwatts).DecibelWatts, DecibelMilliwattsTolerance);
+            AssertEx.EqualTolerance(1, PowerRatio<double>.FromDecibelWatts(decibelwatt.DecibelWatts).DecibelWatts, DecibelWattsTolerance);
+        }
+
+        [Fact]
+        public void LogarithmicArithmeticOperators()
+        {
+            PowerRatio<double> v = PowerRatio<double>.FromDecibelWatts(40);
+            AssertEx.EqualTolerance(-40, -v.DecibelWatts, DecibelWattsTolerance);
+            AssertLogarithmicAddition();
+            AssertLogarithmicSubtraction();
+            AssertEx.EqualTolerance(50, (v*10).DecibelWatts, DecibelWattsTolerance);
+            AssertEx.EqualTolerance(50, (10*v).DecibelWatts, DecibelWattsTolerance);
+            AssertEx.EqualTolerance(35, (v/5).DecibelWatts, DecibelWattsTolerance);
+            AssertEx.EqualTolerance(35, v/PowerRatio<double>.FromDecibelWatts(5), DecibelWattsTolerance);
+        }
+
+        protected abstract void AssertLogarithmicAddition();
+
+        protected abstract void AssertLogarithmicSubtraction();
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            PowerRatio<double> oneDecibelWatt = PowerRatio<double>.FromDecibelWatts(1);
+            PowerRatio<double> twoDecibelWatts = PowerRatio<double>.FromDecibelWatts(2);
+
+            Assert.True(oneDecibelWatt < twoDecibelWatts);
+            Assert.True(oneDecibelWatt <= twoDecibelWatts);
+            Assert.True(twoDecibelWatts > oneDecibelWatt);
+            Assert.True(twoDecibelWatts >= oneDecibelWatt);
+
+            Assert.False(oneDecibelWatt > twoDecibelWatts);
+            Assert.False(oneDecibelWatt >= twoDecibelWatts);
+            Assert.False(twoDecibelWatts < oneDecibelWatt);
+            Assert.False(twoDecibelWatts <= oneDecibelWatt);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            Assert.Equal(0, decibelwatt.CompareTo(decibelwatt));
+            Assert.True(decibelwatt.CompareTo(PowerRatio<double>.Zero) > 0);
+            Assert.True(PowerRatio<double>.Zero.CompareTo(decibelwatt) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            Assert.Throws<ArgumentException>(() => decibelwatt.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            Assert.Throws<ArgumentNullException>(() => decibelwatt.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = PowerRatio<double>.FromDecibelWatts(1);
+            var b = PowerRatio<double>.FromDecibelWatts(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = PowerRatio<double>.FromDecibelWatts(1);
+            var b = PowerRatio<double>.FromDecibelWatts(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = PowerRatio<double>.FromDecibelWatts(1);
+            Assert.True(v.Equals(PowerRatio<double>.FromDecibelWatts(1), DecibelWattsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(PowerRatio<double>.Zero, DecibelWattsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            Assert.False(decibelwatt.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            Assert.False(decibelwatt.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(PowerRatioUnit.Undefined, PowerRatio<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(PowerRatioUnit)).Cast<PowerRatioUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == PowerRatioUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(PowerRatio<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs
new file mode 100644
index 0000000000..89abfa6346
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs
@@ -0,0 +1,407 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Power.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class PowerTestsBase
+    {
+        protected abstract double BoilerHorsepowerInOneWatt { get; }
+        protected abstract double BritishThermalUnitsPerHourInOneWatt { get; }
+        protected abstract double DecawattsInOneWatt { get; }
+        protected abstract double DeciwattsInOneWatt { get; }
+        protected abstract double ElectricalHorsepowerInOneWatt { get; }
+        protected abstract double FemtowattsInOneWatt { get; }
+        protected abstract double GigawattsInOneWatt { get; }
+        protected abstract double HydraulicHorsepowerInOneWatt { get; }
+        protected abstract double KilobritishThermalUnitsPerHourInOneWatt { get; }
+        protected abstract double KilowattsInOneWatt { get; }
+        protected abstract double MechanicalHorsepowerInOneWatt { get; }
+        protected abstract double MegawattsInOneWatt { get; }
+        protected abstract double MetricHorsepowerInOneWatt { get; }
+        protected abstract double MicrowattsInOneWatt { get; }
+        protected abstract double MilliwattsInOneWatt { get; }
+        protected abstract double NanowattsInOneWatt { get; }
+        protected abstract double PetawattsInOneWatt { get; }
+        protected abstract double PicowattsInOneWatt { get; }
+        protected abstract double TerawattsInOneWatt { get; }
+        protected abstract double WattsInOneWatt { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double BoilerHorsepowerTolerance { get { return 1e-5; } }
+        protected virtual double BritishThermalUnitsPerHourTolerance { get { return 1e-5; } }
+        protected virtual double DecawattsTolerance { get { return 1e-5; } }
+        protected virtual double DeciwattsTolerance { get { return 1e-5; } }
+        protected virtual double ElectricalHorsepowerTolerance { get { return 1e-5; } }
+        protected virtual double FemtowattsTolerance { get { return 1e-5; } }
+        protected virtual double GigawattsTolerance { get { return 1e-5; } }
+        protected virtual double HydraulicHorsepowerTolerance { get { return 1e-5; } }
+        protected virtual double KilobritishThermalUnitsPerHourTolerance { get { return 1e-5; } }
+        protected virtual double KilowattsTolerance { get { return 1e-5; } }
+        protected virtual double MechanicalHorsepowerTolerance { get { return 1e-5; } }
+        protected virtual double MegawattsTolerance { get { return 1e-5; } }
+        protected virtual double MetricHorsepowerTolerance { get { return 1e-5; } }
+        protected virtual double MicrowattsTolerance { get { return 1e-5; } }
+        protected virtual double MilliwattsTolerance { get { return 1e-5; } }
+        protected virtual double NanowattsTolerance { get { return 1e-5; } }
+        protected virtual double PetawattsTolerance { get { return 1e-5; } }
+        protected virtual double PicowattsTolerance { get { return 1e-5; } }
+        protected virtual double TerawattsTolerance { get { return 1e-5; } }
+        protected virtual double WattsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Power<double>((decimal)0.0, PowerUnit.Undefined));
+        }
+
+        [Fact]
+        public void WattToPowerUnits()
+        {
+            Power<double> watt = Power<double>.FromWatts(1);
+            AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, watt.BoilerHorsepower, BoilerHorsepowerTolerance);
+            AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, watt.BritishThermalUnitsPerHour, BritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(DecawattsInOneWatt, watt.Decawatts, DecawattsTolerance);
+            AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.Deciwatts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(ElectricalHorsepowerInOneWatt, watt.ElectricalHorsepower, ElectricalHorsepowerTolerance);
+            AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.Femtowatts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(GigawattsInOneWatt, watt.Gigawatts, GigawattsTolerance);
+            AssertEx.EqualTolerance(HydraulicHorsepowerInOneWatt, watt.HydraulicHorsepower, HydraulicHorsepowerTolerance);
+            AssertEx.EqualTolerance(KilobritishThermalUnitsPerHourInOneWatt, watt.KilobritishThermalUnitsPerHour, KilobritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(KilowattsInOneWatt, watt.Kilowatts, KilowattsTolerance);
+            AssertEx.EqualTolerance(MechanicalHorsepowerInOneWatt, watt.MechanicalHorsepower, MechanicalHorsepowerTolerance);
+            AssertEx.EqualTolerance(MegawattsInOneWatt, watt.Megawatts, MegawattsTolerance);
+            AssertEx.EqualTolerance(MetricHorsepowerInOneWatt, watt.MetricHorsepower, MetricHorsepowerTolerance);
+            AssertEx.EqualTolerance(MicrowattsInOneWatt, watt.Microwatts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(MilliwattsInOneWatt, watt.Milliwatts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(NanowattsInOneWatt, watt.Nanowatts, NanowattsTolerance);
+            AssertEx.EqualTolerance(PetawattsInOneWatt, watt.Petawatts, PetawattsTolerance);
+            AssertEx.EqualTolerance(PicowattsInOneWatt, watt.Picowatts, PicowattsTolerance);
+            AssertEx.EqualTolerance(TerawattsInOneWatt, watt.Terawatts, TerawattsTolerance);
+            AssertEx.EqualTolerance(WattsInOneWatt, watt.Watts, WattsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.BoilerHorsepower).BoilerHorsepower, BoilerHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.BritishThermalUnitPerHour).BritishThermalUnitsPerHour, BritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Decawatt).Decawatts, DecawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Deciwatt).Deciwatts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.ElectricalHorsepower).ElectricalHorsepower, ElectricalHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Femtowatt).Femtowatts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Gigawatt).Gigawatts, GigawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.HydraulicHorsepower).HydraulicHorsepower, HydraulicHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.KilobritishThermalUnitPerHour).KilobritishThermalUnitsPerHour, KilobritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Kilowatt).Kilowatts, KilowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.MechanicalHorsepower).MechanicalHorsepower, MechanicalHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Megawatt).Megawatts, MegawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.MetricHorsepower).MetricHorsepower, MetricHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Microwatt).Microwatts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Milliwatt).Milliwatts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Nanowatt).Nanowatts, NanowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Petawatt).Petawatts, PetawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Picowatt).Picowatts, PicowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Terawatt).Terawatts, TerawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.From(1, PowerUnit.Watt).Watts, WattsTolerance);
+        }
+
+        [Fact]
+        public void As()
+        {
+            var watt = Power<double>.FromWatts(1);
+            AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, watt.As(PowerUnit.BoilerHorsepower), BoilerHorsepowerTolerance);
+            AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, watt.As(PowerUnit.BritishThermalUnitPerHour), BritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(DecawattsInOneWatt, watt.As(PowerUnit.Decawatt), DecawattsTolerance);
+            AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.As(PowerUnit.Deciwatt), DeciwattsTolerance);
+            AssertEx.EqualTolerance(ElectricalHorsepowerInOneWatt, watt.As(PowerUnit.ElectricalHorsepower), ElectricalHorsepowerTolerance);
+            AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.As(PowerUnit.Femtowatt), FemtowattsTolerance);
+            AssertEx.EqualTolerance(GigawattsInOneWatt, watt.As(PowerUnit.Gigawatt), GigawattsTolerance);
+            AssertEx.EqualTolerance(HydraulicHorsepowerInOneWatt, watt.As(PowerUnit.HydraulicHorsepower), HydraulicHorsepowerTolerance);
+            AssertEx.EqualTolerance(KilobritishThermalUnitsPerHourInOneWatt, watt.As(PowerUnit.KilobritishThermalUnitPerHour), KilobritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(KilowattsInOneWatt, watt.As(PowerUnit.Kilowatt), KilowattsTolerance);
+            AssertEx.EqualTolerance(MechanicalHorsepowerInOneWatt, watt.As(PowerUnit.MechanicalHorsepower), MechanicalHorsepowerTolerance);
+            AssertEx.EqualTolerance(MegawattsInOneWatt, watt.As(PowerUnit.Megawatt), MegawattsTolerance);
+            AssertEx.EqualTolerance(MetricHorsepowerInOneWatt, watt.As(PowerUnit.MetricHorsepower), MetricHorsepowerTolerance);
+            AssertEx.EqualTolerance(MicrowattsInOneWatt, watt.As(PowerUnit.Microwatt), MicrowattsTolerance);
+            AssertEx.EqualTolerance(MilliwattsInOneWatt, watt.As(PowerUnit.Milliwatt), MilliwattsTolerance);
+            AssertEx.EqualTolerance(NanowattsInOneWatt, watt.As(PowerUnit.Nanowatt), NanowattsTolerance);
+            AssertEx.EqualTolerance(PetawattsInOneWatt, watt.As(PowerUnit.Petawatt), PetawattsTolerance);
+            AssertEx.EqualTolerance(PicowattsInOneWatt, watt.As(PowerUnit.Picowatt), PicowattsTolerance);
+            AssertEx.EqualTolerance(TerawattsInOneWatt, watt.As(PowerUnit.Terawatt), TerawattsTolerance);
+            AssertEx.EqualTolerance(WattsInOneWatt, watt.As(PowerUnit.Watt), WattsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var watt = Power<double>.FromWatts(1);
+
+            var boilerhorsepowerQuantity = watt.ToUnit(PowerUnit.BoilerHorsepower);
+            AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, (double)boilerhorsepowerQuantity.Value, BoilerHorsepowerTolerance);
+            Assert.Equal(PowerUnit.BoilerHorsepower, boilerhorsepowerQuantity.Unit);
+
+            var britishthermalunitperhourQuantity = watt.ToUnit(PowerUnit.BritishThermalUnitPerHour);
+            AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, (double)britishthermalunitperhourQuantity.Value, BritishThermalUnitsPerHourTolerance);
+            Assert.Equal(PowerUnit.BritishThermalUnitPerHour, britishthermalunitperhourQuantity.Unit);
+
+            var decawattQuantity = watt.ToUnit(PowerUnit.Decawatt);
+            AssertEx.EqualTolerance(DecawattsInOneWatt, (double)decawattQuantity.Value, DecawattsTolerance);
+            Assert.Equal(PowerUnit.Decawatt, decawattQuantity.Unit);
+
+            var deciwattQuantity = watt.ToUnit(PowerUnit.Deciwatt);
+            AssertEx.EqualTolerance(DeciwattsInOneWatt, (double)deciwattQuantity.Value, DeciwattsTolerance);
+            Assert.Equal(PowerUnit.Deciwatt, deciwattQuantity.Unit);
+
+            var electricalhorsepowerQuantity = watt.ToUnit(PowerUnit.ElectricalHorsepower);
+            AssertEx.EqualTolerance(ElectricalHorsepowerInOneWatt, (double)electricalhorsepowerQuantity.Value, ElectricalHorsepowerTolerance);
+            Assert.Equal(PowerUnit.ElectricalHorsepower, electricalhorsepowerQuantity.Unit);
+
+            var femtowattQuantity = watt.ToUnit(PowerUnit.Femtowatt);
+            AssertEx.EqualTolerance(FemtowattsInOneWatt, (double)femtowattQuantity.Value, FemtowattsTolerance);
+            Assert.Equal(PowerUnit.Femtowatt, femtowattQuantity.Unit);
+
+            var gigawattQuantity = watt.ToUnit(PowerUnit.Gigawatt);
+            AssertEx.EqualTolerance(GigawattsInOneWatt, (double)gigawattQuantity.Value, GigawattsTolerance);
+            Assert.Equal(PowerUnit.Gigawatt, gigawattQuantity.Unit);
+
+            var hydraulichorsepowerQuantity = watt.ToUnit(PowerUnit.HydraulicHorsepower);
+            AssertEx.EqualTolerance(HydraulicHorsepowerInOneWatt, (double)hydraulichorsepowerQuantity.Value, HydraulicHorsepowerTolerance);
+            Assert.Equal(PowerUnit.HydraulicHorsepower, hydraulichorsepowerQuantity.Unit);
+
+            var kilobritishthermalunitperhourQuantity = watt.ToUnit(PowerUnit.KilobritishThermalUnitPerHour);
+            AssertEx.EqualTolerance(KilobritishThermalUnitsPerHourInOneWatt, (double)kilobritishthermalunitperhourQuantity.Value, KilobritishThermalUnitsPerHourTolerance);
+            Assert.Equal(PowerUnit.KilobritishThermalUnitPerHour, kilobritishthermalunitperhourQuantity.Unit);
+
+            var kilowattQuantity = watt.ToUnit(PowerUnit.Kilowatt);
+            AssertEx.EqualTolerance(KilowattsInOneWatt, (double)kilowattQuantity.Value, KilowattsTolerance);
+            Assert.Equal(PowerUnit.Kilowatt, kilowattQuantity.Unit);
+
+            var mechanicalhorsepowerQuantity = watt.ToUnit(PowerUnit.MechanicalHorsepower);
+            AssertEx.EqualTolerance(MechanicalHorsepowerInOneWatt, (double)mechanicalhorsepowerQuantity.Value, MechanicalHorsepowerTolerance);
+            Assert.Equal(PowerUnit.MechanicalHorsepower, mechanicalhorsepowerQuantity.Unit);
+
+            var megawattQuantity = watt.ToUnit(PowerUnit.Megawatt);
+            AssertEx.EqualTolerance(MegawattsInOneWatt, (double)megawattQuantity.Value, MegawattsTolerance);
+            Assert.Equal(PowerUnit.Megawatt, megawattQuantity.Unit);
+
+            var metrichorsepowerQuantity = watt.ToUnit(PowerUnit.MetricHorsepower);
+            AssertEx.EqualTolerance(MetricHorsepowerInOneWatt, (double)metrichorsepowerQuantity.Value, MetricHorsepowerTolerance);
+            Assert.Equal(PowerUnit.MetricHorsepower, metrichorsepowerQuantity.Unit);
+
+            var microwattQuantity = watt.ToUnit(PowerUnit.Microwatt);
+            AssertEx.EqualTolerance(MicrowattsInOneWatt, (double)microwattQuantity.Value, MicrowattsTolerance);
+            Assert.Equal(PowerUnit.Microwatt, microwattQuantity.Unit);
+
+            var milliwattQuantity = watt.ToUnit(PowerUnit.Milliwatt);
+            AssertEx.EqualTolerance(MilliwattsInOneWatt, (double)milliwattQuantity.Value, MilliwattsTolerance);
+            Assert.Equal(PowerUnit.Milliwatt, milliwattQuantity.Unit);
+
+            var nanowattQuantity = watt.ToUnit(PowerUnit.Nanowatt);
+            AssertEx.EqualTolerance(NanowattsInOneWatt, (double)nanowattQuantity.Value, NanowattsTolerance);
+            Assert.Equal(PowerUnit.Nanowatt, nanowattQuantity.Unit);
+
+            var petawattQuantity = watt.ToUnit(PowerUnit.Petawatt);
+            AssertEx.EqualTolerance(PetawattsInOneWatt, (double)petawattQuantity.Value, PetawattsTolerance);
+            Assert.Equal(PowerUnit.Petawatt, petawattQuantity.Unit);
+
+            var picowattQuantity = watt.ToUnit(PowerUnit.Picowatt);
+            AssertEx.EqualTolerance(PicowattsInOneWatt, (double)picowattQuantity.Value, PicowattsTolerance);
+            Assert.Equal(PowerUnit.Picowatt, picowattQuantity.Unit);
+
+            var terawattQuantity = watt.ToUnit(PowerUnit.Terawatt);
+            AssertEx.EqualTolerance(TerawattsInOneWatt, (double)terawattQuantity.Value, TerawattsTolerance);
+            Assert.Equal(PowerUnit.Terawatt, terawattQuantity.Unit);
+
+            var wattQuantity = watt.ToUnit(PowerUnit.Watt);
+            AssertEx.EqualTolerance(WattsInOneWatt, (double)wattQuantity.Value, WattsTolerance);
+            Assert.Equal(PowerUnit.Watt, wattQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Power<double> watt = Power<double>.FromWatts(1);
+            AssertEx.EqualTolerance(1, Power<double>.FromBoilerHorsepower(watt.BoilerHorsepower).Watts, BoilerHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromBritishThermalUnitsPerHour(watt.BritishThermalUnitsPerHour).Watts, BritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromElectricalHorsepower(watt.ElectricalHorsepower).Watts, ElectricalHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromHydraulicHorsepower(watt.HydraulicHorsepower).Watts, HydraulicHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromKilobritishThermalUnitsPerHour(watt.KilobritishThermalUnitsPerHour).Watts, KilobritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMechanicalHorsepower(watt.MechanicalHorsepower).Watts, MechanicalHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMetricHorsepower(watt.MetricHorsepower).Watts, MetricHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromWatts(watt.Watts).Watts, WattsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Power<double> v = Power<double>.FromWatts(1);
+            AssertEx.EqualTolerance(-1, -v.Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (Power<double>.FromWatts(3)-v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (Power<double>.FromWatts(10)/5).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, Power<double>.FromWatts(10)/Power<double>.FromWatts(5), WattsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Power<double> oneWatt = Power<double>.FromWatts(1);
+            Power<double> twoWatts = Power<double>.FromWatts(2);
+
+            Assert.True(oneWatt < twoWatts);
+            Assert.True(oneWatt <= twoWatts);
+            Assert.True(twoWatts > oneWatt);
+            Assert.True(twoWatts >= oneWatt);
+
+            Assert.False(oneWatt > twoWatts);
+            Assert.False(oneWatt >= twoWatts);
+            Assert.False(twoWatts < oneWatt);
+            Assert.False(twoWatts <= oneWatt);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Power<double> watt = Power<double>.FromWatts(1);
+            Assert.Equal(0, watt.CompareTo(watt));
+            Assert.True(watt.CompareTo(Power<double>.Zero) > 0);
+            Assert.True(Power<double>.Zero.CompareTo(watt) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Power<double> watt = Power<double>.FromWatts(1);
+            Assert.Throws<ArgumentException>(() => watt.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Power<double> watt = Power<double>.FromWatts(1);
+            Assert.Throws<ArgumentNullException>(() => watt.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Power<double>.FromWatts(1);
+            var b = Power<double>.FromWatts(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Power<double>.FromWatts(1);
+            var b = Power<double>.FromWatts(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Power<double>.FromWatts(1);
+            Assert.True(v.Equals(Power<double>.FromWatts(1), WattsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Power<double>.Zero, WattsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Power<double> watt = Power<double>.FromWatts(1);
+            Assert.False(watt.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Power<double> watt = Power<double>.FromWatts(1);
+            Assert.False(watt.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(PowerUnit.Undefined, Power<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(PowerUnit)).Cast<PowerUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == PowerUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Power<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs
new file mode 100644
index 0000000000..b78137ac14
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs
@@ -0,0 +1,303 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of PressureChangeRate.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class PressureChangeRateTestsBase
+    {
+        protected abstract double AtmospheresPerSecondInOnePascalPerSecond { get; }
+        protected abstract double KilopascalsPerMinuteInOnePascalPerSecond { get; }
+        protected abstract double KilopascalsPerSecondInOnePascalPerSecond { get; }
+        protected abstract double MegapascalsPerMinuteInOnePascalPerSecond { get; }
+        protected abstract double MegapascalsPerSecondInOnePascalPerSecond { get; }
+        protected abstract double PascalsPerMinuteInOnePascalPerSecond { get; }
+        protected abstract double PascalsPerSecondInOnePascalPerSecond { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double AtmospheresPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double KilopascalsPerMinuteTolerance { get { return 1e-5; } }
+        protected virtual double KilopascalsPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double MegapascalsPerMinuteTolerance { get { return 1e-5; } }
+        protected virtual double MegapascalsPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double PascalsPerMinuteTolerance { get { return 1e-5; } }
+        protected virtual double PascalsPerSecondTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>((double)0.0, PressureChangeRateUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>(double.PositiveInfinity, PressureChangeRateUnit.PascalPerSecond));
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>(double.NegativeInfinity, PressureChangeRateUnit.PascalPerSecond));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>(double.NaN, PressureChangeRateUnit.PascalPerSecond));
+        }
+
+        [Fact]
+        public void PascalPerSecondToPressureChangeRateUnits()
+        {
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.AtmospheresPerSecond, AtmospheresPerSecondTolerance);
+            AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.KilopascalsPerMinute, KilopascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.KilopascalsPerSecond, KilopascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(MegapascalsPerMinuteInOnePascalPerSecond, pascalpersecond.MegapascalsPerMinute, MegapascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, pascalpersecond.MegapascalsPerSecond, MegapascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, pascalpersecond.PascalsPerMinute, PascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, pascalpersecond.PascalsPerSecond, PascalsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.From(1, PressureChangeRateUnit.AtmospherePerSecond).AtmospheresPerSecond, AtmospheresPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.From(1, PressureChangeRateUnit.KilopascalPerMinute).KilopascalsPerMinute, KilopascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.From(1, PressureChangeRateUnit.KilopascalPerSecond).KilopascalsPerSecond, KilopascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.From(1, PressureChangeRateUnit.MegapascalPerMinute).MegapascalsPerMinute, MegapascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.From(1, PressureChangeRateUnit.MegapascalPerSecond).MegapascalsPerSecond, MegapascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.From(1, PressureChangeRateUnit.PascalPerMinute).PascalsPerMinute, PascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.From(1, PressureChangeRateUnit.PascalPerSecond).PascalsPerSecond, PascalsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void FromPascalsPerSecond_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => PressureChangeRate<double>.FromPascalsPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => PressureChangeRate<double>.FromPascalsPerSecond(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromPascalsPerSecond_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => PressureChangeRate<double>.FromPascalsPerSecond(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.AtmospherePerSecond), AtmospheresPerSecondTolerance);
+            AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerMinute), KilopascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerSecond), KilopascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(MegapascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapascalPerMinute), MegapascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapascalPerSecond), MegapascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PascalPerMinute), PascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PascalPerSecond), PascalsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+
+            var atmospherepersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.AtmospherePerSecond);
+            AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, (double)atmospherepersecondQuantity.Value, AtmospheresPerSecondTolerance);
+            Assert.Equal(PressureChangeRateUnit.AtmospherePerSecond, atmospherepersecondQuantity.Unit);
+
+            var kilopascalperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.KilopascalPerMinute);
+            AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, (double)kilopascalperminuteQuantity.Value, KilopascalsPerMinuteTolerance);
+            Assert.Equal(PressureChangeRateUnit.KilopascalPerMinute, kilopascalperminuteQuantity.Unit);
+
+            var kilopascalpersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.KilopascalPerSecond);
+            AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, (double)kilopascalpersecondQuantity.Value, KilopascalsPerSecondTolerance);
+            Assert.Equal(PressureChangeRateUnit.KilopascalPerSecond, kilopascalpersecondQuantity.Unit);
+
+            var megapascalperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.MegapascalPerMinute);
+            AssertEx.EqualTolerance(MegapascalsPerMinuteInOnePascalPerSecond, (double)megapascalperminuteQuantity.Value, MegapascalsPerMinuteTolerance);
+            Assert.Equal(PressureChangeRateUnit.MegapascalPerMinute, megapascalperminuteQuantity.Unit);
+
+            var megapascalpersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.MegapascalPerSecond);
+            AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, (double)megapascalpersecondQuantity.Value, MegapascalsPerSecondTolerance);
+            Assert.Equal(PressureChangeRateUnit.MegapascalPerSecond, megapascalpersecondQuantity.Unit);
+
+            var pascalperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.PascalPerMinute);
+            AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, (double)pascalperminuteQuantity.Value, PascalsPerMinuteTolerance);
+            Assert.Equal(PressureChangeRateUnit.PascalPerMinute, pascalperminuteQuantity.Unit);
+
+            var pascalpersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.PascalPerSecond);
+            AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, (double)pascalpersecondQuantity.Value, PascalsPerSecondTolerance);
+            Assert.Equal(PressureChangeRateUnit.PascalPerSecond, pascalpersecondQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromAtmospheresPerSecond(pascalpersecond.AtmospheresPerSecond).PascalsPerSecond, AtmospheresPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromKilopascalsPerMinute(pascalpersecond.KilopascalsPerMinute).PascalsPerSecond, KilopascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromKilopascalsPerSecond(pascalpersecond.KilopascalsPerSecond).PascalsPerSecond, KilopascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromMegapascalsPerMinute(pascalpersecond.MegapascalsPerMinute).PascalsPerSecond, MegapascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromMegapascalsPerSecond(pascalpersecond.MegapascalsPerSecond).PascalsPerSecond, MegapascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromPascalsPerMinute(pascalpersecond.PascalsPerMinute).PascalsPerSecond, PascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromPascalsPerSecond(pascalpersecond.PascalsPerSecond).PascalsPerSecond, PascalsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            PressureChangeRate<double> v = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            AssertEx.EqualTolerance(-1, -v.PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (PressureChangeRate<double>.FromPascalsPerSecond(3)-v).PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (v + v).PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (v*10).PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (10*v).PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (PressureChangeRate<double>.FromPascalsPerSecond(10)/5).PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, PressureChangeRate<double>.FromPascalsPerSecond(10)/PressureChangeRate<double>.FromPascalsPerSecond(5), PascalsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            PressureChangeRate<double> onePascalPerSecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            PressureChangeRate<double> twoPascalsPerSecond = PressureChangeRate<double>.FromPascalsPerSecond(2);
+
+            Assert.True(onePascalPerSecond < twoPascalsPerSecond);
+            Assert.True(onePascalPerSecond <= twoPascalsPerSecond);
+            Assert.True(twoPascalsPerSecond > onePascalPerSecond);
+            Assert.True(twoPascalsPerSecond >= onePascalPerSecond);
+
+            Assert.False(onePascalPerSecond > twoPascalsPerSecond);
+            Assert.False(onePascalPerSecond >= twoPascalsPerSecond);
+            Assert.False(twoPascalsPerSecond < onePascalPerSecond);
+            Assert.False(twoPascalsPerSecond <= onePascalPerSecond);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            Assert.Equal(0, pascalpersecond.CompareTo(pascalpersecond));
+            Assert.True(pascalpersecond.CompareTo(PressureChangeRate<double>.Zero) > 0);
+            Assert.True(PressureChangeRate<double>.Zero.CompareTo(pascalpersecond) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            Assert.Throws<ArgumentException>(() => pascalpersecond.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            Assert.Throws<ArgumentNullException>(() => pascalpersecond.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            var b = PressureChangeRate<double>.FromPascalsPerSecond(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            var b = PressureChangeRate<double>.FromPascalsPerSecond(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            Assert.True(v.Equals(PressureChangeRate<double>.FromPascalsPerSecond(1), PascalsPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(PressureChangeRate<double>.Zero, PascalsPerSecondTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            Assert.False(pascalpersecond.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            Assert.False(pascalpersecond.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(PressureChangeRateUnit.Undefined, PressureChangeRate<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(PressureChangeRateUnit)).Cast<PressureChangeRateUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == PressureChangeRateUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(PressureChangeRate<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/RatioChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioChangeRateTestsBase.g.cs
new file mode 100644
index 0000000000..55f6a0d5be
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/RatioChangeRateTestsBase.g.cs
@@ -0,0 +1,253 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of RatioChangeRate.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class RatioChangeRateTestsBase
+    {
+        protected abstract double DecimalFractionsPerSecondInOneDecimalFractionPerSecond { get; }
+        protected abstract double PercentsPerSecondInOneDecimalFractionPerSecond { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DecimalFractionsPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double PercentsPerSecondTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>((double)0.0, RatioChangeRateUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>(double.PositiveInfinity, RatioChangeRateUnit.DecimalFractionPerSecond));
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>(double.NegativeInfinity, RatioChangeRateUnit.DecimalFractionPerSecond));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>(double.NaN, RatioChangeRateUnit.DecimalFractionPerSecond));
+        }
+
+        [Fact]
+        public void DecimalFractionPerSecondToRatioChangeRateUnits()
+        {
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            AssertEx.EqualTolerance(DecimalFractionsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(PercentsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.PercentsPerSecond, PercentsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, RatioChangeRate<double>.From(1, RatioChangeRateUnit.DecimalFractionPerSecond).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RatioChangeRate<double>.From(1, RatioChangeRateUnit.PercentPerSecond).PercentsPerSecond, PercentsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void FromDecimalFractionsPerSecond_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RatioChangeRate<double>.FromDecimalFractionsPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RatioChangeRate<double>.FromDecimalFractionsPerSecond(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromDecimalFractionsPerSecond_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RatioChangeRate<double>.FromDecimalFractionsPerSecond(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            AssertEx.EqualTolerance(DecimalFractionsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.As(RatioChangeRateUnit.DecimalFractionPerSecond), DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(PercentsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.As(RatioChangeRateUnit.PercentPerSecond), PercentsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+
+            var decimalfractionpersecondQuantity = decimalfractionpersecond.ToUnit(RatioChangeRateUnit.DecimalFractionPerSecond);
+            AssertEx.EqualTolerance(DecimalFractionsPerSecondInOneDecimalFractionPerSecond, (double)decimalfractionpersecondQuantity.Value, DecimalFractionsPerSecondTolerance);
+            Assert.Equal(RatioChangeRateUnit.DecimalFractionPerSecond, decimalfractionpersecondQuantity.Unit);
+
+            var percentpersecondQuantity = decimalfractionpersecond.ToUnit(RatioChangeRateUnit.PercentPerSecond);
+            AssertEx.EqualTolerance(PercentsPerSecondInOneDecimalFractionPerSecond, (double)percentpersecondQuantity.Value, PercentsPerSecondTolerance);
+            Assert.Equal(RatioChangeRateUnit.PercentPerSecond, percentpersecondQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            AssertEx.EqualTolerance(1, RatioChangeRate<double>.FromDecimalFractionsPerSecond(decimalfractionpersecond.DecimalFractionsPerSecond).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RatioChangeRate<double>.FromPercentsPerSecond(decimalfractionpersecond.PercentsPerSecond).DecimalFractionsPerSecond, PercentsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            RatioChangeRate<double> v = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            AssertEx.EqualTolerance(-1, -v.DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (RatioChangeRate<double>.FromDecimalFractionsPerSecond(3)-v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (v + v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (v*10).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(10, (10*v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (RatioChangeRate<double>.FromDecimalFractionsPerSecond(10)/5).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, RatioChangeRate<double>.FromDecimalFractionsPerSecond(10)/RatioChangeRate<double>.FromDecimalFractionsPerSecond(5), DecimalFractionsPerSecondTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            RatioChangeRate<double> oneDecimalFractionPerSecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> twoDecimalFractionsPerSecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(2);
+
+            Assert.True(oneDecimalFractionPerSecond < twoDecimalFractionsPerSecond);
+            Assert.True(oneDecimalFractionPerSecond <= twoDecimalFractionsPerSecond);
+            Assert.True(twoDecimalFractionsPerSecond > oneDecimalFractionPerSecond);
+            Assert.True(twoDecimalFractionsPerSecond >= oneDecimalFractionPerSecond);
+
+            Assert.False(oneDecimalFractionPerSecond > twoDecimalFractionsPerSecond);
+            Assert.False(oneDecimalFractionPerSecond >= twoDecimalFractionsPerSecond);
+            Assert.False(twoDecimalFractionsPerSecond < oneDecimalFractionPerSecond);
+            Assert.False(twoDecimalFractionsPerSecond <= oneDecimalFractionPerSecond);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            Assert.Equal(0, decimalfractionpersecond.CompareTo(decimalfractionpersecond));
+            Assert.True(decimalfractionpersecond.CompareTo(RatioChangeRate<double>.Zero) > 0);
+            Assert.True(RatioChangeRate<double>.Zero.CompareTo(decimalfractionpersecond) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            Assert.Throws<ArgumentException>(() => decimalfractionpersecond.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            Assert.Throws<ArgumentNullException>(() => decimalfractionpersecond.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            var b = RatioChangeRate<double>.FromDecimalFractionsPerSecond(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            var b = RatioChangeRate<double>.FromDecimalFractionsPerSecond(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            Assert.True(v.Equals(RatioChangeRate<double>.FromDecimalFractionsPerSecond(1), DecimalFractionsPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RatioChangeRate<double>.Zero, DecimalFractionsPerSecondTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            Assert.False(decimalfractionpersecond.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            Assert.False(decimalfractionpersecond.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(RatioChangeRateUnit.Undefined, RatioChangeRate<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(RatioChangeRateUnit)).Cast<RatioChangeRateUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == RatioChangeRateUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(RatioChangeRate<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs
new file mode 100644
index 0000000000..edeabcd516
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs
@@ -0,0 +1,293 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Ratio.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class RatioTestsBase
+    {
+        protected abstract double DecimalFractionsInOneDecimalFraction { get; }
+        protected abstract double PartsPerBillionInOneDecimalFraction { get; }
+        protected abstract double PartsPerMillionInOneDecimalFraction { get; }
+        protected abstract double PartsPerThousandInOneDecimalFraction { get; }
+        protected abstract double PartsPerTrillionInOneDecimalFraction { get; }
+        protected abstract double PercentInOneDecimalFraction { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DecimalFractionsTolerance { get { return 1e-5; } }
+        protected virtual double PartsPerBillionTolerance { get { return 1e-5; } }
+        protected virtual double PartsPerMillionTolerance { get { return 1e-5; } }
+        protected virtual double PartsPerThousandTolerance { get { return 1e-5; } }
+        protected virtual double PartsPerTrillionTolerance { get { return 1e-5; } }
+        protected virtual double PercentTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Ratio<double>((double)0.0, RatioUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Ratio<double>(double.PositiveInfinity, RatioUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new Ratio<double>(double.NegativeInfinity, RatioUnit.DecimalFraction));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Ratio<double>(double.NaN, RatioUnit.DecimalFraction));
+        }
+
+        [Fact]
+        public void DecimalFractionToRatioUnits()
+        {
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.PartsPerBillion, PartsPerBillionTolerance);
+            AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.PartsPerMillion, PartsPerMillionTolerance);
+            AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, decimalfraction.PartsPerThousand, PartsPerThousandTolerance);
+            AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, decimalfraction.PartsPerTrillion, PartsPerTrillionTolerance);
+            AssertEx.EqualTolerance(PercentInOneDecimalFraction, decimalfraction.Percent, PercentTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Ratio<double>.From(1, RatioUnit.DecimalFraction).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.From(1, RatioUnit.PartPerBillion).PartsPerBillion, PartsPerBillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.From(1, RatioUnit.PartPerMillion).PartsPerMillion, PartsPerMillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.From(1, RatioUnit.PartPerThousand).PartsPerThousand, PartsPerThousandTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.From(1, RatioUnit.PartPerTrillion).PartsPerTrillion, PartsPerTrillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.From(1, RatioUnit.Percent).Percent, PercentTolerance);
+        }
+
+        [Fact]
+        public void FromDecimalFractions_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Ratio<double>.FromDecimalFractions(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Ratio<double>.FromDecimalFractions(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromDecimalFractions_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Ratio<double>.FromDecimalFractions(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.As(RatioUnit.DecimalFraction), DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerBillion), PartsPerBillionTolerance);
+            AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerMillion), PartsPerMillionTolerance);
+            AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerThousand), PartsPerThousandTolerance);
+            AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerTrillion), PartsPerTrillionTolerance);
+            AssertEx.EqualTolerance(PercentInOneDecimalFraction, decimalfraction.As(RatioUnit.Percent), PercentTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var decimalfraction = Ratio<double>.FromDecimalFractions(1);
+
+            var decimalfractionQuantity = decimalfraction.ToUnit(RatioUnit.DecimalFraction);
+            AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, (double)decimalfractionQuantity.Value, DecimalFractionsTolerance);
+            Assert.Equal(RatioUnit.DecimalFraction, decimalfractionQuantity.Unit);
+
+            var partperbillionQuantity = decimalfraction.ToUnit(RatioUnit.PartPerBillion);
+            AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, (double)partperbillionQuantity.Value, PartsPerBillionTolerance);
+            Assert.Equal(RatioUnit.PartPerBillion, partperbillionQuantity.Unit);
+
+            var partpermillionQuantity = decimalfraction.ToUnit(RatioUnit.PartPerMillion);
+            AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, (double)partpermillionQuantity.Value, PartsPerMillionTolerance);
+            Assert.Equal(RatioUnit.PartPerMillion, partpermillionQuantity.Unit);
+
+            var partperthousandQuantity = decimalfraction.ToUnit(RatioUnit.PartPerThousand);
+            AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, (double)partperthousandQuantity.Value, PartsPerThousandTolerance);
+            Assert.Equal(RatioUnit.PartPerThousand, partperthousandQuantity.Unit);
+
+            var partpertrillionQuantity = decimalfraction.ToUnit(RatioUnit.PartPerTrillion);
+            AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, (double)partpertrillionQuantity.Value, PartsPerTrillionTolerance);
+            Assert.Equal(RatioUnit.PartPerTrillion, partpertrillionQuantity.Unit);
+
+            var percentQuantity = decimalfraction.ToUnit(RatioUnit.Percent);
+            AssertEx.EqualTolerance(PercentInOneDecimalFraction, (double)percentQuantity.Value, PercentTolerance);
+            Assert.Equal(RatioUnit.Percent, percentQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            Ratio<double> v = Ratio<double>.FromDecimalFractions(1);
+            AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (Ratio<double>.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (Ratio<double>.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, Ratio<double>.FromDecimalFractions(10)/Ratio<double>.FromDecimalFractions(5), DecimalFractionsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Ratio<double> oneDecimalFraction = Ratio<double>.FromDecimalFractions(1);
+            Ratio<double> twoDecimalFractions = Ratio<double>.FromDecimalFractions(2);
+
+            Assert.True(oneDecimalFraction < twoDecimalFractions);
+            Assert.True(oneDecimalFraction <= twoDecimalFractions);
+            Assert.True(twoDecimalFractions > oneDecimalFraction);
+            Assert.True(twoDecimalFractions >= oneDecimalFraction);
+
+            Assert.False(oneDecimalFraction > twoDecimalFractions);
+            Assert.False(oneDecimalFraction >= twoDecimalFractions);
+            Assert.False(twoDecimalFractions < oneDecimalFraction);
+            Assert.False(twoDecimalFractions <= oneDecimalFraction);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            Assert.Equal(0, decimalfraction.CompareTo(decimalfraction));
+            Assert.True(decimalfraction.CompareTo(Ratio<double>.Zero) > 0);
+            Assert.True(Ratio<double>.Zero.CompareTo(decimalfraction) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            Assert.Throws<ArgumentException>(() => decimalfraction.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            Assert.Throws<ArgumentNullException>(() => decimalfraction.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Ratio<double>.FromDecimalFractions(1);
+            var b = Ratio<double>.FromDecimalFractions(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Ratio<double>.FromDecimalFractions(1);
+            var b = Ratio<double>.FromDecimalFractions(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Ratio<double>.FromDecimalFractions(1);
+            Assert.True(v.Equals(Ratio<double>.FromDecimalFractions(1), DecimalFractionsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Ratio<double>.Zero, DecimalFractionsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            Assert.False(decimalfraction.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            Assert.False(decimalfraction.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(RatioUnit.Undefined, Ratio<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(RatioUnit)).Cast<RatioUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == RatioUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Ratio<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ReactiveEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ReactiveEnergyTestsBase.g.cs
new file mode 100644
index 0000000000..ec51ed1356
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ReactiveEnergyTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ReactiveEnergy.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ReactiveEnergyTestsBase
+    {
+        protected abstract double KilovoltampereReactiveHoursInOneVoltampereReactiveHour { get; }
+        protected abstract double MegavoltampereReactiveHoursInOneVoltampereReactiveHour { get; }
+        protected abstract double VoltampereReactiveHoursInOneVoltampereReactiveHour { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilovoltampereReactiveHoursTolerance { get { return 1e-5; } }
+        protected virtual double MegavoltampereReactiveHoursTolerance { get { return 1e-5; } }
+        protected virtual double VoltampereReactiveHoursTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>((double)0.0, ReactiveEnergyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>(double.PositiveInfinity, ReactiveEnergyUnit.VoltampereReactiveHour));
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>(double.NegativeInfinity, ReactiveEnergyUnit.VoltampereReactiveHour));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>(double.NaN, ReactiveEnergyUnit.VoltampereReactiveHour));
+        }
+
+        [Fact]
+        public void VoltampereReactiveHourToReactiveEnergyUnits()
+        {
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            AssertEx.EqualTolerance(KilovoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.KilovoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(MegavoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.MegavoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(VoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.From(1, ReactiveEnergyUnit.KilovoltampereReactiveHour).KilovoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.From(1, ReactiveEnergyUnit.MegavoltampereReactiveHour).MegavoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.From(1, ReactiveEnergyUnit.VoltampereReactiveHour).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+        }
+
+        [Fact]
+        public void FromVoltampereReactiveHours_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ReactiveEnergy<double>.FromVoltampereReactiveHours(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ReactiveEnergy<double>.FromVoltampereReactiveHours(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVoltampereReactiveHours_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ReactiveEnergy<double>.FromVoltampereReactiveHours(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            AssertEx.EqualTolerance(KilovoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.As(ReactiveEnergyUnit.KilovoltampereReactiveHour), KilovoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(MegavoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.As(ReactiveEnergyUnit.MegavoltampereReactiveHour), MegavoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(VoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.As(ReactiveEnergyUnit.VoltampereReactiveHour), VoltampereReactiveHoursTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+
+            var kilovoltamperereactivehourQuantity = voltamperereactivehour.ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour);
+            AssertEx.EqualTolerance(KilovoltampereReactiveHoursInOneVoltampereReactiveHour, (double)kilovoltamperereactivehourQuantity.Value, KilovoltampereReactiveHoursTolerance);
+            Assert.Equal(ReactiveEnergyUnit.KilovoltampereReactiveHour, kilovoltamperereactivehourQuantity.Unit);
+
+            var megavoltamperereactivehourQuantity = voltamperereactivehour.ToUnit(ReactiveEnergyUnit.MegavoltampereReactiveHour);
+            AssertEx.EqualTolerance(MegavoltampereReactiveHoursInOneVoltampereReactiveHour, (double)megavoltamperereactivehourQuantity.Value, MegavoltampereReactiveHoursTolerance);
+            Assert.Equal(ReactiveEnergyUnit.MegavoltampereReactiveHour, megavoltamperereactivehourQuantity.Unit);
+
+            var voltamperereactivehourQuantity = voltamperereactivehour.ToUnit(ReactiveEnergyUnit.VoltampereReactiveHour);
+            AssertEx.EqualTolerance(VoltampereReactiveHoursInOneVoltampereReactiveHour, (double)voltamperereactivehourQuantity.Value, VoltampereReactiveHoursTolerance);
+            Assert.Equal(ReactiveEnergyUnit.VoltampereReactiveHour, voltamperereactivehourQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.FromKilovoltampereReactiveHours(voltamperereactivehour.KilovoltampereReactiveHours).VoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.FromMegavoltampereReactiveHours(voltamperereactivehour.MegavoltampereReactiveHours).VoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.FromVoltampereReactiveHours(voltamperereactivehour.VoltampereReactiveHours).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ReactiveEnergy<double> v = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            AssertEx.EqualTolerance(-1, -v.VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(2, (ReactiveEnergy<double>.FromVoltampereReactiveHours(3)-v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(2, (v + v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(10, (v*10).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(10, (10*v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(2, (ReactiveEnergy<double>.FromVoltampereReactiveHours(10)/5).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(2, ReactiveEnergy<double>.FromVoltampereReactiveHours(10)/ReactiveEnergy<double>.FromVoltampereReactiveHours(5), VoltampereReactiveHoursTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ReactiveEnergy<double> oneVoltampereReactiveHour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> twoVoltampereReactiveHours = ReactiveEnergy<double>.FromVoltampereReactiveHours(2);
+
+            Assert.True(oneVoltampereReactiveHour < twoVoltampereReactiveHours);
+            Assert.True(oneVoltampereReactiveHour <= twoVoltampereReactiveHours);
+            Assert.True(twoVoltampereReactiveHours > oneVoltampereReactiveHour);
+            Assert.True(twoVoltampereReactiveHours >= oneVoltampereReactiveHour);
+
+            Assert.False(oneVoltampereReactiveHour > twoVoltampereReactiveHours);
+            Assert.False(oneVoltampereReactiveHour >= twoVoltampereReactiveHours);
+            Assert.False(twoVoltampereReactiveHours < oneVoltampereReactiveHour);
+            Assert.False(twoVoltampereReactiveHours <= oneVoltampereReactiveHour);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            Assert.Equal(0, voltamperereactivehour.CompareTo(voltamperereactivehour));
+            Assert.True(voltamperereactivehour.CompareTo(ReactiveEnergy<double>.Zero) > 0);
+            Assert.True(ReactiveEnergy<double>.Zero.CompareTo(voltamperereactivehour) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            Assert.Throws<ArgumentException>(() => voltamperereactivehour.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            Assert.Throws<ArgumentNullException>(() => voltamperereactivehour.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            var b = ReactiveEnergy<double>.FromVoltampereReactiveHours(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            var b = ReactiveEnergy<double>.FromVoltampereReactiveHours(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            Assert.True(v.Equals(ReactiveEnergy<double>.FromVoltampereReactiveHours(1), VoltampereReactiveHoursTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ReactiveEnergy<double>.Zero, VoltampereReactiveHoursTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            Assert.False(voltamperereactivehour.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            Assert.False(voltamperereactivehour.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ReactiveEnergyUnit.Undefined, ReactiveEnergy<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ReactiveEnergyUnit)).Cast<ReactiveEnergyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ReactiveEnergyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ReactiveEnergy<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ReactivePowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ReactivePowerTestsBase.g.cs
new file mode 100644
index 0000000000..4661c45dc3
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ReactivePowerTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ReactivePower.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ReactivePowerTestsBase
+    {
+        protected abstract double GigavoltamperesReactiveInOneVoltampereReactive { get; }
+        protected abstract double KilovoltamperesReactiveInOneVoltampereReactive { get; }
+        protected abstract double MegavoltamperesReactiveInOneVoltampereReactive { get; }
+        protected abstract double VoltamperesReactiveInOneVoltampereReactive { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double GigavoltamperesReactiveTolerance { get { return 1e-5; } }
+        protected virtual double KilovoltamperesReactiveTolerance { get { return 1e-5; } }
+        protected virtual double MegavoltamperesReactiveTolerance { get { return 1e-5; } }
+        protected virtual double VoltamperesReactiveTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>((double)0.0, ReactivePowerUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>(double.PositiveInfinity, ReactivePowerUnit.VoltampereReactive));
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>(double.NegativeInfinity, ReactivePowerUnit.VoltampereReactive));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>(double.NaN, ReactivePowerUnit.VoltampereReactive));
+        }
+
+        [Fact]
+        public void VoltampereReactiveToReactivePowerUnits()
+        {
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            AssertEx.EqualTolerance(GigavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.GigavoltamperesReactive, GigavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(KilovoltamperesReactiveInOneVoltampereReactive, voltamperereactive.KilovoltamperesReactive, KilovoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(MegavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.MegavoltamperesReactive, MegavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(VoltamperesReactiveInOneVoltampereReactive, voltamperereactive.VoltamperesReactive, VoltamperesReactiveTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ReactivePower<double>.From(1, ReactivePowerUnit.GigavoltampereReactive).GigavoltamperesReactive, GigavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.From(1, ReactivePowerUnit.KilovoltampereReactive).KilovoltamperesReactive, KilovoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.From(1, ReactivePowerUnit.MegavoltampereReactive).MegavoltamperesReactive, MegavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.From(1, ReactivePowerUnit.VoltampereReactive).VoltamperesReactive, VoltamperesReactiveTolerance);
+        }
+
+        [Fact]
+        public void FromVoltamperesReactive_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ReactivePower<double>.FromVoltamperesReactive(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ReactivePower<double>.FromVoltamperesReactive(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromVoltamperesReactive_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ReactivePower<double>.FromVoltamperesReactive(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            AssertEx.EqualTolerance(GigavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.As(ReactivePowerUnit.GigavoltampereReactive), GigavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(KilovoltamperesReactiveInOneVoltampereReactive, voltamperereactive.As(ReactivePowerUnit.KilovoltampereReactive), KilovoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(MegavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.As(ReactivePowerUnit.MegavoltampereReactive), MegavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(VoltamperesReactiveInOneVoltampereReactive, voltamperereactive.As(ReactivePowerUnit.VoltampereReactive), VoltamperesReactiveTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+
+            var gigavoltamperereactiveQuantity = voltamperereactive.ToUnit(ReactivePowerUnit.GigavoltampereReactive);
+            AssertEx.EqualTolerance(GigavoltamperesReactiveInOneVoltampereReactive, (double)gigavoltamperereactiveQuantity.Value, GigavoltamperesReactiveTolerance);
+            Assert.Equal(ReactivePowerUnit.GigavoltampereReactive, gigavoltamperereactiveQuantity.Unit);
+
+            var kilovoltamperereactiveQuantity = voltamperereactive.ToUnit(ReactivePowerUnit.KilovoltampereReactive);
+            AssertEx.EqualTolerance(KilovoltamperesReactiveInOneVoltampereReactive, (double)kilovoltamperereactiveQuantity.Value, KilovoltamperesReactiveTolerance);
+            Assert.Equal(ReactivePowerUnit.KilovoltampereReactive, kilovoltamperereactiveQuantity.Unit);
+
+            var megavoltamperereactiveQuantity = voltamperereactive.ToUnit(ReactivePowerUnit.MegavoltampereReactive);
+            AssertEx.EqualTolerance(MegavoltamperesReactiveInOneVoltampereReactive, (double)megavoltamperereactiveQuantity.Value, MegavoltamperesReactiveTolerance);
+            Assert.Equal(ReactivePowerUnit.MegavoltampereReactive, megavoltamperereactiveQuantity.Unit);
+
+            var voltamperereactiveQuantity = voltamperereactive.ToUnit(ReactivePowerUnit.VoltampereReactive);
+            AssertEx.EqualTolerance(VoltamperesReactiveInOneVoltampereReactive, (double)voltamperereactiveQuantity.Value, VoltamperesReactiveTolerance);
+            Assert.Equal(ReactivePowerUnit.VoltampereReactive, voltamperereactiveQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromGigavoltamperesReactive(voltamperereactive.GigavoltamperesReactive).VoltamperesReactive, GigavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromKilovoltamperesReactive(voltamperereactive.KilovoltamperesReactive).VoltamperesReactive, KilovoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromMegavoltamperesReactive(voltamperereactive.MegavoltamperesReactive).VoltamperesReactive, MegavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromVoltamperesReactive(voltamperereactive.VoltamperesReactive).VoltamperesReactive, VoltamperesReactiveTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ReactivePower<double> v = ReactivePower<double>.FromVoltamperesReactive(1);
+            AssertEx.EqualTolerance(-1, -v.VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(2, (ReactivePower<double>.FromVoltamperesReactive(3)-v).VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(2, (v + v).VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(10, (v*10).VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(10, (10*v).VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(2, (ReactivePower<double>.FromVoltamperesReactive(10)/5).VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(2, ReactivePower<double>.FromVoltamperesReactive(10)/ReactivePower<double>.FromVoltamperesReactive(5), VoltamperesReactiveTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ReactivePower<double> oneVoltampereReactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            ReactivePower<double> twoVoltamperesReactive = ReactivePower<double>.FromVoltamperesReactive(2);
+
+            Assert.True(oneVoltampereReactive < twoVoltamperesReactive);
+            Assert.True(oneVoltampereReactive <= twoVoltamperesReactive);
+            Assert.True(twoVoltamperesReactive > oneVoltampereReactive);
+            Assert.True(twoVoltamperesReactive >= oneVoltampereReactive);
+
+            Assert.False(oneVoltampereReactive > twoVoltamperesReactive);
+            Assert.False(oneVoltampereReactive >= twoVoltamperesReactive);
+            Assert.False(twoVoltamperesReactive < oneVoltampereReactive);
+            Assert.False(twoVoltamperesReactive <= oneVoltampereReactive);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            Assert.Equal(0, voltamperereactive.CompareTo(voltamperereactive));
+            Assert.True(voltamperereactive.CompareTo(ReactivePower<double>.Zero) > 0);
+            Assert.True(ReactivePower<double>.Zero.CompareTo(voltamperereactive) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            Assert.Throws<ArgumentException>(() => voltamperereactive.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            Assert.Throws<ArgumentNullException>(() => voltamperereactive.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ReactivePower<double>.FromVoltamperesReactive(1);
+            var b = ReactivePower<double>.FromVoltamperesReactive(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ReactivePower<double>.FromVoltamperesReactive(1);
+            var b = ReactivePower<double>.FromVoltamperesReactive(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ReactivePower<double>.FromVoltamperesReactive(1);
+            Assert.True(v.Equals(ReactivePower<double>.FromVoltamperesReactive(1), VoltamperesReactiveTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ReactivePower<double>.Zero, VoltamperesReactiveTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            Assert.False(voltamperereactive.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            Assert.False(voltamperereactive.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ReactivePowerUnit.Undefined, ReactivePower<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ReactivePowerUnit)).Cast<ReactivePowerUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ReactivePowerUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ReactivePower<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/RotationalAccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalAccelerationTestsBase.g.cs
new file mode 100644
index 0000000000..04bda57195
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/RotationalAccelerationTestsBase.g.cs
@@ -0,0 +1,273 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of RotationalAcceleration.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class RotationalAccelerationTestsBase
+    {
+        protected abstract double DegreesPerSecondSquaredInOneRadianPerSecondSquared { get; }
+        protected abstract double RadiansPerSecondSquaredInOneRadianPerSecondSquared { get; }
+        protected abstract double RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared { get; }
+        protected abstract double RevolutionsPerSecondSquaredInOneRadianPerSecondSquared { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DegreesPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double RadiansPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double RevolutionsPerMinutePerSecondTolerance { get { return 1e-5; } }
+        protected virtual double RevolutionsPerSecondSquaredTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>((double)0.0, RotationalAccelerationUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>(double.PositiveInfinity, RotationalAccelerationUnit.RadianPerSecondSquared));
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>(double.NegativeInfinity, RotationalAccelerationUnit.RadianPerSecondSquared));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>(double.NaN, RotationalAccelerationUnit.RadianPerSecondSquared));
+        }
+
+        [Fact]
+        public void RadianPerSecondSquaredToRotationalAccelerationUnits()
+        {
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.DegreesPerSecondSquared, DegreesPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(RadiansPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared, radianpersecondsquared.RevolutionsPerMinutePerSecond, RevolutionsPerMinutePerSecondTolerance);
+            AssertEx.EqualTolerance(RevolutionsPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.RevolutionsPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.DegreePerSecondSquared).DegreesPerSecondSquared, DegreesPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.RadianPerSecondSquared).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.RevolutionPerMinutePerSecond).RevolutionsPerMinutePerSecond, RevolutionsPerMinutePerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.RevolutionPerSecondSquared).RevolutionsPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
+        }
+
+        [Fact]
+        public void FromRadiansPerSecondSquared_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RotationalAcceleration<double>.FromRadiansPerSecondSquared(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalAcceleration<double>.FromRadiansPerSecondSquared(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromRadiansPerSecondSquared_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RotationalAcceleration<double>.FromRadiansPerSecondSquared(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.DegreePerSecondSquared), DegreesPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(RadiansPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RadianPerSecondSquared), RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond), RevolutionsPerMinutePerSecondTolerance);
+            AssertEx.EqualTolerance(RevolutionsPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RevolutionPerSecondSquared), RevolutionsPerSecondSquaredTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+
+            var degreepersecondsquaredQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared);
+            AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, (double)degreepersecondsquaredQuantity.Value, DegreesPerSecondSquaredTolerance);
+            Assert.Equal(RotationalAccelerationUnit.DegreePerSecondSquared, degreepersecondsquaredQuantity.Unit);
+
+            var radianpersecondsquaredQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.RadianPerSecondSquared);
+            AssertEx.EqualTolerance(RadiansPerSecondSquaredInOneRadianPerSecondSquared, (double)radianpersecondsquaredQuantity.Value, RadiansPerSecondSquaredTolerance);
+            Assert.Equal(RotationalAccelerationUnit.RadianPerSecondSquared, radianpersecondsquaredQuantity.Unit);
+
+            var revolutionperminutepersecondQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
+            AssertEx.EqualTolerance(RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared, (double)revolutionperminutepersecondQuantity.Value, RevolutionsPerMinutePerSecondTolerance);
+            Assert.Equal(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, revolutionperminutepersecondQuantity.Unit);
+
+            var revolutionpersecondsquaredQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.RevolutionPerSecondSquared);
+            AssertEx.EqualTolerance(RevolutionsPerSecondSquaredInOneRadianPerSecondSquared, (double)revolutionpersecondsquaredQuantity.Value, RevolutionsPerSecondSquaredTolerance);
+            Assert.Equal(RotationalAccelerationUnit.RevolutionPerSecondSquared, revolutionpersecondsquaredQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromDegreesPerSecondSquared(radianpersecondsquared.DegreesPerSecondSquared).RadiansPerSecondSquared, DegreesPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromRadiansPerSecondSquared(radianpersecondsquared.RadiansPerSecondSquared).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromRevolutionsPerMinutePerSecond(radianpersecondsquared.RevolutionsPerMinutePerSecond).RadiansPerSecondSquared, RevolutionsPerMinutePerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromRevolutionsPerSecondSquared(radianpersecondsquared.RevolutionsPerSecondSquared).RadiansPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            RotationalAcceleration<double> v = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            AssertEx.EqualTolerance(-1, -v.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (RotationalAcceleration<double>.FromRadiansPerSecondSquared(3)-v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (v + v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(10, (v*10).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(10, (10*v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (RotationalAcceleration<double>.FromRadiansPerSecondSquared(10)/5).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, RotationalAcceleration<double>.FromRadiansPerSecondSquared(10)/RotationalAcceleration<double>.FromRadiansPerSecondSquared(5), RadiansPerSecondSquaredTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            RotationalAcceleration<double> oneRadianPerSecondSquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> twoRadiansPerSecondSquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(2);
+
+            Assert.True(oneRadianPerSecondSquared < twoRadiansPerSecondSquared);
+            Assert.True(oneRadianPerSecondSquared <= twoRadiansPerSecondSquared);
+            Assert.True(twoRadiansPerSecondSquared > oneRadianPerSecondSquared);
+            Assert.True(twoRadiansPerSecondSquared >= oneRadianPerSecondSquared);
+
+            Assert.False(oneRadianPerSecondSquared > twoRadiansPerSecondSquared);
+            Assert.False(oneRadianPerSecondSquared >= twoRadiansPerSecondSquared);
+            Assert.False(twoRadiansPerSecondSquared < oneRadianPerSecondSquared);
+            Assert.False(twoRadiansPerSecondSquared <= oneRadianPerSecondSquared);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            Assert.Equal(0, radianpersecondsquared.CompareTo(radianpersecondsquared));
+            Assert.True(radianpersecondsquared.CompareTo(RotationalAcceleration<double>.Zero) > 0);
+            Assert.True(RotationalAcceleration<double>.Zero.CompareTo(radianpersecondsquared) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            Assert.Throws<ArgumentException>(() => radianpersecondsquared.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            Assert.Throws<ArgumentNullException>(() => radianpersecondsquared.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            var b = RotationalAcceleration<double>.FromRadiansPerSecondSquared(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            var b = RotationalAcceleration<double>.FromRadiansPerSecondSquared(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            Assert.True(v.Equals(RotationalAcceleration<double>.FromRadiansPerSecondSquared(1), RadiansPerSecondSquaredTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RotationalAcceleration<double>.Zero, RadiansPerSecondSquaredTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            Assert.False(radianpersecondsquared.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            Assert.False(radianpersecondsquared.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(RotationalAccelerationUnit.Undefined, RotationalAcceleration<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(RotationalAccelerationUnit)).Cast<RotationalAccelerationUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == RotationalAccelerationUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(RotationalAcceleration<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/RotationalStiffnessPerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalStiffnessPerLengthTestsBase.g.cs
new file mode 100644
index 0000000000..4f4a5d9f0e
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/RotationalStiffnessPerLengthTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of RotationalStiffnessPerLength.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class RotationalStiffnessPerLengthTestsBase
+    {
+        protected abstract double KilonewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter { get; }
+        protected abstract double MeganewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter { get; }
+        protected abstract double NewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilonewtonMetersPerRadianPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double MeganewtonMetersPerRadianPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double NewtonMetersPerRadianPerMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>((double)0.0, RotationalStiffnessPerLengthUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>(double.PositiveInfinity, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>(double.NegativeInfinity, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>(double.NaN, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
+        }
+
+        [Fact]
+        public void NewtonMeterPerRadianPerMeterToRotationalStiffnessPerLengthUnits()
+        {
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            AssertEx.EqualTolerance(KilonewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.KilonewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(MeganewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.MeganewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(NewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter).KilonewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter).MeganewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+        }
+
+        [Fact]
+        public void FromNewtonMetersPerRadianPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromNewtonMetersPerRadianPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            AssertEx.EqualTolerance(KilonewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.As(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter), KilonewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(MeganewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.As(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter), MeganewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(NewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.As(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter), NewtonMetersPerRadianPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+
+            var kilonewtonmeterperradianpermeterQuantity = newtonmeterperradianpermeter.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
+            AssertEx.EqualTolerance(KilonewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, (double)kilonewtonmeterperradianpermeterQuantity.Value, KilonewtonMetersPerRadianPerMeterTolerance);
+            Assert.Equal(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, kilonewtonmeterperradianpermeterQuantity.Unit);
+
+            var meganewtonmeterperradianpermeterQuantity = newtonmeterperradianpermeter.ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
+            AssertEx.EqualTolerance(MeganewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, (double)meganewtonmeterperradianpermeterQuantity.Value, MeganewtonMetersPerRadianPerMeterTolerance);
+            Assert.Equal(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, meganewtonmeterperradianpermeterQuantity.Unit);
+
+            var newtonmeterperradianpermeterQuantity = newtonmeterperradianpermeter.ToUnit(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
+            AssertEx.EqualTolerance(NewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, (double)newtonmeterperradianpermeterQuantity.Value, NewtonMetersPerRadianPerMeterTolerance);
+            Assert.Equal(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, newtonmeterperradianpermeterQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromKilonewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.KilonewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromMeganewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.MeganewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.NewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            RotationalStiffnessPerLength<double> v = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(3)-v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(10)/5).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(2, RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(10)/RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(5), NewtonMetersPerRadianPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            RotationalStiffnessPerLength<double> oneNewtonMeterPerRadianPerMeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> twoNewtonMetersPerRadianPerMeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(2);
+
+            Assert.True(oneNewtonMeterPerRadianPerMeter < twoNewtonMetersPerRadianPerMeter);
+            Assert.True(oneNewtonMeterPerRadianPerMeter <= twoNewtonMetersPerRadianPerMeter);
+            Assert.True(twoNewtonMetersPerRadianPerMeter > oneNewtonMeterPerRadianPerMeter);
+            Assert.True(twoNewtonMetersPerRadianPerMeter >= oneNewtonMeterPerRadianPerMeter);
+
+            Assert.False(oneNewtonMeterPerRadianPerMeter > twoNewtonMetersPerRadianPerMeter);
+            Assert.False(oneNewtonMeterPerRadianPerMeter >= twoNewtonMetersPerRadianPerMeter);
+            Assert.False(twoNewtonMetersPerRadianPerMeter < oneNewtonMeterPerRadianPerMeter);
+            Assert.False(twoNewtonMetersPerRadianPerMeter <= oneNewtonMeterPerRadianPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            Assert.Equal(0, newtonmeterperradianpermeter.CompareTo(newtonmeterperradianpermeter));
+            Assert.True(newtonmeterperradianpermeter.CompareTo(RotationalStiffnessPerLength<double>.Zero) > 0);
+            Assert.True(RotationalStiffnessPerLength<double>.Zero.CompareTo(newtonmeterperradianpermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            Assert.Throws<ArgumentException>(() => newtonmeterperradianpermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => newtonmeterperradianpermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            var b = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            var b = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            Assert.True(v.Equals(RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1), NewtonMetersPerRadianPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RotationalStiffnessPerLength<double>.Zero, NewtonMetersPerRadianPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            Assert.False(newtonmeterperradianpermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            Assert.False(newtonmeterperradianpermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(RotationalStiffnessPerLengthUnit.Undefined, RotationalStiffnessPerLength<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(RotationalStiffnessPerLengthUnit)).Cast<RotationalStiffnessPerLengthUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == RotationalStiffnessPerLengthUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(RotationalStiffnessPerLength<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/RotationalStiffnessTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalStiffnessTestsBase.g.cs
new file mode 100644
index 0000000000..5b7dcb33c2
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/RotationalStiffnessTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of RotationalStiffness.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class RotationalStiffnessTestsBase
+    {
+        protected abstract double KilonewtonMetersPerRadianInOneNewtonMeterPerRadian { get; }
+        protected abstract double MeganewtonMetersPerRadianInOneNewtonMeterPerRadian { get; }
+        protected abstract double NewtonMetersPerRadianInOneNewtonMeterPerRadian { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KilonewtonMetersPerRadianTolerance { get { return 1e-5; } }
+        protected virtual double MeganewtonMetersPerRadianTolerance { get { return 1e-5; } }
+        protected virtual double NewtonMetersPerRadianTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>((double)0.0, RotationalStiffnessUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>(double.PositiveInfinity, RotationalStiffnessUnit.NewtonMeterPerRadian));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>(double.NegativeInfinity, RotationalStiffnessUnit.NewtonMeterPerRadian));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>(double.NaN, RotationalStiffnessUnit.NewtonMeterPerRadian));
+        }
+
+        [Fact]
+        public void NewtonMeterPerRadianToRotationalStiffnessUnits()
+        {
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.KilonewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.From(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian).KilonewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian).MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NewtonMeterPerRadian).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+        }
+
+        [Fact]
+        public void FromNewtonMetersPerRadian_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RotationalStiffness<double>.FromNewtonMetersPerRadian(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalStiffness<double>.FromNewtonMetersPerRadian(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromNewtonMetersPerRadian_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => RotationalStiffness<double>.FromNewtonMetersPerRadian(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.KilonewtonMeterPerRadian), KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.MeganewtonMeterPerRadian), MeganewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.NewtonMeterPerRadian), NewtonMetersPerRadianTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+
+            var kilonewtonmeterperradianQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
+            AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)kilonewtonmeterperradianQuantity.Value, KilonewtonMetersPerRadianTolerance);
+            Assert.Equal(RotationalStiffnessUnit.KilonewtonMeterPerRadian, kilonewtonmeterperradianQuantity.Unit);
+
+            var meganewtonmeterperradianQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+            AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)meganewtonmeterperradianQuantity.Value, MeganewtonMetersPerRadianTolerance);
+            Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, meganewtonmeterperradianQuantity.Unit);
+
+            var newtonmeterperradianQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian);
+            AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)newtonmeterperradianQuantity.Value, NewtonMetersPerRadianTolerance);
+            Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, newtonmeterperradianQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromKilonewtonMetersPerRadian(newtonmeterperradian.KilonewtonMetersPerRadian).NewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMeganewtonMetersPerRadian(newtonmeterperradian.MeganewtonMetersPerRadian).NewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNewtonMetersPerRadian(newtonmeterperradian.NewtonMetersPerRadian).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            RotationalStiffness<double> v = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            AssertEx.EqualTolerance(-1, -v.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffness<double>.FromNewtonMetersPerRadian(3)-v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(2, (v + v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(10, (v*10).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(10, (10*v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffness<double>.FromNewtonMetersPerRadian(10)/5).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(2, RotationalStiffness<double>.FromNewtonMetersPerRadian(10)/RotationalStiffness<double>.FromNewtonMetersPerRadian(5), NewtonMetersPerRadianTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            RotationalStiffness<double> oneNewtonMeterPerRadian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> twoNewtonMetersPerRadian = RotationalStiffness<double>.FromNewtonMetersPerRadian(2);
+
+            Assert.True(oneNewtonMeterPerRadian < twoNewtonMetersPerRadian);
+            Assert.True(oneNewtonMeterPerRadian <= twoNewtonMetersPerRadian);
+            Assert.True(twoNewtonMetersPerRadian > oneNewtonMeterPerRadian);
+            Assert.True(twoNewtonMetersPerRadian >= oneNewtonMeterPerRadian);
+
+            Assert.False(oneNewtonMeterPerRadian > twoNewtonMetersPerRadian);
+            Assert.False(oneNewtonMeterPerRadian >= twoNewtonMetersPerRadian);
+            Assert.False(twoNewtonMetersPerRadian < oneNewtonMeterPerRadian);
+            Assert.False(twoNewtonMetersPerRadian <= oneNewtonMeterPerRadian);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            Assert.Equal(0, newtonmeterperradian.CompareTo(newtonmeterperradian));
+            Assert.True(newtonmeterperradian.CompareTo(RotationalStiffness<double>.Zero) > 0);
+            Assert.True(RotationalStiffness<double>.Zero.CompareTo(newtonmeterperradian) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            Assert.Throws<ArgumentException>(() => newtonmeterperradian.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            Assert.Throws<ArgumentNullException>(() => newtonmeterperradian.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            var b = RotationalStiffness<double>.FromNewtonMetersPerRadian(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            var b = RotationalStiffness<double>.FromNewtonMetersPerRadian(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            Assert.True(v.Equals(RotationalStiffness<double>.FromNewtonMetersPerRadian(1), NewtonMetersPerRadianTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RotationalStiffness<double>.Zero, NewtonMetersPerRadianTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            Assert.False(newtonmeterperradian.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            Assert.False(newtonmeterperradian.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(RotationalStiffnessUnit.Undefined, RotationalStiffness<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(RotationalStiffnessUnit)).Cast<RotationalStiffnessUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == RotationalStiffnessUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(RotationalStiffness<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/SolidAngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SolidAngleTestsBase.g.cs
new file mode 100644
index 0000000000..30536baff8
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/SolidAngleTestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of SolidAngle.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class SolidAngleTestsBase
+    {
+        protected abstract double SteradiansInOneSteradian { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double SteradiansTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>((double)0.0, SolidAngleUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>(double.PositiveInfinity, SolidAngleUnit.Steradian));
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>(double.NegativeInfinity, SolidAngleUnit.Steradian));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>(double.NaN, SolidAngleUnit.Steradian));
+        }
+
+        [Fact]
+        public void SteradianToSolidAngleUnits()
+        {
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            AssertEx.EqualTolerance(SteradiansInOneSteradian, steradian.Steradians, SteradiansTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, SolidAngle<double>.From(1, SolidAngleUnit.Steradian).Steradians, SteradiansTolerance);
+        }
+
+        [Fact]
+        public void FromSteradians_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => SolidAngle<double>.FromSteradians(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SolidAngle<double>.FromSteradians(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromSteradians_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => SolidAngle<double>.FromSteradians(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var steradian = SolidAngle<double>.FromSteradians(1);
+            AssertEx.EqualTolerance(SteradiansInOneSteradian, steradian.As(SolidAngleUnit.Steradian), SteradiansTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var steradian = SolidAngle<double>.FromSteradians(1);
+
+            var steradianQuantity = steradian.ToUnit(SolidAngleUnit.Steradian);
+            AssertEx.EqualTolerance(SteradiansInOneSteradian, (double)steradianQuantity.Value, SteradiansTolerance);
+            Assert.Equal(SolidAngleUnit.Steradian, steradianQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            AssertEx.EqualTolerance(1, SolidAngle<double>.FromSteradians(steradian.Steradians).Steradians, SteradiansTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            SolidAngle<double> v = SolidAngle<double>.FromSteradians(1);
+            AssertEx.EqualTolerance(-1, -v.Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(2, (SolidAngle<double>.FromSteradians(3)-v).Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(2, (SolidAngle<double>.FromSteradians(10)/5).Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(2, SolidAngle<double>.FromSteradians(10)/SolidAngle<double>.FromSteradians(5), SteradiansTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            SolidAngle<double> oneSteradian = SolidAngle<double>.FromSteradians(1);
+            SolidAngle<double> twoSteradians = SolidAngle<double>.FromSteradians(2);
+
+            Assert.True(oneSteradian < twoSteradians);
+            Assert.True(oneSteradian <= twoSteradians);
+            Assert.True(twoSteradians > oneSteradian);
+            Assert.True(twoSteradians >= oneSteradian);
+
+            Assert.False(oneSteradian > twoSteradians);
+            Assert.False(oneSteradian >= twoSteradians);
+            Assert.False(twoSteradians < oneSteradian);
+            Assert.False(twoSteradians <= oneSteradian);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            Assert.Equal(0, steradian.CompareTo(steradian));
+            Assert.True(steradian.CompareTo(SolidAngle<double>.Zero) > 0);
+            Assert.True(SolidAngle<double>.Zero.CompareTo(steradian) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            Assert.Throws<ArgumentException>(() => steradian.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            Assert.Throws<ArgumentNullException>(() => steradian.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = SolidAngle<double>.FromSteradians(1);
+            var b = SolidAngle<double>.FromSteradians(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = SolidAngle<double>.FromSteradians(1);
+            var b = SolidAngle<double>.FromSteradians(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = SolidAngle<double>.FromSteradians(1);
+            Assert.True(v.Equals(SolidAngle<double>.FromSteradians(1), SteradiansTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SolidAngle<double>.Zero, SteradiansTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            Assert.False(steradian.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            Assert.False(steradian.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(SolidAngleUnit.Undefined, SolidAngle<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(SolidAngleUnit)).Cast<SolidAngleUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == SolidAngleUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(SolidAngle<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
new file mode 100644
index 0000000000..43f55506db
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
@@ -0,0 +1,323 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of SpecificEnergy.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class SpecificEnergyTestsBase
+    {
+        protected abstract double BtuPerPoundInOneJoulePerKilogram { get; }
+        protected abstract double CaloriesPerGramInOneJoulePerKilogram { get; }
+        protected abstract double JoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double KilocaloriesPerGramInOneJoulePerKilogram { get; }
+        protected abstract double KilojoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double KilowattHoursPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double MegajoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double MegawattHoursPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double WattHoursPerKilogramInOneJoulePerKilogram { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double BtuPerPoundTolerance { get { return 1e-5; } }
+        protected virtual double CaloriesPerGramTolerance { get { return 1e-5; } }
+        protected virtual double JoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double KilocaloriesPerGramTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double KilowattHoursPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double MegawattHoursPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double WattHoursPerKilogramTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>((double)0.0, SpecificEnergyUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>(double.PositiveInfinity, SpecificEnergyUnit.JoulePerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>(double.NegativeInfinity, SpecificEnergyUnit.JoulePerKilogram));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>(double.NaN, SpecificEnergyUnit.JoulePerKilogram));
+        }
+
+        [Fact]
+        public void JoulePerKilogramToSpecificEnergyUnits()
+        {
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            AssertEx.EqualTolerance(BtuPerPoundInOneJoulePerKilogram, jouleperkilogram.BtuPerPound, BtuPerPoundTolerance);
+            AssertEx.EqualTolerance(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.CaloriesPerGram, CaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(JoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(KilocaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.KilocaloriesPerGram, KilocaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.KilojoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(KilowattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.KilowattHoursPerKilogram, KilowattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.MegajoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(MegawattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.MegawattHoursPerKilogram, MegawattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(WattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.WattHoursPerKilogram, WattHoursPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.BtuPerPound).BtuPerPound, BtuPerPoundTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.CaloriePerGram).CaloriesPerGram, CaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.JoulePerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilocaloriePerGram).KilocaloriesPerGram, KilocaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilojoulePerKilogram).KilojoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilowattHourPerKilogram).KilowattHoursPerKilogram, KilowattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.MegajoulePerKilogram).MegajoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.MegawattHourPerKilogram).MegawattHoursPerKilogram, MegawattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.From(1, SpecificEnergyUnit.WattHourPerKilogram).WattHoursPerKilogram, WattHoursPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void FromJoulesPerKilogram_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => SpecificEnergy<double>.FromJoulesPerKilogram(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificEnergy<double>.FromJoulesPerKilogram(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromJoulesPerKilogram_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => SpecificEnergy<double>.FromJoulesPerKilogram(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            AssertEx.EqualTolerance(BtuPerPoundInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.BtuPerPound), BtuPerPoundTolerance);
+            AssertEx.EqualTolerance(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.CaloriePerGram), CaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(JoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.JoulePerKilogram), JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(KilocaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilocaloriePerGram), KilocaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(KilojoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilojoulePerKilogram), KilojoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(KilowattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilowattHourPerKilogram), KilowattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(MegajoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.MegajoulePerKilogram), MegajoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(MegawattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.MegawattHourPerKilogram), MegawattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(WattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.WattHourPerKilogram), WattHoursPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+
+            var btuperpoundQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.BtuPerPound);
+            AssertEx.EqualTolerance(BtuPerPoundInOneJoulePerKilogram, (double)btuperpoundQuantity.Value, BtuPerPoundTolerance);
+            Assert.Equal(SpecificEnergyUnit.BtuPerPound, btuperpoundQuantity.Unit);
+
+            var caloriepergramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.CaloriePerGram);
+            AssertEx.EqualTolerance(CaloriesPerGramInOneJoulePerKilogram, (double)caloriepergramQuantity.Value, CaloriesPerGramTolerance);
+            Assert.Equal(SpecificEnergyUnit.CaloriePerGram, caloriepergramQuantity.Unit);
+
+            var jouleperkilogramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.JoulePerKilogram);
+            AssertEx.EqualTolerance(JoulesPerKilogramInOneJoulePerKilogram, (double)jouleperkilogramQuantity.Value, JoulesPerKilogramTolerance);
+            Assert.Equal(SpecificEnergyUnit.JoulePerKilogram, jouleperkilogramQuantity.Unit);
+
+            var kilocaloriepergramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.KilocaloriePerGram);
+            AssertEx.EqualTolerance(KilocaloriesPerGramInOneJoulePerKilogram, (double)kilocaloriepergramQuantity.Value, KilocaloriesPerGramTolerance);
+            Assert.Equal(SpecificEnergyUnit.KilocaloriePerGram, kilocaloriepergramQuantity.Unit);
+
+            var kilojouleperkilogramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.KilojoulePerKilogram);
+            AssertEx.EqualTolerance(KilojoulesPerKilogramInOneJoulePerKilogram, (double)kilojouleperkilogramQuantity.Value, KilojoulesPerKilogramTolerance);
+            Assert.Equal(SpecificEnergyUnit.KilojoulePerKilogram, kilojouleperkilogramQuantity.Unit);
+
+            var kilowatthourperkilogramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram);
+            AssertEx.EqualTolerance(KilowattHoursPerKilogramInOneJoulePerKilogram, (double)kilowatthourperkilogramQuantity.Value, KilowattHoursPerKilogramTolerance);
+            Assert.Equal(SpecificEnergyUnit.KilowattHourPerKilogram, kilowatthourperkilogramQuantity.Unit);
+
+            var megajouleperkilogramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.MegajoulePerKilogram);
+            AssertEx.EqualTolerance(MegajoulesPerKilogramInOneJoulePerKilogram, (double)megajouleperkilogramQuantity.Value, MegajoulesPerKilogramTolerance);
+            Assert.Equal(SpecificEnergyUnit.MegajoulePerKilogram, megajouleperkilogramQuantity.Unit);
+
+            var megawatthourperkilogramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram);
+            AssertEx.EqualTolerance(MegawattHoursPerKilogramInOneJoulePerKilogram, (double)megawatthourperkilogramQuantity.Value, MegawattHoursPerKilogramTolerance);
+            Assert.Equal(SpecificEnergyUnit.MegawattHourPerKilogram, megawatthourperkilogramQuantity.Unit);
+
+            var watthourperkilogramQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.WattHourPerKilogram);
+            AssertEx.EqualTolerance(WattHoursPerKilogramInOneJoulePerKilogram, (double)watthourperkilogramQuantity.Value, WattHoursPerKilogramTolerance);
+            Assert.Equal(SpecificEnergyUnit.WattHourPerKilogram, watthourperkilogramQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromBtuPerPound(jouleperkilogram.BtuPerPound).JoulesPerKilogram, BtuPerPoundTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromCaloriesPerGram(jouleperkilogram.CaloriesPerGram).JoulesPerKilogram, CaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromJoulesPerKilogram(jouleperkilogram.JoulesPerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilocaloriesPerGram(jouleperkilogram.KilocaloriesPerGram).JoulesPerKilogram, KilocaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilojoulesPerKilogram(jouleperkilogram.KilojoulesPerKilogram).JoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilowattHoursPerKilogram(jouleperkilogram.KilowattHoursPerKilogram).JoulesPerKilogram, KilowattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromMegajoulesPerKilogram(jouleperkilogram.MegajoulesPerKilogram).JoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromMegawattHoursPerKilogram(jouleperkilogram.MegawattHoursPerKilogram).JoulesPerKilogram, MegawattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromWattHoursPerKilogram(jouleperkilogram.WattHoursPerKilogram).JoulesPerKilogram, WattHoursPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            SpecificEnergy<double> v = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            AssertEx.EqualTolerance(-1, -v.JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificEnergy<double>.FromJoulesPerKilogram(3)-v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (v + v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(10, (v*10).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(10, (10*v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificEnergy<double>.FromJoulesPerKilogram(10)/5).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, SpecificEnergy<double>.FromJoulesPerKilogram(10)/SpecificEnergy<double>.FromJoulesPerKilogram(5), JoulesPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            SpecificEnergy<double> oneJoulePerKilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> twoJoulesPerKilogram = SpecificEnergy<double>.FromJoulesPerKilogram(2);
+
+            Assert.True(oneJoulePerKilogram < twoJoulesPerKilogram);
+            Assert.True(oneJoulePerKilogram <= twoJoulesPerKilogram);
+            Assert.True(twoJoulesPerKilogram > oneJoulePerKilogram);
+            Assert.True(twoJoulesPerKilogram >= oneJoulePerKilogram);
+
+            Assert.False(oneJoulePerKilogram > twoJoulesPerKilogram);
+            Assert.False(oneJoulePerKilogram >= twoJoulesPerKilogram);
+            Assert.False(twoJoulesPerKilogram < oneJoulePerKilogram);
+            Assert.False(twoJoulesPerKilogram <= oneJoulePerKilogram);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            Assert.Equal(0, jouleperkilogram.CompareTo(jouleperkilogram));
+            Assert.True(jouleperkilogram.CompareTo(SpecificEnergy<double>.Zero) > 0);
+            Assert.True(SpecificEnergy<double>.Zero.CompareTo(jouleperkilogram) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            Assert.Throws<ArgumentException>(() => jouleperkilogram.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            Assert.Throws<ArgumentNullException>(() => jouleperkilogram.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            var b = SpecificEnergy<double>.FromJoulesPerKilogram(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            var b = SpecificEnergy<double>.FromJoulesPerKilogram(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            Assert.True(v.Equals(SpecificEnergy<double>.FromJoulesPerKilogram(1), JoulesPerKilogramTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SpecificEnergy<double>.Zero, JoulesPerKilogramTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            Assert.False(jouleperkilogram.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            Assert.False(jouleperkilogram.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(SpecificEnergyUnit.Undefined, SpecificEnergy<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(SpecificEnergyUnit)).Cast<SpecificEnergyUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == SpecificEnergyUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(SpecificEnergy<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificVolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificVolumeTestsBase.g.cs
new file mode 100644
index 0000000000..714026e6be
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/SpecificVolumeTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of SpecificVolume.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class SpecificVolumeTestsBase
+    {
+        protected abstract double CubicFeetPerPoundInOneCubicMeterPerKilogram { get; }
+        protected abstract double CubicMetersPerKilogramInOneCubicMeterPerKilogram { get; }
+        protected abstract double MillicubicMetersPerKilogramInOneCubicMeterPerKilogram { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CubicFeetPerPoundTolerance { get { return 1e-5; } }
+        protected virtual double CubicMetersPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double MillicubicMetersPerKilogramTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>((double)0.0, SpecificVolumeUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>(double.PositiveInfinity, SpecificVolumeUnit.CubicMeterPerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>(double.NegativeInfinity, SpecificVolumeUnit.CubicMeterPerKilogram));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>(double.NaN, SpecificVolumeUnit.CubicMeterPerKilogram));
+        }
+
+        [Fact]
+        public void CubicMeterPerKilogramToSpecificVolumeUnits()
+        {
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, cubicmeterperkilogram.CubicFeetPerPound, CubicFeetPerPoundTolerance);
+            AssertEx.EqualTolerance(CubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.MillicubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.From(1, SpecificVolumeUnit.CubicFootPerPound).CubicFeetPerPound, CubicFeetPerPoundTolerance);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.From(1, SpecificVolumeUnit.CubicMeterPerKilogram).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.From(1, SpecificVolumeUnit.MillicubicMeterPerKilogram).MillicubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void FromCubicMetersPerKilogram_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => SpecificVolume<double>.FromCubicMetersPerKilogram(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificVolume<double>.FromCubicMetersPerKilogram(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromCubicMetersPerKilogram_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => SpecificVolume<double>.FromCubicMetersPerKilogram(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.CubicFootPerPound), CubicFeetPerPoundTolerance);
+            AssertEx.EqualTolerance(CubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.CubicMeterPerKilogram), CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.MillicubicMeterPerKilogram), MillicubicMetersPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+
+            var cubicfootperpoundQuantity = cubicmeterperkilogram.ToUnit(SpecificVolumeUnit.CubicFootPerPound);
+            AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, (double)cubicfootperpoundQuantity.Value, CubicFeetPerPoundTolerance);
+            Assert.Equal(SpecificVolumeUnit.CubicFootPerPound, cubicfootperpoundQuantity.Unit);
+
+            var cubicmeterperkilogramQuantity = cubicmeterperkilogram.ToUnit(SpecificVolumeUnit.CubicMeterPerKilogram);
+            AssertEx.EqualTolerance(CubicMetersPerKilogramInOneCubicMeterPerKilogram, (double)cubicmeterperkilogramQuantity.Value, CubicMetersPerKilogramTolerance);
+            Assert.Equal(SpecificVolumeUnit.CubicMeterPerKilogram, cubicmeterperkilogramQuantity.Unit);
+
+            var millicubicmeterperkilogramQuantity = cubicmeterperkilogram.ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram);
+            AssertEx.EqualTolerance(MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, (double)millicubicmeterperkilogramQuantity.Value, MillicubicMetersPerKilogramTolerance);
+            Assert.Equal(SpecificVolumeUnit.MillicubicMeterPerKilogram, millicubicmeterperkilogramQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.FromCubicFeetPerPound(cubicmeterperkilogram.CubicFeetPerPound).CubicMetersPerKilogram, CubicFeetPerPoundTolerance);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.FromCubicMetersPerKilogram(cubicmeterperkilogram.CubicMetersPerKilogram).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.FromMillicubicMetersPerKilogram(cubicmeterperkilogram.MillicubicMetersPerKilogram).CubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            SpecificVolume<double> v = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            AssertEx.EqualTolerance(-1, -v.CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificVolume<double>.FromCubicMetersPerKilogram(3)-v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (v + v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(10, (v*10).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(10, (10*v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificVolume<double>.FromCubicMetersPerKilogram(10)/5).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, SpecificVolume<double>.FromCubicMetersPerKilogram(10)/SpecificVolume<double>.FromCubicMetersPerKilogram(5), CubicMetersPerKilogramTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            SpecificVolume<double> oneCubicMeterPerKilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> twoCubicMetersPerKilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(2);
+
+            Assert.True(oneCubicMeterPerKilogram < twoCubicMetersPerKilogram);
+            Assert.True(oneCubicMeterPerKilogram <= twoCubicMetersPerKilogram);
+            Assert.True(twoCubicMetersPerKilogram > oneCubicMeterPerKilogram);
+            Assert.True(twoCubicMetersPerKilogram >= oneCubicMeterPerKilogram);
+
+            Assert.False(oneCubicMeterPerKilogram > twoCubicMetersPerKilogram);
+            Assert.False(oneCubicMeterPerKilogram >= twoCubicMetersPerKilogram);
+            Assert.False(twoCubicMetersPerKilogram < oneCubicMeterPerKilogram);
+            Assert.False(twoCubicMetersPerKilogram <= oneCubicMeterPerKilogram);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            Assert.Equal(0, cubicmeterperkilogram.CompareTo(cubicmeterperkilogram));
+            Assert.True(cubicmeterperkilogram.CompareTo(SpecificVolume<double>.Zero) > 0);
+            Assert.True(SpecificVolume<double>.Zero.CompareTo(cubicmeterperkilogram) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            Assert.Throws<ArgumentException>(() => cubicmeterperkilogram.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            Assert.Throws<ArgumentNullException>(() => cubicmeterperkilogram.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            var b = SpecificVolume<double>.FromCubicMetersPerKilogram(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            var b = SpecificVolume<double>.FromCubicMetersPerKilogram(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            Assert.True(v.Equals(SpecificVolume<double>.FromCubicMetersPerKilogram(1), CubicMetersPerKilogramTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SpecificVolume<double>.Zero, CubicMetersPerKilogramTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            Assert.False(cubicmeterperkilogram.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            Assert.False(cubicmeterperkilogram.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(SpecificVolumeUnit.Undefined, SpecificVolume<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(SpecificVolumeUnit)).Cast<SpecificVolumeUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == SpecificVolumeUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(SpecificVolume<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs
new file mode 100644
index 0000000000..465706a919
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs
@@ -0,0 +1,313 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of TemperatureDelta.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class TemperatureDeltaTestsBase
+    {
+        protected abstract double DegreesCelsiusInOneKelvin { get; }
+        protected abstract double DegreesDelisleInOneKelvin { get; }
+        protected abstract double DegreesFahrenheitInOneKelvin { get; }
+        protected abstract double DegreesNewtonInOneKelvin { get; }
+        protected abstract double DegreesRankineInOneKelvin { get; }
+        protected abstract double DegreesReaumurInOneKelvin { get; }
+        protected abstract double DegreesRoemerInOneKelvin { get; }
+        protected abstract double KelvinsInOneKelvin { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DegreesCelsiusTolerance { get { return 1e-5; } }
+        protected virtual double DegreesDelisleTolerance { get { return 1e-5; } }
+        protected virtual double DegreesFahrenheitTolerance { get { return 1e-5; } }
+        protected virtual double DegreesNewtonTolerance { get { return 1e-5; } }
+        protected virtual double DegreesRankineTolerance { get { return 1e-5; } }
+        protected virtual double DegreesReaumurTolerance { get { return 1e-5; } }
+        protected virtual double DegreesRoemerTolerance { get { return 1e-5; } }
+        protected virtual double KelvinsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>((double)0.0, TemperatureDeltaUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>(double.PositiveInfinity, TemperatureDeltaUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>(double.NegativeInfinity, TemperatureDeltaUnit.Kelvin));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>(double.NaN, TemperatureDeltaUnit.Kelvin));
+        }
+
+        [Fact]
+        public void KelvinToTemperatureDeltaUnits()
+        {
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.DegreesCelsius, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.DegreesDelisle, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.DegreesFahrenheit, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.DegreesNewton, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.DegreesRankine, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.DegreesReaumur, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.DegreesRoemer, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.Kelvins, KelvinsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeCelsius).DegreesCelsius, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeDelisle).DegreesDelisle, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeFahrenheit).DegreesFahrenheit, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeNewton).DegreesNewton, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeRankine).DegreesRankine, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeReaumur).DegreesReaumur, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeRoemer).DegreesRoemer, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.From(1, TemperatureDeltaUnit.Kelvin).Kelvins, KelvinsTolerance);
+        }
+
+        [Fact]
+        public void FromKelvins_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => TemperatureDelta<double>.FromKelvins(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => TemperatureDelta<double>.FromKelvins(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromKelvins_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => TemperatureDelta<double>.FromKelvins(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var kelvin = TemperatureDelta<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeCelsius), DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeDelisle), DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeFahrenheit), DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeNewton), DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRankine), DegreesRankineTolerance);
+            AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeReaumur), DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRoemer), DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.As(TemperatureDeltaUnit.Kelvin), KelvinsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var kelvin = TemperatureDelta<double>.FromKelvins(1);
+
+            var degreecelsiusQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeCelsius);
+            AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, (double)degreecelsiusQuantity.Value, DegreesCelsiusTolerance);
+            Assert.Equal(TemperatureDeltaUnit.DegreeCelsius, degreecelsiusQuantity.Unit);
+
+            var degreedelisleQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeDelisle);
+            AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, (double)degreedelisleQuantity.Value, DegreesDelisleTolerance);
+            Assert.Equal(TemperatureDeltaUnit.DegreeDelisle, degreedelisleQuantity.Unit);
+
+            var degreefahrenheitQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeFahrenheit);
+            AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, (double)degreefahrenheitQuantity.Value, DegreesFahrenheitTolerance);
+            Assert.Equal(TemperatureDeltaUnit.DegreeFahrenheit, degreefahrenheitQuantity.Unit);
+
+            var degreenewtonQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeNewton);
+            AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, (double)degreenewtonQuantity.Value, DegreesNewtonTolerance);
+            Assert.Equal(TemperatureDeltaUnit.DegreeNewton, degreenewtonQuantity.Unit);
+
+            var degreerankineQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeRankine);
+            AssertEx.EqualTolerance(DegreesRankineInOneKelvin, (double)degreerankineQuantity.Value, DegreesRankineTolerance);
+            Assert.Equal(TemperatureDeltaUnit.DegreeRankine, degreerankineQuantity.Unit);
+
+            var degreereaumurQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeReaumur);
+            AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, (double)degreereaumurQuantity.Value, DegreesReaumurTolerance);
+            Assert.Equal(TemperatureDeltaUnit.DegreeReaumur, degreereaumurQuantity.Unit);
+
+            var degreeroemerQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeRoemer);
+            AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, (double)degreeroemerQuantity.Value, DegreesRoemerTolerance);
+            Assert.Equal(TemperatureDeltaUnit.DegreeRoemer, degreeroemerQuantity.Unit);
+
+            var kelvinQuantity = kelvin.ToUnit(TemperatureDeltaUnit.Kelvin);
+            AssertEx.EqualTolerance(KelvinsInOneKelvin, (double)kelvinQuantity.Value, KelvinsTolerance);
+            Assert.Equal(TemperatureDeltaUnit.Kelvin, kelvinQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            TemperatureDelta<double> v = TemperatureDelta<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(-1, -v.Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(2, (TemperatureDelta<double>.FromKelvins(3)-v).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(2, (TemperatureDelta<double>.FromKelvins(10)/5).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(2, TemperatureDelta<double>.FromKelvins(10)/TemperatureDelta<double>.FromKelvins(5), KelvinsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            TemperatureDelta<double> oneKelvin = TemperatureDelta<double>.FromKelvins(1);
+            TemperatureDelta<double> twoKelvins = TemperatureDelta<double>.FromKelvins(2);
+
+            Assert.True(oneKelvin < twoKelvins);
+            Assert.True(oneKelvin <= twoKelvins);
+            Assert.True(twoKelvins > oneKelvin);
+            Assert.True(twoKelvins >= oneKelvin);
+
+            Assert.False(oneKelvin > twoKelvins);
+            Assert.False(oneKelvin >= twoKelvins);
+            Assert.False(twoKelvins < oneKelvin);
+            Assert.False(twoKelvins <= oneKelvin);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            Assert.Equal(0, kelvin.CompareTo(kelvin));
+            Assert.True(kelvin.CompareTo(TemperatureDelta<double>.Zero) > 0);
+            Assert.True(TemperatureDelta<double>.Zero.CompareTo(kelvin) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            Assert.Throws<ArgumentException>(() => kelvin.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            Assert.Throws<ArgumentNullException>(() => kelvin.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = TemperatureDelta<double>.FromKelvins(1);
+            var b = TemperatureDelta<double>.FromKelvins(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = TemperatureDelta<double>.FromKelvins(1);
+            var b = TemperatureDelta<double>.FromKelvins(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = TemperatureDelta<double>.FromKelvins(1);
+            Assert.True(v.Equals(TemperatureDelta<double>.FromKelvins(1), KelvinsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(TemperatureDelta<double>.Zero, KelvinsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            Assert.False(kelvin.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            Assert.False(kelvin.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(TemperatureDeltaUnit.Undefined, TemperatureDelta<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(TemperatureDeltaUnit)).Cast<TemperatureDeltaUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == TemperatureDeltaUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(TemperatureDelta<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs
new file mode 100644
index 0000000000..65a2f49924
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs
@@ -0,0 +1,311 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of Temperature.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class TemperatureTestsBase
+    {
+        protected abstract double DegreesCelsiusInOneKelvin { get; }
+        protected abstract double DegreesDelisleInOneKelvin { get; }
+        protected abstract double DegreesFahrenheitInOneKelvin { get; }
+        protected abstract double DegreesNewtonInOneKelvin { get; }
+        protected abstract double DegreesRankineInOneKelvin { get; }
+        protected abstract double DegreesReaumurInOneKelvin { get; }
+        protected abstract double DegreesRoemerInOneKelvin { get; }
+        protected abstract double KelvinsInOneKelvin { get; }
+        protected abstract double SolarTemperaturesInOneKelvin { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double DegreesCelsiusTolerance { get { return 1e-5; } }
+        protected virtual double DegreesDelisleTolerance { get { return 1e-5; } }
+        protected virtual double DegreesFahrenheitTolerance { get { return 1e-5; } }
+        protected virtual double DegreesNewtonTolerance { get { return 1e-5; } }
+        protected virtual double DegreesRankineTolerance { get { return 1e-5; } }
+        protected virtual double DegreesReaumurTolerance { get { return 1e-5; } }
+        protected virtual double DegreesRoemerTolerance { get { return 1e-5; } }
+        protected virtual double KelvinsTolerance { get { return 1e-5; } }
+        protected virtual double SolarTemperaturesTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Temperature<double>((double)0.0, TemperatureUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Temperature<double>(double.PositiveInfinity, TemperatureUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new Temperature<double>(double.NegativeInfinity, TemperatureUnit.Kelvin));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new Temperature<double>(double.NaN, TemperatureUnit.Kelvin));
+        }
+
+        [Fact]
+        public void KelvinToTemperatureUnits()
+        {
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.DegreesCelsius, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.DegreesDelisle, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.DegreesFahrenheit, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.DegreesNewton, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.DegreesRankine, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.DegreesReaumur, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.DegreesRoemer, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(SolarTemperaturesInOneKelvin, kelvin.SolarTemperatures, SolarTemperaturesTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.DegreeCelsius).DegreesCelsius, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.DegreeDelisle).DegreesDelisle, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.DegreeFahrenheit).DegreesFahrenheit, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.DegreeNewton).DegreesNewton, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.DegreeRankine).DegreesRankine, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.DegreeReaumur).DegreesReaumur, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.DegreeRoemer).DegreesRoemer, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.Kelvin).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.From(1, TemperatureUnit.SolarTemperature).SolarTemperatures, SolarTemperaturesTolerance);
+        }
+
+        [Fact]
+        public void FromKelvins_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Temperature<double>.FromKelvins(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Temperature<double>.FromKelvins(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromKelvins_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => Temperature<double>.FromKelvins(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var kelvin = Temperature<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.As(TemperatureUnit.DegreeCelsius), DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.As(TemperatureUnit.DegreeDelisle), DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.As(TemperatureUnit.DegreeFahrenheit), DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.As(TemperatureUnit.DegreeNewton), DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.As(TemperatureUnit.DegreeRankine), DegreesRankineTolerance);
+            AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.As(TemperatureUnit.DegreeReaumur), DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.As(TemperatureUnit.DegreeRoemer), DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.As(TemperatureUnit.Kelvin), KelvinsTolerance);
+            AssertEx.EqualTolerance(SolarTemperaturesInOneKelvin, kelvin.As(TemperatureUnit.SolarTemperature), SolarTemperaturesTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var kelvin = Temperature<double>.FromKelvins(1);
+
+            var degreecelsiusQuantity = kelvin.ToUnit(TemperatureUnit.DegreeCelsius);
+            AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, (double)degreecelsiusQuantity.Value, DegreesCelsiusTolerance);
+            Assert.Equal(TemperatureUnit.DegreeCelsius, degreecelsiusQuantity.Unit);
+
+            var degreedelisleQuantity = kelvin.ToUnit(TemperatureUnit.DegreeDelisle);
+            AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, (double)degreedelisleQuantity.Value, DegreesDelisleTolerance);
+            Assert.Equal(TemperatureUnit.DegreeDelisle, degreedelisleQuantity.Unit);
+
+            var degreefahrenheitQuantity = kelvin.ToUnit(TemperatureUnit.DegreeFahrenheit);
+            AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, (double)degreefahrenheitQuantity.Value, DegreesFahrenheitTolerance);
+            Assert.Equal(TemperatureUnit.DegreeFahrenheit, degreefahrenheitQuantity.Unit);
+
+            var degreenewtonQuantity = kelvin.ToUnit(TemperatureUnit.DegreeNewton);
+            AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, (double)degreenewtonQuantity.Value, DegreesNewtonTolerance);
+            Assert.Equal(TemperatureUnit.DegreeNewton, degreenewtonQuantity.Unit);
+
+            var degreerankineQuantity = kelvin.ToUnit(TemperatureUnit.DegreeRankine);
+            AssertEx.EqualTolerance(DegreesRankineInOneKelvin, (double)degreerankineQuantity.Value, DegreesRankineTolerance);
+            Assert.Equal(TemperatureUnit.DegreeRankine, degreerankineQuantity.Unit);
+
+            var degreereaumurQuantity = kelvin.ToUnit(TemperatureUnit.DegreeReaumur);
+            AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, (double)degreereaumurQuantity.Value, DegreesReaumurTolerance);
+            Assert.Equal(TemperatureUnit.DegreeReaumur, degreereaumurQuantity.Unit);
+
+            var degreeroemerQuantity = kelvin.ToUnit(TemperatureUnit.DegreeRoemer);
+            AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, (double)degreeroemerQuantity.Value, DegreesRoemerTolerance);
+            Assert.Equal(TemperatureUnit.DegreeRoemer, degreeroemerQuantity.Unit);
+
+            var kelvinQuantity = kelvin.ToUnit(TemperatureUnit.Kelvin);
+            AssertEx.EqualTolerance(KelvinsInOneKelvin, (double)kelvinQuantity.Value, KelvinsTolerance);
+            Assert.Equal(TemperatureUnit.Kelvin, kelvinQuantity.Unit);
+
+            var solartemperatureQuantity = kelvin.ToUnit(TemperatureUnit.SolarTemperature);
+            AssertEx.EqualTolerance(SolarTemperaturesInOneKelvin, (double)solartemperatureQuantity.Value, SolarTemperaturesTolerance);
+            Assert.Equal(TemperatureUnit.SolarTemperature, solartemperatureQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromSolarTemperatures(kelvin.SolarTemperatures).Kelvins, SolarTemperaturesTolerance);
+        }
+
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            Temperature<double> oneKelvin = Temperature<double>.FromKelvins(1);
+            Temperature<double> twoKelvins = Temperature<double>.FromKelvins(2);
+
+            Assert.True(oneKelvin < twoKelvins);
+            Assert.True(oneKelvin <= twoKelvins);
+            Assert.True(twoKelvins > oneKelvin);
+            Assert.True(twoKelvins >= oneKelvin);
+
+            Assert.False(oneKelvin > twoKelvins);
+            Assert.False(oneKelvin >= twoKelvins);
+            Assert.False(twoKelvins < oneKelvin);
+            Assert.False(twoKelvins <= oneKelvin);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            Assert.Equal(0, kelvin.CompareTo(kelvin));
+            Assert.True(kelvin.CompareTo(Temperature<double>.Zero) > 0);
+            Assert.True(Temperature<double>.Zero.CompareTo(kelvin) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            Assert.Throws<ArgumentException>(() => kelvin.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            Assert.Throws<ArgumentNullException>(() => kelvin.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = Temperature<double>.FromKelvins(1);
+            var b = Temperature<double>.FromKelvins(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = Temperature<double>.FromKelvins(1);
+            var b = Temperature<double>.FromKelvins(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = Temperature<double>.FromKelvins(1);
+            Assert.True(v.Equals(Temperature<double>.FromKelvins(1), KelvinsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Temperature<double>.Zero, KelvinsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            Assert.False(kelvin.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            Assert.False(kelvin.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(TemperatureUnit.Undefined, Temperature<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(TemperatureUnit)).Cast<TemperatureUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == TemperatureUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(Temperature<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs
index 06781f66f7..20e17d2923 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs
@@ -72,7 +72,7 @@ public abstract partial class AccelerationTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Acceleration((double)0.0, AccelerationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Acceleration<double>((double)0.0, AccelerationUnit.Undefined));
         }
 
         [Fact]
@@ -87,14 +87,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Acceleration(double.PositiveInfinity, AccelerationUnit.MeterPerSecondSquared));
-            Assert.Throws<ArgumentException>(() => new Acceleration(double.NegativeInfinity, AccelerationUnit.MeterPerSecondSquared));
+            Assert.Throws<ArgumentException>(() => new Acceleration<double>(double.PositiveInfinity, AccelerationUnit.MeterPerSecondSquared));
+            Assert.Throws<ArgumentException>(() => new Acceleration<double>(double.NegativeInfinity, AccelerationUnit.MeterPerSecondSquared));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Acceleration(double.NaN, AccelerationUnit.MeterPerSecondSquared));
+            Assert.Throws<ArgumentException>(() => new Acceleration<double>(double.NaN, AccelerationUnit.MeterPerSecondSquared));
         }
 
         [Fact]
@@ -140,7 +140,7 @@ public void Acceleration_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void MeterPerSecondSquaredToAccelerationUnits()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration<double> meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
             AssertEx.EqualTolerance(CentimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.CentimetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(DecimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.DecimetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(FeetPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.FeetPerSecondSquared, FeetPerSecondSquaredTolerance);
@@ -160,59 +160,59 @@ public void MeterPerSecondSquaredToAccelerationUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared);
+            var quantity00 = Acceleration<double>.From(1, AccelerationUnit.CentimeterPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity00.CentimetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.CentimeterPerSecondSquared, quantity00.Unit);
 
-            var quantity01 = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared);
+            var quantity01 = Acceleration<double>.From(1, AccelerationUnit.DecimeterPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity01.DecimetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.DecimeterPerSecondSquared, quantity01.Unit);
 
-            var quantity02 = Acceleration.From(1, AccelerationUnit.FootPerSecondSquared);
+            var quantity02 = Acceleration<double>.From(1, AccelerationUnit.FootPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity02.FeetPerSecondSquared, FeetPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.FootPerSecondSquared, quantity02.Unit);
 
-            var quantity03 = Acceleration.From(1, AccelerationUnit.InchPerSecondSquared);
+            var quantity03 = Acceleration<double>.From(1, AccelerationUnit.InchPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity03.InchesPerSecondSquared, InchesPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.InchPerSecondSquared, quantity03.Unit);
 
-            var quantity04 = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared);
+            var quantity04 = Acceleration<double>.From(1, AccelerationUnit.KilometerPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity04.KilometersPerSecondSquared, KilometersPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.KilometerPerSecondSquared, quantity04.Unit);
 
-            var quantity05 = Acceleration.From(1, AccelerationUnit.KnotPerHour);
+            var quantity05 = Acceleration<double>.From(1, AccelerationUnit.KnotPerHour);
             AssertEx.EqualTolerance(1, quantity05.KnotsPerHour, KnotsPerHourTolerance);
             Assert.Equal(AccelerationUnit.KnotPerHour, quantity05.Unit);
 
-            var quantity06 = Acceleration.From(1, AccelerationUnit.KnotPerMinute);
+            var quantity06 = Acceleration<double>.From(1, AccelerationUnit.KnotPerMinute);
             AssertEx.EqualTolerance(1, quantity06.KnotsPerMinute, KnotsPerMinuteTolerance);
             Assert.Equal(AccelerationUnit.KnotPerMinute, quantity06.Unit);
 
-            var quantity07 = Acceleration.From(1, AccelerationUnit.KnotPerSecond);
+            var quantity07 = Acceleration<double>.From(1, AccelerationUnit.KnotPerSecond);
             AssertEx.EqualTolerance(1, quantity07.KnotsPerSecond, KnotsPerSecondTolerance);
             Assert.Equal(AccelerationUnit.KnotPerSecond, quantity07.Unit);
 
-            var quantity08 = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared);
+            var quantity08 = Acceleration<double>.From(1, AccelerationUnit.MeterPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity08.MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.MeterPerSecondSquared, quantity08.Unit);
 
-            var quantity09 = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared);
+            var quantity09 = Acceleration<double>.From(1, AccelerationUnit.MicrometerPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity09.MicrometersPerSecondSquared, MicrometersPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.MicrometerPerSecondSquared, quantity09.Unit);
 
-            var quantity10 = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared);
+            var quantity10 = Acceleration<double>.From(1, AccelerationUnit.MillimeterPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity10.MillimetersPerSecondSquared, MillimetersPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.MillimeterPerSecondSquared, quantity10.Unit);
 
-            var quantity11 = Acceleration.From(1, AccelerationUnit.MillistandardGravity);
+            var quantity11 = Acceleration<double>.From(1, AccelerationUnit.MillistandardGravity);
             AssertEx.EqualTolerance(1, quantity11.MillistandardGravity, MillistandardGravityTolerance);
             Assert.Equal(AccelerationUnit.MillistandardGravity, quantity11.Unit);
 
-            var quantity12 = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared);
+            var quantity12 = Acceleration<double>.From(1, AccelerationUnit.NanometerPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity12.NanometersPerSecondSquared, NanometersPerSecondSquaredTolerance);
             Assert.Equal(AccelerationUnit.NanometerPerSecondSquared, quantity12.Unit);
 
-            var quantity13 = Acceleration.From(1, AccelerationUnit.StandardGravity);
+            var quantity13 = Acceleration<double>.From(1, AccelerationUnit.StandardGravity);
             AssertEx.EqualTolerance(1, quantity13.StandardGravity, StandardGravityTolerance);
             Assert.Equal(AccelerationUnit.StandardGravity, quantity13.Unit);
 
@@ -221,20 +221,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromMetersPerSecondSquared_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Acceleration.FromMetersPerSecondSquared(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Acceleration.FromMetersPerSecondSquared(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Acceleration<double>.FromMetersPerSecondSquared(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Acceleration<double>.FromMetersPerSecondSquared(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromMetersPerSecondSquared_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Acceleration.FromMetersPerSecondSquared(double.NaN));
+            Assert.Throws<ArgumentException>(() => Acceleration<double>.FromMetersPerSecondSquared(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            var meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
             AssertEx.EqualTolerance(CentimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.CentimeterPerSecondSquared), CentimetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(DecimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.DecimeterPerSecondSquared), DecimetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(FeetPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.FootPerSecondSquared), FeetPerSecondSquaredTolerance);
@@ -271,7 +271,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            var meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
 
             var centimeterpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.CentimeterPerSecondSquared);
             AssertEx.EqualTolerance(CentimetersPerSecondSquaredInOneMeterPerSecondSquared, (double)centimeterpersecondsquaredQuantity.Value, CentimetersPerSecondSquaredTolerance);
@@ -340,41 +340,41 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
-            AssertEx.EqualTolerance(1, Acceleration.FromCentimetersPerSecondSquared(meterpersecondsquared.CentimetersPerSecondSquared).MetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromDecimetersPerSecondSquared(meterpersecondsquared.DecimetersPerSecondSquared).MetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromFeetPerSecondSquared(meterpersecondsquared.FeetPerSecondSquared).MetersPerSecondSquared, FeetPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromInchesPerSecondSquared(meterpersecondsquared.InchesPerSecondSquared).MetersPerSecondSquared, InchesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKilometersPerSecondSquared(meterpersecondsquared.KilometersPerSecondSquared).MetersPerSecondSquared, KilometersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerHour(meterpersecondsquared.KnotsPerHour).MetersPerSecondSquared, KnotsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerMinute(meterpersecondsquared.KnotsPerMinute).MetersPerSecondSquared, KnotsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerSecond(meterpersecondsquared.KnotsPerSecond).MetersPerSecondSquared, KnotsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMetersPerSecondSquared(meterpersecondsquared.MetersPerSecondSquared).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMicrometersPerSecondSquared(meterpersecondsquared.MicrometersPerSecondSquared).MetersPerSecondSquared, MicrometersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMillimetersPerSecondSquared(meterpersecondsquared.MillimetersPerSecondSquared).MetersPerSecondSquared, MillimetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMillistandardGravity(meterpersecondsquared.MillistandardGravity).MetersPerSecondSquared, MillistandardGravityTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromNanometersPerSecondSquared(meterpersecondsquared.NanometersPerSecondSquared).MetersPerSecondSquared, NanometersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromStandardGravity(meterpersecondsquared.StandardGravity).MetersPerSecondSquared, StandardGravityTolerance);
+            Acceleration<double> meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromCentimetersPerSecondSquared(meterpersecondsquared.CentimetersPerSecondSquared).MetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromDecimetersPerSecondSquared(meterpersecondsquared.DecimetersPerSecondSquared).MetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromFeetPerSecondSquared(meterpersecondsquared.FeetPerSecondSquared).MetersPerSecondSquared, FeetPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromInchesPerSecondSquared(meterpersecondsquared.InchesPerSecondSquared).MetersPerSecondSquared, InchesPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromKilometersPerSecondSquared(meterpersecondsquared.KilometersPerSecondSquared).MetersPerSecondSquared, KilometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromKnotsPerHour(meterpersecondsquared.KnotsPerHour).MetersPerSecondSquared, KnotsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromKnotsPerMinute(meterpersecondsquared.KnotsPerMinute).MetersPerSecondSquared, KnotsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromKnotsPerSecond(meterpersecondsquared.KnotsPerSecond).MetersPerSecondSquared, KnotsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromMetersPerSecondSquared(meterpersecondsquared.MetersPerSecondSquared).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromMicrometersPerSecondSquared(meterpersecondsquared.MicrometersPerSecondSquared).MetersPerSecondSquared, MicrometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromMillimetersPerSecondSquared(meterpersecondsquared.MillimetersPerSecondSquared).MetersPerSecondSquared, MillimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromMillistandardGravity(meterpersecondsquared.MillistandardGravity).MetersPerSecondSquared, MillistandardGravityTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromNanometersPerSecondSquared(meterpersecondsquared.NanometersPerSecondSquared).MetersPerSecondSquared, NanometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration<double>.FromStandardGravity(meterpersecondsquared.StandardGravity).MetersPerSecondSquared, StandardGravityTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Acceleration v = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration<double> v = Acceleration<double>.FromMetersPerSecondSquared(1);
             AssertEx.EqualTolerance(-1, -v.MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (Acceleration.FromMetersPerSecondSquared(3)-v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (Acceleration<double>.FromMetersPerSecondSquared(3)-v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(2, (v + v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(10, (v*10).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(10, (10*v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (Acceleration.FromMetersPerSecondSquared(10)/5).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, Acceleration.FromMetersPerSecondSquared(10)/Acceleration.FromMetersPerSecondSquared(5), MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (Acceleration<double>.FromMetersPerSecondSquared(10)/5).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, Acceleration<double>.FromMetersPerSecondSquared(10)/Acceleration<double>.FromMetersPerSecondSquared(5), MetersPerSecondSquaredTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Acceleration oneMeterPerSecondSquared = Acceleration.FromMetersPerSecondSquared(1);
-            Acceleration twoMetersPerSecondSquared = Acceleration.FromMetersPerSecondSquared(2);
+            Acceleration<double> oneMeterPerSecondSquared = Acceleration<double>.FromMetersPerSecondSquared(1);
+            Acceleration<double> twoMetersPerSecondSquared = Acceleration<double>.FromMetersPerSecondSquared(2);
 
             Assert.True(oneMeterPerSecondSquared < twoMetersPerSecondSquared);
             Assert.True(oneMeterPerSecondSquared <= twoMetersPerSecondSquared);
@@ -390,31 +390,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration<double> meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
             Assert.Equal(0, meterpersecondsquared.CompareTo(meterpersecondsquared));
-            Assert.True(meterpersecondsquared.CompareTo(Acceleration.Zero) > 0);
-            Assert.True(Acceleration.Zero.CompareTo(meterpersecondsquared) < 0);
+            Assert.True(meterpersecondsquared.CompareTo(Acceleration<double>.Zero) > 0);
+            Assert.True(Acceleration<double>.Zero.CompareTo(meterpersecondsquared) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration<double> meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
             Assert.Throws<ArgumentException>(() => meterpersecondsquared.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration<double> meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
             Assert.Throws<ArgumentNullException>(() => meterpersecondsquared.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Acceleration.FromMetersPerSecondSquared(1);
-            var b = Acceleration.FromMetersPerSecondSquared(2);
+            var a = Acceleration<double>.FromMetersPerSecondSquared(1);
+            var b = Acceleration<double>.FromMetersPerSecondSquared(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -433,8 +433,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Acceleration.FromMetersPerSecondSquared(1);
-            var b = Acceleration.FromMetersPerSecondSquared(2);
+            var a = Acceleration<double>.FromMetersPerSecondSquared(1);
+            var b = Acceleration<double>.FromMetersPerSecondSquared(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -454,9 +454,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Acceleration.FromMetersPerSecondSquared(1);
-            Assert.True(v.Equals(Acceleration.FromMetersPerSecondSquared(1), MetersPerSecondSquaredTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Acceleration.Zero, MetersPerSecondSquaredTolerance, ComparisonType.Relative));
+            var v = Acceleration<double>.FromMetersPerSecondSquared(1);
+            Assert.True(v.Equals(Acceleration<double>.FromMetersPerSecondSquared(1), MetersPerSecondSquaredTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Acceleration<double>.Zero, MetersPerSecondSquaredTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -469,21 +469,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration<double> meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
             Assert.False(meterpersecondsquared.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration<double> meterpersecondsquared = Acceleration<double>.FromMetersPerSecondSquared(1);
             Assert.False(meterpersecondsquared.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(AccelerationUnit.Undefined, Acceleration.Units);
+            Assert.DoesNotContain(AccelerationUnit.Undefined, Acceleration<double>.Units);
         }
 
         [Fact]
@@ -502,7 +502,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Acceleration.BaseDimensions is null);
+            Assert.False(Acceleration<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs
index caa8dfe820..c1cce76870 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs
@@ -74,7 +74,7 @@ public abstract partial class AmountOfSubstanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AmountOfSubstance((double)0.0, AmountOfSubstanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new AmountOfSubstance<double>((double)0.0, AmountOfSubstanceUnit.Undefined));
         }
 
         [Fact]
@@ -89,14 +89,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AmountOfSubstance(double.PositiveInfinity, AmountOfSubstanceUnit.Mole));
-            Assert.Throws<ArgumentException>(() => new AmountOfSubstance(double.NegativeInfinity, AmountOfSubstanceUnit.Mole));
+            Assert.Throws<ArgumentException>(() => new AmountOfSubstance<double>(double.PositiveInfinity, AmountOfSubstanceUnit.Mole));
+            Assert.Throws<ArgumentException>(() => new AmountOfSubstance<double>(double.NegativeInfinity, AmountOfSubstanceUnit.Mole));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AmountOfSubstance(double.NaN, AmountOfSubstanceUnit.Mole));
+            Assert.Throws<ArgumentException>(() => new AmountOfSubstance<double>(double.NaN, AmountOfSubstanceUnit.Mole));
         }
 
         [Fact]
@@ -142,7 +142,7 @@ public void AmountOfSubstance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
         [Fact]
         public void MoleToAmountOfSubstanceUnits()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
+            AmountOfSubstance<double> mole = AmountOfSubstance<double>.FromMoles(1);
             AssertEx.EqualTolerance(CentimolesInOneMole, mole.Centimoles, CentimolesTolerance);
             AssertEx.EqualTolerance(CentipoundMolesInOneMole, mole.CentipoundMoles, CentipoundMolesTolerance);
             AssertEx.EqualTolerance(DecimolesInOneMole, mole.Decimoles, DecimolesTolerance);
@@ -163,63 +163,63 @@ public void MoleToAmountOfSubstanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Centimole);
+            var quantity00 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Centimole);
             AssertEx.EqualTolerance(1, quantity00.Centimoles, CentimolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Centimole, quantity00.Unit);
 
-            var quantity01 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.CentipoundMole);
+            var quantity01 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.CentipoundMole);
             AssertEx.EqualTolerance(1, quantity01.CentipoundMoles, CentipoundMolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.CentipoundMole, quantity01.Unit);
 
-            var quantity02 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Decimole);
+            var quantity02 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Decimole);
             AssertEx.EqualTolerance(1, quantity02.Decimoles, DecimolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Decimole, quantity02.Unit);
 
-            var quantity03 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.DecipoundMole);
+            var quantity03 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.DecipoundMole);
             AssertEx.EqualTolerance(1, quantity03.DecipoundMoles, DecipoundMolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.DecipoundMole, quantity03.Unit);
 
-            var quantity04 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Kilomole);
+            var quantity04 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Kilomole);
             AssertEx.EqualTolerance(1, quantity04.Kilomoles, KilomolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Kilomole, quantity04.Unit);
 
-            var quantity05 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.KilopoundMole);
+            var quantity05 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.KilopoundMole);
             AssertEx.EqualTolerance(1, quantity05.KilopoundMoles, KilopoundMolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.KilopoundMole, quantity05.Unit);
 
-            var quantity06 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Megamole);
+            var quantity06 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Megamole);
             AssertEx.EqualTolerance(1, quantity06.Megamoles, MegamolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Megamole, quantity06.Unit);
 
-            var quantity07 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Micromole);
+            var quantity07 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Micromole);
             AssertEx.EqualTolerance(1, quantity07.Micromoles, MicromolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Micromole, quantity07.Unit);
 
-            var quantity08 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.MicropoundMole);
+            var quantity08 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.MicropoundMole);
             AssertEx.EqualTolerance(1, quantity08.MicropoundMoles, MicropoundMolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.MicropoundMole, quantity08.Unit);
 
-            var quantity09 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Millimole);
+            var quantity09 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Millimole);
             AssertEx.EqualTolerance(1, quantity09.Millimoles, MillimolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Millimole, quantity09.Unit);
 
-            var quantity10 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.MillipoundMole);
+            var quantity10 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.MillipoundMole);
             AssertEx.EqualTolerance(1, quantity10.MillipoundMoles, MillipoundMolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.MillipoundMole, quantity10.Unit);
 
-            var quantity11 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Mole);
+            var quantity11 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Mole);
             AssertEx.EqualTolerance(1, quantity11.Moles, MolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Mole, quantity11.Unit);
 
-            var quantity12 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.Nanomole);
+            var quantity12 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.Nanomole);
             AssertEx.EqualTolerance(1, quantity12.Nanomoles, NanomolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.Nanomole, quantity12.Unit);
 
-            var quantity13 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.NanopoundMole);
+            var quantity13 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.NanopoundMole);
             AssertEx.EqualTolerance(1, quantity13.NanopoundMoles, NanopoundMolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.NanopoundMole, quantity13.Unit);
 
-            var quantity14 = AmountOfSubstance.From(1, AmountOfSubstanceUnit.PoundMole);
+            var quantity14 = AmountOfSubstance<double>.From(1, AmountOfSubstanceUnit.PoundMole);
             AssertEx.EqualTolerance(1, quantity14.PoundMoles, PoundMolesTolerance);
             Assert.Equal(AmountOfSubstanceUnit.PoundMole, quantity14.Unit);
 
@@ -228,20 +228,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromMoles_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AmountOfSubstance.FromMoles(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => AmountOfSubstance.FromMoles(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => AmountOfSubstance<double>.FromMoles(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => AmountOfSubstance<double>.FromMoles(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromMoles_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AmountOfSubstance.FromMoles(double.NaN));
+            Assert.Throws<ArgumentException>(() => AmountOfSubstance<double>.FromMoles(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var mole = AmountOfSubstance.FromMoles(1);
+            var mole = AmountOfSubstance<double>.FromMoles(1);
             AssertEx.EqualTolerance(CentimolesInOneMole, mole.As(AmountOfSubstanceUnit.Centimole), CentimolesTolerance);
             AssertEx.EqualTolerance(CentipoundMolesInOneMole, mole.As(AmountOfSubstanceUnit.CentipoundMole), CentipoundMolesTolerance);
             AssertEx.EqualTolerance(DecimolesInOneMole, mole.As(AmountOfSubstanceUnit.Decimole), DecimolesTolerance);
@@ -279,7 +279,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var mole = AmountOfSubstance.FromMoles(1);
+            var mole = AmountOfSubstance<double>.FromMoles(1);
 
             var centimoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Centimole);
             AssertEx.EqualTolerance(CentimolesInOneMole, (double)centimoleQuantity.Value, CentimolesTolerance);
@@ -352,42 +352,42 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromCentimoles(mole.Centimoles).Moles, CentimolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromCentipoundMoles(mole.CentipoundMoles).Moles, CentipoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromDecimoles(mole.Decimoles).Moles, DecimolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromDecipoundMoles(mole.DecipoundMoles).Moles, DecipoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromKilomoles(mole.Kilomoles).Moles, KilomolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromKilopoundMoles(mole.KilopoundMoles).Moles, KilopoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMegamoles(mole.Megamoles).Moles, MegamolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMicromoles(mole.Micromoles).Moles, MicromolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMicropoundMoles(mole.MicropoundMoles).Moles, MicropoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMillimoles(mole.Millimoles).Moles, MillimolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMillipoundMoles(mole.MillipoundMoles).Moles, MillipoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMoles(mole.Moles).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromNanomoles(mole.Nanomoles).Moles, NanomolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromNanopoundMoles(mole.NanopoundMoles).Moles, NanopoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromPoundMoles(mole.PoundMoles).Moles, PoundMolesTolerance);
+            AmountOfSubstance<double> mole = AmountOfSubstance<double>.FromMoles(1);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromCentimoles(mole.Centimoles).Moles, CentimolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromCentipoundMoles(mole.CentipoundMoles).Moles, CentipoundMolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromDecimoles(mole.Decimoles).Moles, DecimolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromDecipoundMoles(mole.DecipoundMoles).Moles, DecipoundMolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromKilomoles(mole.Kilomoles).Moles, KilomolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromKilopoundMoles(mole.KilopoundMoles).Moles, KilopoundMolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromMegamoles(mole.Megamoles).Moles, MegamolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromMicromoles(mole.Micromoles).Moles, MicromolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromMicropoundMoles(mole.MicropoundMoles).Moles, MicropoundMolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromMillimoles(mole.Millimoles).Moles, MillimolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromMillipoundMoles(mole.MillipoundMoles).Moles, MillipoundMolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromMoles(mole.Moles).Moles, MolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromNanomoles(mole.Nanomoles).Moles, NanomolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromNanopoundMoles(mole.NanopoundMoles).Moles, NanopoundMolesTolerance);
+            AssertEx.EqualTolerance(1, AmountOfSubstance<double>.FromPoundMoles(mole.PoundMoles).Moles, PoundMolesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            AmountOfSubstance v = AmountOfSubstance.FromMoles(1);
+            AmountOfSubstance<double> v = AmountOfSubstance<double>.FromMoles(1);
             AssertEx.EqualTolerance(-1, -v.Moles, MolesTolerance);
-            AssertEx.EqualTolerance(2, (AmountOfSubstance.FromMoles(3)-v).Moles, MolesTolerance);
+            AssertEx.EqualTolerance(2, (AmountOfSubstance<double>.FromMoles(3)-v).Moles, MolesTolerance);
             AssertEx.EqualTolerance(2, (v + v).Moles, MolesTolerance);
             AssertEx.EqualTolerance(10, (v*10).Moles, MolesTolerance);
             AssertEx.EqualTolerance(10, (10*v).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(2, (AmountOfSubstance.FromMoles(10)/5).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(2, AmountOfSubstance.FromMoles(10)/AmountOfSubstance.FromMoles(5), MolesTolerance);
+            AssertEx.EqualTolerance(2, (AmountOfSubstance<double>.FromMoles(10)/5).Moles, MolesTolerance);
+            AssertEx.EqualTolerance(2, AmountOfSubstance<double>.FromMoles(10)/AmountOfSubstance<double>.FromMoles(5), MolesTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            AmountOfSubstance oneMole = AmountOfSubstance.FromMoles(1);
-            AmountOfSubstance twoMoles = AmountOfSubstance.FromMoles(2);
+            AmountOfSubstance<double> oneMole = AmountOfSubstance<double>.FromMoles(1);
+            AmountOfSubstance<double> twoMoles = AmountOfSubstance<double>.FromMoles(2);
 
             Assert.True(oneMole < twoMoles);
             Assert.True(oneMole <= twoMoles);
@@ -403,31 +403,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
+            AmountOfSubstance<double> mole = AmountOfSubstance<double>.FromMoles(1);
             Assert.Equal(0, mole.CompareTo(mole));
-            Assert.True(mole.CompareTo(AmountOfSubstance.Zero) > 0);
-            Assert.True(AmountOfSubstance.Zero.CompareTo(mole) < 0);
+            Assert.True(mole.CompareTo(AmountOfSubstance<double>.Zero) > 0);
+            Assert.True(AmountOfSubstance<double>.Zero.CompareTo(mole) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
+            AmountOfSubstance<double> mole = AmountOfSubstance<double>.FromMoles(1);
             Assert.Throws<ArgumentException>(() => mole.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
+            AmountOfSubstance<double> mole = AmountOfSubstance<double>.FromMoles(1);
             Assert.Throws<ArgumentNullException>(() => mole.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = AmountOfSubstance.FromMoles(1);
-            var b = AmountOfSubstance.FromMoles(2);
+            var a = AmountOfSubstance<double>.FromMoles(1);
+            var b = AmountOfSubstance<double>.FromMoles(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -446,8 +446,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = AmountOfSubstance.FromMoles(1);
-            var b = AmountOfSubstance.FromMoles(2);
+            var a = AmountOfSubstance<double>.FromMoles(1);
+            var b = AmountOfSubstance<double>.FromMoles(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -467,9 +467,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = AmountOfSubstance.FromMoles(1);
-            Assert.True(v.Equals(AmountOfSubstance.FromMoles(1), MolesTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(AmountOfSubstance.Zero, MolesTolerance, ComparisonType.Relative));
+            var v = AmountOfSubstance<double>.FromMoles(1);
+            Assert.True(v.Equals(AmountOfSubstance<double>.FromMoles(1), MolesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(AmountOfSubstance<double>.Zero, MolesTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -482,21 +482,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
+            AmountOfSubstance<double> mole = AmountOfSubstance<double>.FromMoles(1);
             Assert.False(mole.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
+            AmountOfSubstance<double> mole = AmountOfSubstance<double>.FromMoles(1);
             Assert.False(mole.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(AmountOfSubstanceUnit.Undefined, AmountOfSubstance.Units);
+            Assert.DoesNotContain(AmountOfSubstanceUnit.Undefined, AmountOfSubstance<double>.Units);
         }
 
         [Fact]
@@ -515,7 +515,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(AmountOfSubstance.BaseDimensions is null);
+            Assert.False(AmountOfSubstance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs
index 31befffc43..18f9233922 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class AmplitudeRatioTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AmplitudeRatio((double)0.0, AmplitudeRatioUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>((double)0.0, AmplitudeRatioUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AmplitudeRatio(double.PositiveInfinity, AmplitudeRatioUnit.DecibelVolt));
-            Assert.Throws<ArgumentException>(() => new AmplitudeRatio(double.NegativeInfinity, AmplitudeRatioUnit.DecibelVolt));
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>(double.PositiveInfinity, AmplitudeRatioUnit.DecibelVolt));
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>(double.NegativeInfinity, AmplitudeRatioUnit.DecibelVolt));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AmplitudeRatio(double.NaN, AmplitudeRatioUnit.DecibelVolt));
+            Assert.Throws<ArgumentException>(() => new AmplitudeRatio<double>(double.NaN, AmplitudeRatioUnit.DecibelVolt));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void AmplitudeRatio_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DecibelVoltToAmplitudeRatioUnits()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
             AssertEx.EqualTolerance(DecibelMicrovoltsInOneDecibelVolt, decibelvolt.DecibelMicrovolts, DecibelMicrovoltsTolerance);
             AssertEx.EqualTolerance(DecibelMillivoltsInOneDecibelVolt, decibelvolt.DecibelMillivolts, DecibelMillivoltsTolerance);
             AssertEx.EqualTolerance(DecibelsUnloadedInOneDecibelVolt, decibelvolt.DecibelsUnloaded, DecibelsUnloadedTolerance);
@@ -130,19 +130,19 @@ public void DecibelVoltToAmplitudeRatioUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt);
+            var quantity00 = AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelMicrovolt);
             AssertEx.EqualTolerance(1, quantity00.DecibelMicrovolts, DecibelMicrovoltsTolerance);
             Assert.Equal(AmplitudeRatioUnit.DecibelMicrovolt, quantity00.Unit);
 
-            var quantity01 = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt);
+            var quantity01 = AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelMillivolt);
             AssertEx.EqualTolerance(1, quantity01.DecibelMillivolts, DecibelMillivoltsTolerance);
             Assert.Equal(AmplitudeRatioUnit.DecibelMillivolt, quantity01.Unit);
 
-            var quantity02 = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelUnloaded);
+            var quantity02 = AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelUnloaded);
             AssertEx.EqualTolerance(1, quantity02.DecibelsUnloaded, DecibelsUnloadedTolerance);
             Assert.Equal(AmplitudeRatioUnit.DecibelUnloaded, quantity02.Unit);
 
-            var quantity03 = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt);
+            var quantity03 = AmplitudeRatio<double>.From(1, AmplitudeRatioUnit.DecibelVolt);
             AssertEx.EqualTolerance(1, quantity03.DecibelVolts, DecibelVoltsTolerance);
             Assert.Equal(AmplitudeRatioUnit.DecibelVolt, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDecibelVolts_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AmplitudeRatio.FromDecibelVolts(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => AmplitudeRatio.FromDecibelVolts(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => AmplitudeRatio<double>.FromDecibelVolts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => AmplitudeRatio<double>.FromDecibelVolts(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDecibelVolts_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AmplitudeRatio.FromDecibelVolts(double.NaN));
+            Assert.Throws<ArgumentException>(() => AmplitudeRatio<double>.FromDecibelVolts(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            var decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
             AssertEx.EqualTolerance(DecibelMicrovoltsInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelMicrovolt), DecibelMicrovoltsTolerance);
             AssertEx.EqualTolerance(DecibelMillivoltsInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelMillivolt), DecibelMillivoltsTolerance);
             AssertEx.EqualTolerance(DecibelsUnloadedInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelUnloaded), DecibelsUnloadedTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            var decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
 
             var decibelmicrovoltQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelMicrovolt);
             AssertEx.EqualTolerance(DecibelMicrovoltsInOneDecibelVolt, (double)decibelmicrovoltQuantity.Value, DecibelMicrovoltsTolerance);
@@ -220,24 +220,24 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelMicrovolts(decibelvolt.DecibelMicrovolts).DecibelVolts, DecibelMicrovoltsTolerance);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelMillivolts(decibelvolt.DecibelMillivolts).DecibelVolts, DecibelMillivoltsTolerance);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelsUnloaded(decibelvolt.DecibelsUnloaded).DecibelVolts, DecibelsUnloadedTolerance);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelVolts(decibelvolt.DecibelVolts).DecibelVolts, DecibelVoltsTolerance);
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelMicrovolts(decibelvolt.DecibelMicrovolts).DecibelVolts, DecibelMicrovoltsTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelMillivolts(decibelvolt.DecibelMillivolts).DecibelVolts, DecibelMillivoltsTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelsUnloaded(decibelvolt.DecibelsUnloaded).DecibelVolts, DecibelsUnloadedTolerance);
+            AssertEx.EqualTolerance(1, AmplitudeRatio<double>.FromDecibelVolts(decibelvolt.DecibelVolts).DecibelVolts, DecibelVoltsTolerance);
         }
 
         [Fact]
         public void LogarithmicArithmeticOperators()
         {
-            AmplitudeRatio v = AmplitudeRatio.FromDecibelVolts(40);
+            AmplitudeRatio<double> v = AmplitudeRatio<double>.FromDecibelVolts(40);
             AssertEx.EqualTolerance(-40, -v.DecibelVolts, DecibelVoltsTolerance);
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
             AssertEx.EqualTolerance(50, (v*10).DecibelVolts, DecibelVoltsTolerance);
             AssertEx.EqualTolerance(50, (10*v).DecibelVolts, DecibelVoltsTolerance);
             AssertEx.EqualTolerance(35, (v/5).DecibelVolts, DecibelVoltsTolerance);
-            AssertEx.EqualTolerance(35, v/AmplitudeRatio.FromDecibelVolts(5), DecibelVoltsTolerance);
+            AssertEx.EqualTolerance(35, v/AmplitudeRatio<double>.FromDecibelVolts(5), DecibelVoltsTolerance);
         }
 
         protected abstract void AssertLogarithmicAddition();
@@ -247,8 +247,8 @@ public void LogarithmicArithmeticOperators()
         [Fact]
         public void ComparisonOperators()
         {
-            AmplitudeRatio oneDecibelVolt = AmplitudeRatio.FromDecibelVolts(1);
-            AmplitudeRatio twoDecibelVolts = AmplitudeRatio.FromDecibelVolts(2);
+            AmplitudeRatio<double> oneDecibelVolt = AmplitudeRatio<double>.FromDecibelVolts(1);
+            AmplitudeRatio<double> twoDecibelVolts = AmplitudeRatio<double>.FromDecibelVolts(2);
 
             Assert.True(oneDecibelVolt < twoDecibelVolts);
             Assert.True(oneDecibelVolt <= twoDecibelVolts);
@@ -264,31 +264,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
             Assert.Equal(0, decibelvolt.CompareTo(decibelvolt));
-            Assert.True(decibelvolt.CompareTo(AmplitudeRatio.Zero) > 0);
-            Assert.True(AmplitudeRatio.Zero.CompareTo(decibelvolt) < 0);
+            Assert.True(decibelvolt.CompareTo(AmplitudeRatio<double>.Zero) > 0);
+            Assert.True(AmplitudeRatio<double>.Zero.CompareTo(decibelvolt) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
             Assert.Throws<ArgumentException>(() => decibelvolt.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
             Assert.Throws<ArgumentNullException>(() => decibelvolt.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = AmplitudeRatio.FromDecibelVolts(1);
-            var b = AmplitudeRatio.FromDecibelVolts(2);
+            var a = AmplitudeRatio<double>.FromDecibelVolts(1);
+            var b = AmplitudeRatio<double>.FromDecibelVolts(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -307,8 +307,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = AmplitudeRatio.FromDecibelVolts(1);
-            var b = AmplitudeRatio.FromDecibelVolts(2);
+            var a = AmplitudeRatio<double>.FromDecibelVolts(1);
+            var b = AmplitudeRatio<double>.FromDecibelVolts(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -328,9 +328,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = AmplitudeRatio.FromDecibelVolts(1);
-            Assert.True(v.Equals(AmplitudeRatio.FromDecibelVolts(1), DecibelVoltsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(AmplitudeRatio.Zero, DecibelVoltsTolerance, ComparisonType.Relative));
+            var v = AmplitudeRatio<double>.FromDecibelVolts(1);
+            Assert.True(v.Equals(AmplitudeRatio<double>.FromDecibelVolts(1), DecibelVoltsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(AmplitudeRatio<double>.Zero, DecibelVoltsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -343,21 +343,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
             Assert.False(decibelvolt.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+            AmplitudeRatio<double> decibelvolt = AmplitudeRatio<double>.FromDecibelVolts(1);
             Assert.False(decibelvolt.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(AmplitudeRatioUnit.Undefined, AmplitudeRatio.Units);
+            Assert.DoesNotContain(AmplitudeRatioUnit.Undefined, AmplitudeRatio<double>.Units);
         }
 
         [Fact]
@@ -376,7 +376,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(AmplitudeRatio.BaseDimensions is null);
+            Assert.False(AmplitudeRatio<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs
index d03cabb672..f00e6c00e7 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs
@@ -72,7 +72,7 @@ public abstract partial class AngleTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Angle((double)0.0, AngleUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Angle<double>((double)0.0, AngleUnit.Undefined));
         }
 
         [Fact]
@@ -87,14 +87,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Angle(double.PositiveInfinity, AngleUnit.Degree));
-            Assert.Throws<ArgumentException>(() => new Angle(double.NegativeInfinity, AngleUnit.Degree));
+            Assert.Throws<ArgumentException>(() => new Angle<double>(double.PositiveInfinity, AngleUnit.Degree));
+            Assert.Throws<ArgumentException>(() => new Angle<double>(double.NegativeInfinity, AngleUnit.Degree));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Angle(double.NaN, AngleUnit.Degree));
+            Assert.Throws<ArgumentException>(() => new Angle<double>(double.NaN, AngleUnit.Degree));
         }
 
         [Fact]
@@ -140,7 +140,7 @@ public void Angle_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DegreeToAngleUnits()
         {
-            Angle degree = Angle.FromDegrees(1);
+            Angle<double> degree = Angle<double>.FromDegrees(1);
             AssertEx.EqualTolerance(ArcminutesInOneDegree, degree.Arcminutes, ArcminutesTolerance);
             AssertEx.EqualTolerance(ArcsecondsInOneDegree, degree.Arcseconds, ArcsecondsTolerance);
             AssertEx.EqualTolerance(CentiradiansInOneDegree, degree.Centiradians, CentiradiansTolerance);
@@ -160,59 +160,59 @@ public void DegreeToAngleUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Angle.From(1, AngleUnit.Arcminute);
+            var quantity00 = Angle<double>.From(1, AngleUnit.Arcminute);
             AssertEx.EqualTolerance(1, quantity00.Arcminutes, ArcminutesTolerance);
             Assert.Equal(AngleUnit.Arcminute, quantity00.Unit);
 
-            var quantity01 = Angle.From(1, AngleUnit.Arcsecond);
+            var quantity01 = Angle<double>.From(1, AngleUnit.Arcsecond);
             AssertEx.EqualTolerance(1, quantity01.Arcseconds, ArcsecondsTolerance);
             Assert.Equal(AngleUnit.Arcsecond, quantity01.Unit);
 
-            var quantity02 = Angle.From(1, AngleUnit.Centiradian);
+            var quantity02 = Angle<double>.From(1, AngleUnit.Centiradian);
             AssertEx.EqualTolerance(1, quantity02.Centiradians, CentiradiansTolerance);
             Assert.Equal(AngleUnit.Centiradian, quantity02.Unit);
 
-            var quantity03 = Angle.From(1, AngleUnit.Deciradian);
+            var quantity03 = Angle<double>.From(1, AngleUnit.Deciradian);
             AssertEx.EqualTolerance(1, quantity03.Deciradians, DeciradiansTolerance);
             Assert.Equal(AngleUnit.Deciradian, quantity03.Unit);
 
-            var quantity04 = Angle.From(1, AngleUnit.Degree);
+            var quantity04 = Angle<double>.From(1, AngleUnit.Degree);
             AssertEx.EqualTolerance(1, quantity04.Degrees, DegreesTolerance);
             Assert.Equal(AngleUnit.Degree, quantity04.Unit);
 
-            var quantity05 = Angle.From(1, AngleUnit.Gradian);
+            var quantity05 = Angle<double>.From(1, AngleUnit.Gradian);
             AssertEx.EqualTolerance(1, quantity05.Gradians, GradiansTolerance);
             Assert.Equal(AngleUnit.Gradian, quantity05.Unit);
 
-            var quantity06 = Angle.From(1, AngleUnit.Microdegree);
+            var quantity06 = Angle<double>.From(1, AngleUnit.Microdegree);
             AssertEx.EqualTolerance(1, quantity06.Microdegrees, MicrodegreesTolerance);
             Assert.Equal(AngleUnit.Microdegree, quantity06.Unit);
 
-            var quantity07 = Angle.From(1, AngleUnit.Microradian);
+            var quantity07 = Angle<double>.From(1, AngleUnit.Microradian);
             AssertEx.EqualTolerance(1, quantity07.Microradians, MicroradiansTolerance);
             Assert.Equal(AngleUnit.Microradian, quantity07.Unit);
 
-            var quantity08 = Angle.From(1, AngleUnit.Millidegree);
+            var quantity08 = Angle<double>.From(1, AngleUnit.Millidegree);
             AssertEx.EqualTolerance(1, quantity08.Millidegrees, MillidegreesTolerance);
             Assert.Equal(AngleUnit.Millidegree, quantity08.Unit);
 
-            var quantity09 = Angle.From(1, AngleUnit.Milliradian);
+            var quantity09 = Angle<double>.From(1, AngleUnit.Milliradian);
             AssertEx.EqualTolerance(1, quantity09.Milliradians, MilliradiansTolerance);
             Assert.Equal(AngleUnit.Milliradian, quantity09.Unit);
 
-            var quantity10 = Angle.From(1, AngleUnit.Nanodegree);
+            var quantity10 = Angle<double>.From(1, AngleUnit.Nanodegree);
             AssertEx.EqualTolerance(1, quantity10.Nanodegrees, NanodegreesTolerance);
             Assert.Equal(AngleUnit.Nanodegree, quantity10.Unit);
 
-            var quantity11 = Angle.From(1, AngleUnit.Nanoradian);
+            var quantity11 = Angle<double>.From(1, AngleUnit.Nanoradian);
             AssertEx.EqualTolerance(1, quantity11.Nanoradians, NanoradiansTolerance);
             Assert.Equal(AngleUnit.Nanoradian, quantity11.Unit);
 
-            var quantity12 = Angle.From(1, AngleUnit.Radian);
+            var quantity12 = Angle<double>.From(1, AngleUnit.Radian);
             AssertEx.EqualTolerance(1, quantity12.Radians, RadiansTolerance);
             Assert.Equal(AngleUnit.Radian, quantity12.Unit);
 
-            var quantity13 = Angle.From(1, AngleUnit.Revolution);
+            var quantity13 = Angle<double>.From(1, AngleUnit.Revolution);
             AssertEx.EqualTolerance(1, quantity13.Revolutions, RevolutionsTolerance);
             Assert.Equal(AngleUnit.Revolution, quantity13.Unit);
 
@@ -221,20 +221,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDegrees_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Angle.FromDegrees(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Angle.FromDegrees(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Angle<double>.FromDegrees(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Angle<double>.FromDegrees(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDegrees_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Angle.FromDegrees(double.NaN));
+            Assert.Throws<ArgumentException>(() => Angle<double>.FromDegrees(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var degree = Angle.FromDegrees(1);
+            var degree = Angle<double>.FromDegrees(1);
             AssertEx.EqualTolerance(ArcminutesInOneDegree, degree.As(AngleUnit.Arcminute), ArcminutesTolerance);
             AssertEx.EqualTolerance(ArcsecondsInOneDegree, degree.As(AngleUnit.Arcsecond), ArcsecondsTolerance);
             AssertEx.EqualTolerance(CentiradiansInOneDegree, degree.As(AngleUnit.Centiradian), CentiradiansTolerance);
@@ -271,7 +271,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var degree = Angle.FromDegrees(1);
+            var degree = Angle<double>.FromDegrees(1);
 
             var arcminuteQuantity = degree.ToUnit(AngleUnit.Arcminute);
             AssertEx.EqualTolerance(ArcminutesInOneDegree, (double)arcminuteQuantity.Value, ArcminutesTolerance);
@@ -340,41 +340,41 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Angle degree = Angle.FromDegrees(1);
-            AssertEx.EqualTolerance(1, Angle.FromArcminutes(degree.Arcminutes).Degrees, ArcminutesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromArcseconds(degree.Arcseconds).Degrees, ArcsecondsTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromCentiradians(degree.Centiradians).Degrees, CentiradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromDeciradians(degree.Deciradians).Degrees, DeciradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromDegrees(degree.Degrees).Degrees, DegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromGradians(degree.Gradians).Degrees, GradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMicrodegrees(degree.Microdegrees).Degrees, MicrodegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMicroradians(degree.Microradians).Degrees, MicroradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMillidegrees(degree.Millidegrees).Degrees, MillidegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMilliradians(degree.Milliradians).Degrees, MilliradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromNanodegrees(degree.Nanodegrees).Degrees, NanodegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromNanoradians(degree.Nanoradians).Degrees, NanoradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromRadians(degree.Radians).Degrees, RadiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromRevolutions(degree.Revolutions).Degrees, RevolutionsTolerance);
+            Angle<double> degree = Angle<double>.FromDegrees(1);
+            AssertEx.EqualTolerance(1, Angle<double>.FromArcminutes(degree.Arcminutes).Degrees, ArcminutesTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromArcseconds(degree.Arcseconds).Degrees, ArcsecondsTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromCentiradians(degree.Centiradians).Degrees, CentiradiansTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromDeciradians(degree.Deciradians).Degrees, DeciradiansTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromDegrees(degree.Degrees).Degrees, DegreesTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromGradians(degree.Gradians).Degrees, GradiansTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromMicrodegrees(degree.Microdegrees).Degrees, MicrodegreesTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromMicroradians(degree.Microradians).Degrees, MicroradiansTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromMillidegrees(degree.Millidegrees).Degrees, MillidegreesTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromMilliradians(degree.Milliradians).Degrees, MilliradiansTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromNanodegrees(degree.Nanodegrees).Degrees, NanodegreesTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromNanoradians(degree.Nanoradians).Degrees, NanoradiansTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromRadians(degree.Radians).Degrees, RadiansTolerance);
+            AssertEx.EqualTolerance(1, Angle<double>.FromRevolutions(degree.Revolutions).Degrees, RevolutionsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Angle v = Angle.FromDegrees(1);
+            Angle<double> v = Angle<double>.FromDegrees(1);
             AssertEx.EqualTolerance(-1, -v.Degrees, DegreesTolerance);
-            AssertEx.EqualTolerance(2, (Angle.FromDegrees(3)-v).Degrees, DegreesTolerance);
+            AssertEx.EqualTolerance(2, (Angle<double>.FromDegrees(3)-v).Degrees, DegreesTolerance);
             AssertEx.EqualTolerance(2, (v + v).Degrees, DegreesTolerance);
             AssertEx.EqualTolerance(10, (v*10).Degrees, DegreesTolerance);
             AssertEx.EqualTolerance(10, (10*v).Degrees, DegreesTolerance);
-            AssertEx.EqualTolerance(2, (Angle.FromDegrees(10)/5).Degrees, DegreesTolerance);
-            AssertEx.EqualTolerance(2, Angle.FromDegrees(10)/Angle.FromDegrees(5), DegreesTolerance);
+            AssertEx.EqualTolerance(2, (Angle<double>.FromDegrees(10)/5).Degrees, DegreesTolerance);
+            AssertEx.EqualTolerance(2, Angle<double>.FromDegrees(10)/Angle<double>.FromDegrees(5), DegreesTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Angle oneDegree = Angle.FromDegrees(1);
-            Angle twoDegrees = Angle.FromDegrees(2);
+            Angle<double> oneDegree = Angle<double>.FromDegrees(1);
+            Angle<double> twoDegrees = Angle<double>.FromDegrees(2);
 
             Assert.True(oneDegree < twoDegrees);
             Assert.True(oneDegree <= twoDegrees);
@@ -390,31 +390,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Angle degree = Angle.FromDegrees(1);
+            Angle<double> degree = Angle<double>.FromDegrees(1);
             Assert.Equal(0, degree.CompareTo(degree));
-            Assert.True(degree.CompareTo(Angle.Zero) > 0);
-            Assert.True(Angle.Zero.CompareTo(degree) < 0);
+            Assert.True(degree.CompareTo(Angle<double>.Zero) > 0);
+            Assert.True(Angle<double>.Zero.CompareTo(degree) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Angle degree = Angle.FromDegrees(1);
+            Angle<double> degree = Angle<double>.FromDegrees(1);
             Assert.Throws<ArgumentException>(() => degree.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Angle degree = Angle.FromDegrees(1);
+            Angle<double> degree = Angle<double>.FromDegrees(1);
             Assert.Throws<ArgumentNullException>(() => degree.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Angle.FromDegrees(1);
-            var b = Angle.FromDegrees(2);
+            var a = Angle<double>.FromDegrees(1);
+            var b = Angle<double>.FromDegrees(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -433,8 +433,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Angle.FromDegrees(1);
-            var b = Angle.FromDegrees(2);
+            var a = Angle<double>.FromDegrees(1);
+            var b = Angle<double>.FromDegrees(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -454,9 +454,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Angle.FromDegrees(1);
-            Assert.True(v.Equals(Angle.FromDegrees(1), DegreesTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Angle.Zero, DegreesTolerance, ComparisonType.Relative));
+            var v = Angle<double>.FromDegrees(1);
+            Assert.True(v.Equals(Angle<double>.FromDegrees(1), DegreesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Angle<double>.Zero, DegreesTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -469,21 +469,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Angle degree = Angle.FromDegrees(1);
+            Angle<double> degree = Angle<double>.FromDegrees(1);
             Assert.False(degree.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Angle degree = Angle.FromDegrees(1);
+            Angle<double> degree = Angle<double>.FromDegrees(1);
             Assert.False(degree.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(AngleUnit.Undefined, Angle.Units);
+            Assert.DoesNotContain(AngleUnit.Undefined, Angle<double>.Units);
         }
 
         [Fact]
@@ -502,7 +502,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Angle.BaseDimensions is null);
+            Assert.False(Angle<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentEnergyTestsBase.g.cs
index 2e3071c8da..b488537a4c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentEnergyTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class ApparentEnergyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ApparentEnergy((double)0.0, ApparentEnergyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>((double)0.0, ApparentEnergyUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ApparentEnergy(double.PositiveInfinity, ApparentEnergyUnit.VoltampereHour));
-            Assert.Throws<ArgumentException>(() => new ApparentEnergy(double.NegativeInfinity, ApparentEnergyUnit.VoltampereHour));
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>(double.PositiveInfinity, ApparentEnergyUnit.VoltampereHour));
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>(double.NegativeInfinity, ApparentEnergyUnit.VoltampereHour));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ApparentEnergy(double.NaN, ApparentEnergyUnit.VoltampereHour));
+            Assert.Throws<ArgumentException>(() => new ApparentEnergy<double>(double.NaN, ApparentEnergyUnit.VoltampereHour));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void ApparentEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void VoltampereHourToApparentEnergyUnits()
         {
-            ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
             AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, voltamperehour.KilovoltampereHours, KilovoltampereHoursTolerance);
             AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, voltamperehour.MegavoltampereHours, MegavoltampereHoursTolerance);
             AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, voltamperehour.VoltampereHours, VoltampereHoursTolerance);
@@ -127,15 +127,15 @@ public void VoltampereHourToApparentEnergyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ApparentEnergy.From(1, ApparentEnergyUnit.KilovoltampereHour);
+            var quantity00 = ApparentEnergy<double>.From(1, ApparentEnergyUnit.KilovoltampereHour);
             AssertEx.EqualTolerance(1, quantity00.KilovoltampereHours, KilovoltampereHoursTolerance);
             Assert.Equal(ApparentEnergyUnit.KilovoltampereHour, quantity00.Unit);
 
-            var quantity01 = ApparentEnergy.From(1, ApparentEnergyUnit.MegavoltampereHour);
+            var quantity01 = ApparentEnergy<double>.From(1, ApparentEnergyUnit.MegavoltampereHour);
             AssertEx.EqualTolerance(1, quantity01.MegavoltampereHours, MegavoltampereHoursTolerance);
             Assert.Equal(ApparentEnergyUnit.MegavoltampereHour, quantity01.Unit);
 
-            var quantity02 = ApparentEnergy.From(1, ApparentEnergyUnit.VoltampereHour);
+            var quantity02 = ApparentEnergy<double>.From(1, ApparentEnergyUnit.VoltampereHour);
             AssertEx.EqualTolerance(1, quantity02.VoltampereHours, VoltampereHoursTolerance);
             Assert.Equal(ApparentEnergyUnit.VoltampereHour, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltampereHours_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ApparentEnergy.FromVoltampereHours(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ApparentEnergy.FromVoltampereHours(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ApparentEnergy<double>.FromVoltampereHours(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ApparentEnergy<double>.FromVoltampereHours(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltampereHours_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ApparentEnergy.FromVoltampereHours(double.NaN));
+            Assert.Throws<ArgumentException>(() => ApparentEnergy<double>.FromVoltampereHours(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            var voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
             AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.KilovoltampereHour), KilovoltampereHoursTolerance);
             AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.MegavoltampereHour), MegavoltampereHoursTolerance);
             AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.VoltampereHour), VoltampereHoursTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            var voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
 
             var kilovoltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.KilovoltampereHour);
             AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, (double)kilovoltamperehourQuantity.Value, KilovoltampereHoursTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
-            AssertEx.EqualTolerance(1, ApparentEnergy.FromKilovoltampereHours(voltamperehour.KilovoltampereHours).VoltampereHours, KilovoltampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ApparentEnergy.FromMegavoltampereHours(voltamperehour.MegavoltampereHours).VoltampereHours, MegavoltampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ApparentEnergy.FromVoltampereHours(voltamperehour.VoltampereHours).VoltampereHours, VoltampereHoursTolerance);
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.FromKilovoltampereHours(voltamperehour.KilovoltampereHours).VoltampereHours, KilovoltampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.FromMegavoltampereHours(voltamperehour.MegavoltampereHours).VoltampereHours, MegavoltampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ApparentEnergy<double>.FromVoltampereHours(voltamperehour.VoltampereHours).VoltampereHours, VoltampereHoursTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ApparentEnergy v = ApparentEnergy.FromVoltampereHours(1);
+            ApparentEnergy<double> v = ApparentEnergy<double>.FromVoltampereHours(1);
             AssertEx.EqualTolerance(-1, -v.VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(2, (ApparentEnergy.FromVoltampereHours(3)-v).VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(2, (ApparentEnergy<double>.FromVoltampereHours(3)-v).VoltampereHours, VoltampereHoursTolerance);
             AssertEx.EqualTolerance(2, (v + v).VoltampereHours, VoltampereHoursTolerance);
             AssertEx.EqualTolerance(10, (v*10).VoltampereHours, VoltampereHoursTolerance);
             AssertEx.EqualTolerance(10, (10*v).VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(2, (ApparentEnergy.FromVoltampereHours(10)/5).VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(2, ApparentEnergy.FromVoltampereHours(10)/ApparentEnergy.FromVoltampereHours(5), VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(2, (ApparentEnergy<double>.FromVoltampereHours(10)/5).VoltampereHours, VoltampereHoursTolerance);
+            AssertEx.EqualTolerance(2, ApparentEnergy<double>.FromVoltampereHours(10)/ApparentEnergy<double>.FromVoltampereHours(5), VoltampereHoursTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ApparentEnergy oneVoltampereHour = ApparentEnergy.FromVoltampereHours(1);
-            ApparentEnergy twoVoltampereHours = ApparentEnergy.FromVoltampereHours(2);
+            ApparentEnergy<double> oneVoltampereHour = ApparentEnergy<double>.FromVoltampereHours(1);
+            ApparentEnergy<double> twoVoltampereHours = ApparentEnergy<double>.FromVoltampereHours(2);
 
             Assert.True(oneVoltampereHour < twoVoltampereHours);
             Assert.True(oneVoltampereHour <= twoVoltampereHours);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
             Assert.Equal(0, voltamperehour.CompareTo(voltamperehour));
-            Assert.True(voltamperehour.CompareTo(ApparentEnergy.Zero) > 0);
-            Assert.True(ApparentEnergy.Zero.CompareTo(voltamperehour) < 0);
+            Assert.True(voltamperehour.CompareTo(ApparentEnergy<double>.Zero) > 0);
+            Assert.True(ApparentEnergy<double>.Zero.CompareTo(voltamperehour) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
             Assert.Throws<ArgumentException>(() => voltamperehour.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
             Assert.Throws<ArgumentNullException>(() => voltamperehour.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ApparentEnergy.FromVoltampereHours(1);
-            var b = ApparentEnergy.FromVoltampereHours(2);
+            var a = ApparentEnergy<double>.FromVoltampereHours(1);
+            var b = ApparentEnergy<double>.FromVoltampereHours(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ApparentEnergy.FromVoltampereHours(1);
-            var b = ApparentEnergy.FromVoltampereHours(2);
+            var a = ApparentEnergy<double>.FromVoltampereHours(1);
+            var b = ApparentEnergy<double>.FromVoltampereHours(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ApparentEnergy.FromVoltampereHours(1);
-            Assert.True(v.Equals(ApparentEnergy.FromVoltampereHours(1), VoltampereHoursTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ApparentEnergy.Zero, VoltampereHoursTolerance, ComparisonType.Relative));
+            var v = ApparentEnergy<double>.FromVoltampereHours(1);
+            Assert.True(v.Equals(ApparentEnergy<double>.FromVoltampereHours(1), VoltampereHoursTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ApparentEnergy<double>.Zero, VoltampereHoursTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
             Assert.False(voltamperehour.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ApparentEnergy voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+            ApparentEnergy<double> voltamperehour = ApparentEnergy<double>.FromVoltampereHours(1);
             Assert.False(voltamperehour.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ApparentEnergyUnit.Undefined, ApparentEnergy.Units);
+            Assert.DoesNotContain(ApparentEnergyUnit.Undefined, ApparentEnergy<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ApparentEnergy.BaseDimensions is null);
+            Assert.False(ApparentEnergy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentPowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentPowerTestsBase.g.cs
index 239de28b78..7002a82eae 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentPowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ApparentPowerTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class ApparentPowerTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ApparentPower((double)0.0, ApparentPowerUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>((double)0.0, ApparentPowerUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ApparentPower(double.PositiveInfinity, ApparentPowerUnit.Voltampere));
-            Assert.Throws<ArgumentException>(() => new ApparentPower(double.NegativeInfinity, ApparentPowerUnit.Voltampere));
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>(double.PositiveInfinity, ApparentPowerUnit.Voltampere));
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>(double.NegativeInfinity, ApparentPowerUnit.Voltampere));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ApparentPower(double.NaN, ApparentPowerUnit.Voltampere));
+            Assert.Throws<ArgumentException>(() => new ApparentPower<double>(double.NaN, ApparentPowerUnit.Voltampere));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void ApparentPower_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void VoltampereToApparentPowerUnits()
         {
-            ApparentPower voltampere = ApparentPower.FromVoltamperes(1);
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
             AssertEx.EqualTolerance(GigavoltamperesInOneVoltampere, voltampere.Gigavoltamperes, GigavoltamperesTolerance);
             AssertEx.EqualTolerance(KilovoltamperesInOneVoltampere, voltampere.Kilovoltamperes, KilovoltamperesTolerance);
             AssertEx.EqualTolerance(MegavoltamperesInOneVoltampere, voltampere.Megavoltamperes, MegavoltamperesTolerance);
@@ -130,19 +130,19 @@ public void VoltampereToApparentPowerUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ApparentPower.From(1, ApparentPowerUnit.Gigavoltampere);
+            var quantity00 = ApparentPower<double>.From(1, ApparentPowerUnit.Gigavoltampere);
             AssertEx.EqualTolerance(1, quantity00.Gigavoltamperes, GigavoltamperesTolerance);
             Assert.Equal(ApparentPowerUnit.Gigavoltampere, quantity00.Unit);
 
-            var quantity01 = ApparentPower.From(1, ApparentPowerUnit.Kilovoltampere);
+            var quantity01 = ApparentPower<double>.From(1, ApparentPowerUnit.Kilovoltampere);
             AssertEx.EqualTolerance(1, quantity01.Kilovoltamperes, KilovoltamperesTolerance);
             Assert.Equal(ApparentPowerUnit.Kilovoltampere, quantity01.Unit);
 
-            var quantity02 = ApparentPower.From(1, ApparentPowerUnit.Megavoltampere);
+            var quantity02 = ApparentPower<double>.From(1, ApparentPowerUnit.Megavoltampere);
             AssertEx.EqualTolerance(1, quantity02.Megavoltamperes, MegavoltamperesTolerance);
             Assert.Equal(ApparentPowerUnit.Megavoltampere, quantity02.Unit);
 
-            var quantity03 = ApparentPower.From(1, ApparentPowerUnit.Voltampere);
+            var quantity03 = ApparentPower<double>.From(1, ApparentPowerUnit.Voltampere);
             AssertEx.EqualTolerance(1, quantity03.Voltamperes, VoltamperesTolerance);
             Assert.Equal(ApparentPowerUnit.Voltampere, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltamperes_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ApparentPower.FromVoltamperes(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ApparentPower.FromVoltamperes(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ApparentPower<double>.FromVoltamperes(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ApparentPower<double>.FromVoltamperes(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltamperes_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ApparentPower.FromVoltamperes(double.NaN));
+            Assert.Throws<ArgumentException>(() => ApparentPower<double>.FromVoltamperes(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltampere = ApparentPower.FromVoltamperes(1);
+            var voltampere = ApparentPower<double>.FromVoltamperes(1);
             AssertEx.EqualTolerance(GigavoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Gigavoltampere), GigavoltamperesTolerance);
             AssertEx.EqualTolerance(KilovoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Kilovoltampere), KilovoltamperesTolerance);
             AssertEx.EqualTolerance(MegavoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Megavoltampere), MegavoltamperesTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltampere = ApparentPower.FromVoltamperes(1);
+            var voltampere = ApparentPower<double>.FromVoltamperes(1);
 
             var gigavoltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Gigavoltampere);
             AssertEx.EqualTolerance(GigavoltamperesInOneVoltampere, (double)gigavoltampereQuantity.Value, GigavoltamperesTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ApparentPower voltampere = ApparentPower.FromVoltamperes(1);
-            AssertEx.EqualTolerance(1, ApparentPower.FromGigavoltamperes(voltampere.Gigavoltamperes).Voltamperes, GigavoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ApparentPower.FromKilovoltamperes(voltampere.Kilovoltamperes).Voltamperes, KilovoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ApparentPower.FromMegavoltamperes(voltampere.Megavoltamperes).Voltamperes, MegavoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ApparentPower.FromVoltamperes(voltampere.Voltamperes).Voltamperes, VoltamperesTolerance);
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromGigavoltamperes(voltampere.Gigavoltamperes).Voltamperes, GigavoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromKilovoltamperes(voltampere.Kilovoltamperes).Voltamperes, KilovoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromMegavoltamperes(voltampere.Megavoltamperes).Voltamperes, MegavoltamperesTolerance);
+            AssertEx.EqualTolerance(1, ApparentPower<double>.FromVoltamperes(voltampere.Voltamperes).Voltamperes, VoltamperesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ApparentPower v = ApparentPower.FromVoltamperes(1);
+            ApparentPower<double> v = ApparentPower<double>.FromVoltamperes(1);
             AssertEx.EqualTolerance(-1, -v.Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(2, (ApparentPower.FromVoltamperes(3)-v).Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(2, (ApparentPower<double>.FromVoltamperes(3)-v).Voltamperes, VoltamperesTolerance);
             AssertEx.EqualTolerance(2, (v + v).Voltamperes, VoltamperesTolerance);
             AssertEx.EqualTolerance(10, (v*10).Voltamperes, VoltamperesTolerance);
             AssertEx.EqualTolerance(10, (10*v).Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(2, (ApparentPower.FromVoltamperes(10)/5).Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(2, ApparentPower.FromVoltamperes(10)/ApparentPower.FromVoltamperes(5), VoltamperesTolerance);
+            AssertEx.EqualTolerance(2, (ApparentPower<double>.FromVoltamperes(10)/5).Voltamperes, VoltamperesTolerance);
+            AssertEx.EqualTolerance(2, ApparentPower<double>.FromVoltamperes(10)/ApparentPower<double>.FromVoltamperes(5), VoltamperesTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ApparentPower oneVoltampere = ApparentPower.FromVoltamperes(1);
-            ApparentPower twoVoltamperes = ApparentPower.FromVoltamperes(2);
+            ApparentPower<double> oneVoltampere = ApparentPower<double>.FromVoltamperes(1);
+            ApparentPower<double> twoVoltamperes = ApparentPower<double>.FromVoltamperes(2);
 
             Assert.True(oneVoltampere < twoVoltamperes);
             Assert.True(oneVoltampere <= twoVoltamperes);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ApparentPower voltampere = ApparentPower.FromVoltamperes(1);
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
             Assert.Equal(0, voltampere.CompareTo(voltampere));
-            Assert.True(voltampere.CompareTo(ApparentPower.Zero) > 0);
-            Assert.True(ApparentPower.Zero.CompareTo(voltampere) < 0);
+            Assert.True(voltampere.CompareTo(ApparentPower<double>.Zero) > 0);
+            Assert.True(ApparentPower<double>.Zero.CompareTo(voltampere) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ApparentPower voltampere = ApparentPower.FromVoltamperes(1);
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
             Assert.Throws<ArgumentException>(() => voltampere.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ApparentPower voltampere = ApparentPower.FromVoltamperes(1);
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
             Assert.Throws<ArgumentNullException>(() => voltampere.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ApparentPower.FromVoltamperes(1);
-            var b = ApparentPower.FromVoltamperes(2);
+            var a = ApparentPower<double>.FromVoltamperes(1);
+            var b = ApparentPower<double>.FromVoltamperes(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ApparentPower.FromVoltamperes(1);
-            var b = ApparentPower.FromVoltamperes(2);
+            var a = ApparentPower<double>.FromVoltamperes(1);
+            var b = ApparentPower<double>.FromVoltamperes(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ApparentPower.FromVoltamperes(1);
-            Assert.True(v.Equals(ApparentPower.FromVoltamperes(1), VoltamperesTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ApparentPower.Zero, VoltamperesTolerance, ComparisonType.Relative));
+            var v = ApparentPower<double>.FromVoltamperes(1);
+            Assert.True(v.Equals(ApparentPower<double>.FromVoltamperes(1), VoltamperesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ApparentPower<double>.Zero, VoltamperesTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ApparentPower voltampere = ApparentPower.FromVoltamperes(1);
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
             Assert.False(voltampere.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ApparentPower voltampere = ApparentPower.FromVoltamperes(1);
+            ApparentPower<double> voltampere = ApparentPower<double>.FromVoltamperes(1);
             Assert.False(voltampere.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ApparentPowerUnit.Undefined, ApparentPower.Units);
+            Assert.DoesNotContain(ApparentPowerUnit.Undefined, ApparentPower<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ApparentPower.BaseDimensions is null);
+            Assert.False(ApparentPower<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs
index 307c82af4e..717fc0bfdd 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class AreaDensityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AreaDensity((double)0.0, AreaDensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>((double)0.0, AreaDensityUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AreaDensity(double.PositiveInfinity, AreaDensityUnit.KilogramPerSquareMeter));
-            Assert.Throws<ArgumentException>(() => new AreaDensity(double.NegativeInfinity, AreaDensityUnit.KilogramPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>(double.PositiveInfinity, AreaDensityUnit.KilogramPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>(double.NegativeInfinity, AreaDensityUnit.KilogramPerSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AreaDensity(double.NaN, AreaDensityUnit.KilogramPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new AreaDensity<double>(double.NaN, AreaDensityUnit.KilogramPerSquareMeter));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void AreaDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void KilogramPerSquareMeterToAreaDensityUnits()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = AreaDensity.From(1, AreaDensityUnit.KilogramPerSquareMeter);
+            var quantity00 = AreaDensity<double>.From(1, AreaDensityUnit.KilogramPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity00.KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
             Assert.Equal(AreaDensityUnit.KilogramPerSquareMeter, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramsPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AreaDensity.FromKilogramsPerSquareMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => AreaDensity.FromKilogramsPerSquareMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => AreaDensity<double>.FromKilogramsPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => AreaDensity<double>.FromKilogramsPerSquareMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramsPerSquareMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AreaDensity.FromKilogramsPerSquareMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => AreaDensity<double>.FromKilogramsPerSquareMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            var kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.KilogramPerSquareMeter), KilogramsPerSquareMeterTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            var kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
 
             var kilogrampersquaremeterQuantity = kilogrampersquaremeter.ToUnit(AreaDensityUnit.KilogramPerSquareMeter);
             AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, (double)kilogrampersquaremeterQuantity.Value, KilogramsPerSquareMeterTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, AreaDensity.FromKilogramsPerSquareMeter(kilogrampersquaremeter.KilogramsPerSquareMeter).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, AreaDensity<double>.FromKilogramsPerSquareMeter(kilogrampersquaremeter.KilogramsPerSquareMeter).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            AreaDensity v = AreaDensity.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> v = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             AssertEx.EqualTolerance(-1, -v.KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (AreaDensity.FromKilogramsPerSquareMeter(3)-v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (AreaDensity<double>.FromKilogramsPerSquareMeter(3)-v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (AreaDensity.FromKilogramsPerSquareMeter(10)/5).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, AreaDensity.FromKilogramsPerSquareMeter(10)/AreaDensity.FromKilogramsPerSquareMeter(5), KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (AreaDensity<double>.FromKilogramsPerSquareMeter(10)/5).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, AreaDensity<double>.FromKilogramsPerSquareMeter(10)/AreaDensity<double>.FromKilogramsPerSquareMeter(5), KilogramsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            AreaDensity oneKilogramPerSquareMeter = AreaDensity.FromKilogramsPerSquareMeter(1);
-            AreaDensity twoKilogramsPerSquareMeter = AreaDensity.FromKilogramsPerSquareMeter(2);
+            AreaDensity<double> oneKilogramPerSquareMeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> twoKilogramsPerSquareMeter = AreaDensity<double>.FromKilogramsPerSquareMeter(2);
 
             Assert.True(oneKilogramPerSquareMeter < twoKilogramsPerSquareMeter);
             Assert.True(oneKilogramPerSquareMeter <= twoKilogramsPerSquareMeter);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             Assert.Equal(0, kilogrampersquaremeter.CompareTo(kilogrampersquaremeter));
-            Assert.True(kilogrampersquaremeter.CompareTo(AreaDensity.Zero) > 0);
-            Assert.True(AreaDensity.Zero.CompareTo(kilogrampersquaremeter) < 0);
+            Assert.True(kilogrampersquaremeter.CompareTo(AreaDensity<double>.Zero) > 0);
+            Assert.True(AreaDensity<double>.Zero.CompareTo(kilogrampersquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             Assert.Throws<ArgumentException>(() => kilogrampersquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             Assert.Throws<ArgumentNullException>(() => kilogrampersquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = AreaDensity.FromKilogramsPerSquareMeter(1);
-            var b = AreaDensity.FromKilogramsPerSquareMeter(2);
+            var a = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            var b = AreaDensity<double>.FromKilogramsPerSquareMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = AreaDensity.FromKilogramsPerSquareMeter(1);
-            var b = AreaDensity.FromKilogramsPerSquareMeter(2);
+            var a = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            var b = AreaDensity<double>.FromKilogramsPerSquareMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = AreaDensity.FromKilogramsPerSquareMeter(1);
-            Assert.True(v.Equals(AreaDensity.FromKilogramsPerSquareMeter(1), KilogramsPerSquareMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(AreaDensity.Zero, KilogramsPerSquareMeterTolerance, ComparisonType.Relative));
+            var v = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
+            Assert.True(v.Equals(AreaDensity<double>.FromKilogramsPerSquareMeter(1), KilogramsPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(AreaDensity<double>.Zero, KilogramsPerSquareMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             Assert.False(kilogrampersquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+            AreaDensity<double> kilogrampersquaremeter = AreaDensity<double>.FromKilogramsPerSquareMeter(1);
             Assert.False(kilogrampersquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(AreaDensityUnit.Undefined, AreaDensity.Units);
+            Assert.DoesNotContain(AreaDensityUnit.Undefined, AreaDensity<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(AreaDensity.BaseDimensions is null);
+            Assert.False(AreaDensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs
index 0fde2b3698..0d3a6bef1d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs
@@ -56,7 +56,7 @@ public abstract partial class AreaMomentOfInertiaTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia((double)0.0, AreaMomentOfInertiaUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>((double)0.0, AreaMomentOfInertiaUnit.Undefined));
         }
 
         [Fact]
@@ -71,14 +71,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia(double.PositiveInfinity, AreaMomentOfInertiaUnit.MeterToTheFourth));
-            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia(double.NegativeInfinity, AreaMomentOfInertiaUnit.MeterToTheFourth));
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>(double.PositiveInfinity, AreaMomentOfInertiaUnit.MeterToTheFourth));
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>(double.NegativeInfinity, AreaMomentOfInertiaUnit.MeterToTheFourth));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia(double.NaN, AreaMomentOfInertiaUnit.MeterToTheFourth));
+            Assert.Throws<ArgumentException>(() => new AreaMomentOfInertia<double>(double.NaN, AreaMomentOfInertiaUnit.MeterToTheFourth));
         }
 
         [Fact]
@@ -124,7 +124,7 @@ public void AreaMomentOfInertia_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void MeterToTheFourthToAreaMomentOfInertiaUnits()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             AssertEx.EqualTolerance(CentimetersToTheFourthInOneMeterToTheFourth, metertothefourth.CentimetersToTheFourth, CentimetersToTheFourthTolerance);
             AssertEx.EqualTolerance(DecimetersToTheFourthInOneMeterToTheFourth, metertothefourth.DecimetersToTheFourth, DecimetersToTheFourthTolerance);
             AssertEx.EqualTolerance(FeetToTheFourthInOneMeterToTheFourth, metertothefourth.FeetToTheFourth, FeetToTheFourthTolerance);
@@ -136,27 +136,27 @@ public void MeterToTheFourthToAreaMomentOfInertiaUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = AreaMomentOfInertia.From(1, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
+            var quantity00 = AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
             AssertEx.EqualTolerance(1, quantity00.CentimetersToTheFourth, CentimetersToTheFourthTolerance);
             Assert.Equal(AreaMomentOfInertiaUnit.CentimeterToTheFourth, quantity00.Unit);
 
-            var quantity01 = AreaMomentOfInertia.From(1, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
+            var quantity01 = AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
             AssertEx.EqualTolerance(1, quantity01.DecimetersToTheFourth, DecimetersToTheFourthTolerance);
             Assert.Equal(AreaMomentOfInertiaUnit.DecimeterToTheFourth, quantity01.Unit);
 
-            var quantity02 = AreaMomentOfInertia.From(1, AreaMomentOfInertiaUnit.FootToTheFourth);
+            var quantity02 = AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.FootToTheFourth);
             AssertEx.EqualTolerance(1, quantity02.FeetToTheFourth, FeetToTheFourthTolerance);
             Assert.Equal(AreaMomentOfInertiaUnit.FootToTheFourth, quantity02.Unit);
 
-            var quantity03 = AreaMomentOfInertia.From(1, AreaMomentOfInertiaUnit.InchToTheFourth);
+            var quantity03 = AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.InchToTheFourth);
             AssertEx.EqualTolerance(1, quantity03.InchesToTheFourth, InchesToTheFourthTolerance);
             Assert.Equal(AreaMomentOfInertiaUnit.InchToTheFourth, quantity03.Unit);
 
-            var quantity04 = AreaMomentOfInertia.From(1, AreaMomentOfInertiaUnit.MeterToTheFourth);
+            var quantity04 = AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.MeterToTheFourth);
             AssertEx.EqualTolerance(1, quantity04.MetersToTheFourth, MetersToTheFourthTolerance);
             Assert.Equal(AreaMomentOfInertiaUnit.MeterToTheFourth, quantity04.Unit);
 
-            var quantity05 = AreaMomentOfInertia.From(1, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
+            var quantity05 = AreaMomentOfInertia<double>.From(1, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
             AssertEx.EqualTolerance(1, quantity05.MillimetersToTheFourth, MillimetersToTheFourthTolerance);
             Assert.Equal(AreaMomentOfInertiaUnit.MillimeterToTheFourth, quantity05.Unit);
 
@@ -165,20 +165,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromMetersToTheFourth_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia.FromMetersToTheFourth(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia.FromMetersToTheFourth(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia<double>.FromMetersToTheFourth(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia<double>.FromMetersToTheFourth(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromMetersToTheFourth_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia.FromMetersToTheFourth(double.NaN));
+            Assert.Throws<ArgumentException>(() => AreaMomentOfInertia<double>.FromMetersToTheFourth(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            var metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             AssertEx.EqualTolerance(CentimetersToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.CentimeterToTheFourth), CentimetersToTheFourthTolerance);
             AssertEx.EqualTolerance(DecimetersToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.DecimeterToTheFourth), DecimetersToTheFourthTolerance);
             AssertEx.EqualTolerance(FeetToTheFourthInOneMeterToTheFourth, metertothefourth.As(AreaMomentOfInertiaUnit.FootToTheFourth), FeetToTheFourthTolerance);
@@ -207,7 +207,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            var metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
 
             var centimetertothefourthQuantity = metertothefourth.ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth);
             AssertEx.EqualTolerance(CentimetersToTheFourthInOneMeterToTheFourth, (double)centimetertothefourthQuantity.Value, CentimetersToTheFourthTolerance);
@@ -244,33 +244,33 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromCentimetersToTheFourth(metertothefourth.CentimetersToTheFourth).MetersToTheFourth, CentimetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromDecimetersToTheFourth(metertothefourth.DecimetersToTheFourth).MetersToTheFourth, DecimetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromFeetToTheFourth(metertothefourth.FeetToTheFourth).MetersToTheFourth, FeetToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromInchesToTheFourth(metertothefourth.InchesToTheFourth).MetersToTheFourth, InchesToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromMetersToTheFourth(metertothefourth.MetersToTheFourth).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromMillimetersToTheFourth(metertothefourth.MillimetersToTheFourth).MetersToTheFourth, MillimetersToTheFourthTolerance);
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromCentimetersToTheFourth(metertothefourth.CentimetersToTheFourth).MetersToTheFourth, CentimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromDecimetersToTheFourth(metertothefourth.DecimetersToTheFourth).MetersToTheFourth, DecimetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromFeetToTheFourth(metertothefourth.FeetToTheFourth).MetersToTheFourth, FeetToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromInchesToTheFourth(metertothefourth.InchesToTheFourth).MetersToTheFourth, InchesToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromMetersToTheFourth(metertothefourth.MetersToTheFourth).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(1, AreaMomentOfInertia<double>.FromMillimetersToTheFourth(metertothefourth.MillimetersToTheFourth).MetersToTheFourth, MillimetersToTheFourthTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            AreaMomentOfInertia v = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> v = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             AssertEx.EqualTolerance(-1, -v.MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(2, (AreaMomentOfInertia.FromMetersToTheFourth(3)-v).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(2, (AreaMomentOfInertia<double>.FromMetersToTheFourth(3)-v).MetersToTheFourth, MetersToTheFourthTolerance);
             AssertEx.EqualTolerance(2, (v + v).MetersToTheFourth, MetersToTheFourthTolerance);
             AssertEx.EqualTolerance(10, (v*10).MetersToTheFourth, MetersToTheFourthTolerance);
             AssertEx.EqualTolerance(10, (10*v).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(2, (AreaMomentOfInertia.FromMetersToTheFourth(10)/5).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(2, AreaMomentOfInertia.FromMetersToTheFourth(10)/AreaMomentOfInertia.FromMetersToTheFourth(5), MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(2, (AreaMomentOfInertia<double>.FromMetersToTheFourth(10)/5).MetersToTheFourth, MetersToTheFourthTolerance);
+            AssertEx.EqualTolerance(2, AreaMomentOfInertia<double>.FromMetersToTheFourth(10)/AreaMomentOfInertia<double>.FromMetersToTheFourth(5), MetersToTheFourthTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            AreaMomentOfInertia oneMeterToTheFourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            AreaMomentOfInertia twoMetersToTheFourth = AreaMomentOfInertia.FromMetersToTheFourth(2);
+            AreaMomentOfInertia<double> oneMeterToTheFourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> twoMetersToTheFourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(2);
 
             Assert.True(oneMeterToTheFourth < twoMetersToTheFourth);
             Assert.True(oneMeterToTheFourth <= twoMetersToTheFourth);
@@ -286,31 +286,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             Assert.Equal(0, metertothefourth.CompareTo(metertothefourth));
-            Assert.True(metertothefourth.CompareTo(AreaMomentOfInertia.Zero) > 0);
-            Assert.True(AreaMomentOfInertia.Zero.CompareTo(metertothefourth) < 0);
+            Assert.True(metertothefourth.CompareTo(AreaMomentOfInertia<double>.Zero) > 0);
+            Assert.True(AreaMomentOfInertia<double>.Zero.CompareTo(metertothefourth) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             Assert.Throws<ArgumentException>(() => metertothefourth.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             Assert.Throws<ArgumentNullException>(() => metertothefourth.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            var b = AreaMomentOfInertia.FromMetersToTheFourth(2);
+            var a = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            var b = AreaMomentOfInertia<double>.FromMetersToTheFourth(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -329,8 +329,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            var b = AreaMomentOfInertia.FromMetersToTheFourth(2);
+            var a = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            var b = AreaMomentOfInertia<double>.FromMetersToTheFourth(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -350,9 +350,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            Assert.True(v.Equals(AreaMomentOfInertia.FromMetersToTheFourth(1), MetersToTheFourthTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(AreaMomentOfInertia.Zero, MetersToTheFourthTolerance, ComparisonType.Relative));
+            var v = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
+            Assert.True(v.Equals(AreaMomentOfInertia<double>.FromMetersToTheFourth(1), MetersToTheFourthTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(AreaMomentOfInertia<double>.Zero, MetersToTheFourthTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -365,21 +365,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             Assert.False(metertothefourth.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
+            AreaMomentOfInertia<double> metertothefourth = AreaMomentOfInertia<double>.FromMetersToTheFourth(1);
             Assert.False(metertothefourth.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(AreaMomentOfInertiaUnit.Undefined, AreaMomentOfInertia.Units);
+            Assert.DoesNotContain(AreaMomentOfInertiaUnit.Undefined, AreaMomentOfInertia<double>.Units);
         }
 
         [Fact]
@@ -398,7 +398,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(AreaMomentOfInertia.BaseDimensions is null);
+            Assert.False(AreaMomentOfInertia<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs
index bccc9d7614..71888c151b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs
@@ -72,7 +72,7 @@ public abstract partial class AreaTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Area((double)0.0, AreaUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Area<double>((double)0.0, AreaUnit.Undefined));
         }
 
         [Fact]
@@ -87,14 +87,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Area(double.PositiveInfinity, AreaUnit.SquareMeter));
-            Assert.Throws<ArgumentException>(() => new Area(double.NegativeInfinity, AreaUnit.SquareMeter));
+            Assert.Throws<ArgumentException>(() => new Area<double>(double.PositiveInfinity, AreaUnit.SquareMeter));
+            Assert.Throws<ArgumentException>(() => new Area<double>(double.NegativeInfinity, AreaUnit.SquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Area(double.NaN, AreaUnit.SquareMeter));
+            Assert.Throws<ArgumentException>(() => new Area<double>(double.NaN, AreaUnit.SquareMeter));
         }
 
         [Fact]
@@ -140,7 +140,7 @@ public void Area_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void SquareMeterToAreaUnits()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
+            Area<double> squaremeter = Area<double>.FromSquareMeters(1);
             AssertEx.EqualTolerance(AcresInOneSquareMeter, squaremeter.Acres, AcresTolerance);
             AssertEx.EqualTolerance(HectaresInOneSquareMeter, squaremeter.Hectares, HectaresTolerance);
             AssertEx.EqualTolerance(SquareCentimetersInOneSquareMeter, squaremeter.SquareCentimeters, SquareCentimetersTolerance);
@@ -160,59 +160,59 @@ public void SquareMeterToAreaUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Area.From(1, AreaUnit.Acre);
+            var quantity00 = Area<double>.From(1, AreaUnit.Acre);
             AssertEx.EqualTolerance(1, quantity00.Acres, AcresTolerance);
             Assert.Equal(AreaUnit.Acre, quantity00.Unit);
 
-            var quantity01 = Area.From(1, AreaUnit.Hectare);
+            var quantity01 = Area<double>.From(1, AreaUnit.Hectare);
             AssertEx.EqualTolerance(1, quantity01.Hectares, HectaresTolerance);
             Assert.Equal(AreaUnit.Hectare, quantity01.Unit);
 
-            var quantity02 = Area.From(1, AreaUnit.SquareCentimeter);
+            var quantity02 = Area<double>.From(1, AreaUnit.SquareCentimeter);
             AssertEx.EqualTolerance(1, quantity02.SquareCentimeters, SquareCentimetersTolerance);
             Assert.Equal(AreaUnit.SquareCentimeter, quantity02.Unit);
 
-            var quantity03 = Area.From(1, AreaUnit.SquareDecimeter);
+            var quantity03 = Area<double>.From(1, AreaUnit.SquareDecimeter);
             AssertEx.EqualTolerance(1, quantity03.SquareDecimeters, SquareDecimetersTolerance);
             Assert.Equal(AreaUnit.SquareDecimeter, quantity03.Unit);
 
-            var quantity04 = Area.From(1, AreaUnit.SquareFoot);
+            var quantity04 = Area<double>.From(1, AreaUnit.SquareFoot);
             AssertEx.EqualTolerance(1, quantity04.SquareFeet, SquareFeetTolerance);
             Assert.Equal(AreaUnit.SquareFoot, quantity04.Unit);
 
-            var quantity05 = Area.From(1, AreaUnit.SquareInch);
+            var quantity05 = Area<double>.From(1, AreaUnit.SquareInch);
             AssertEx.EqualTolerance(1, quantity05.SquareInches, SquareInchesTolerance);
             Assert.Equal(AreaUnit.SquareInch, quantity05.Unit);
 
-            var quantity06 = Area.From(1, AreaUnit.SquareKilometer);
+            var quantity06 = Area<double>.From(1, AreaUnit.SquareKilometer);
             AssertEx.EqualTolerance(1, quantity06.SquareKilometers, SquareKilometersTolerance);
             Assert.Equal(AreaUnit.SquareKilometer, quantity06.Unit);
 
-            var quantity07 = Area.From(1, AreaUnit.SquareMeter);
+            var quantity07 = Area<double>.From(1, AreaUnit.SquareMeter);
             AssertEx.EqualTolerance(1, quantity07.SquareMeters, SquareMetersTolerance);
             Assert.Equal(AreaUnit.SquareMeter, quantity07.Unit);
 
-            var quantity08 = Area.From(1, AreaUnit.SquareMicrometer);
+            var quantity08 = Area<double>.From(1, AreaUnit.SquareMicrometer);
             AssertEx.EqualTolerance(1, quantity08.SquareMicrometers, SquareMicrometersTolerance);
             Assert.Equal(AreaUnit.SquareMicrometer, quantity08.Unit);
 
-            var quantity09 = Area.From(1, AreaUnit.SquareMile);
+            var quantity09 = Area<double>.From(1, AreaUnit.SquareMile);
             AssertEx.EqualTolerance(1, quantity09.SquareMiles, SquareMilesTolerance);
             Assert.Equal(AreaUnit.SquareMile, quantity09.Unit);
 
-            var quantity10 = Area.From(1, AreaUnit.SquareMillimeter);
+            var quantity10 = Area<double>.From(1, AreaUnit.SquareMillimeter);
             AssertEx.EqualTolerance(1, quantity10.SquareMillimeters, SquareMillimetersTolerance);
             Assert.Equal(AreaUnit.SquareMillimeter, quantity10.Unit);
 
-            var quantity11 = Area.From(1, AreaUnit.SquareNauticalMile);
+            var quantity11 = Area<double>.From(1, AreaUnit.SquareNauticalMile);
             AssertEx.EqualTolerance(1, quantity11.SquareNauticalMiles, SquareNauticalMilesTolerance);
             Assert.Equal(AreaUnit.SquareNauticalMile, quantity11.Unit);
 
-            var quantity12 = Area.From(1, AreaUnit.SquareYard);
+            var quantity12 = Area<double>.From(1, AreaUnit.SquareYard);
             AssertEx.EqualTolerance(1, quantity12.SquareYards, SquareYardsTolerance);
             Assert.Equal(AreaUnit.SquareYard, quantity12.Unit);
 
-            var quantity13 = Area.From(1, AreaUnit.UsSurveySquareFoot);
+            var quantity13 = Area<double>.From(1, AreaUnit.UsSurveySquareFoot);
             AssertEx.EqualTolerance(1, quantity13.UsSurveySquareFeet, UsSurveySquareFeetTolerance);
             Assert.Equal(AreaUnit.UsSurveySquareFoot, quantity13.Unit);
 
@@ -221,20 +221,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSquareMeters_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Area.FromSquareMeters(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Area.FromSquareMeters(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Area<double>.FromSquareMeters(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Area<double>.FromSquareMeters(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSquareMeters_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Area.FromSquareMeters(double.NaN));
+            Assert.Throws<ArgumentException>(() => Area<double>.FromSquareMeters(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var squaremeter = Area.FromSquareMeters(1);
+            var squaremeter = Area<double>.FromSquareMeters(1);
             AssertEx.EqualTolerance(AcresInOneSquareMeter, squaremeter.As(AreaUnit.Acre), AcresTolerance);
             AssertEx.EqualTolerance(HectaresInOneSquareMeter, squaremeter.As(AreaUnit.Hectare), HectaresTolerance);
             AssertEx.EqualTolerance(SquareCentimetersInOneSquareMeter, squaremeter.As(AreaUnit.SquareCentimeter), SquareCentimetersTolerance);
@@ -271,7 +271,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var squaremeter = Area.FromSquareMeters(1);
+            var squaremeter = Area<double>.FromSquareMeters(1);
 
             var acreQuantity = squaremeter.ToUnit(AreaUnit.Acre);
             AssertEx.EqualTolerance(AcresInOneSquareMeter, (double)acreQuantity.Value, AcresTolerance);
@@ -340,41 +340,41 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
-            AssertEx.EqualTolerance(1, Area.FromAcres(squaremeter.Acres).SquareMeters, AcresTolerance);
-            AssertEx.EqualTolerance(1, Area.FromHectares(squaremeter.Hectares).SquareMeters, HectaresTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareCentimeters(squaremeter.SquareCentimeters).SquareMeters, SquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareDecimeters(squaremeter.SquareDecimeters).SquareMeters, SquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareFeet(squaremeter.SquareFeet).SquareMeters, SquareFeetTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareInches(squaremeter.SquareInches).SquareMeters, SquareInchesTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareKilometers(squaremeter.SquareKilometers).SquareMeters, SquareKilometersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMeters(squaremeter.SquareMeters).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMicrometers(squaremeter.SquareMicrometers).SquareMeters, SquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMiles(squaremeter.SquareMiles).SquareMeters, SquareMilesTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMillimeters(squaremeter.SquareMillimeters).SquareMeters, SquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareNauticalMiles(squaremeter.SquareNauticalMiles).SquareMeters, SquareNauticalMilesTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareYards(squaremeter.SquareYards).SquareMeters, SquareYardsTolerance);
-            AssertEx.EqualTolerance(1, Area.FromUsSurveySquareFeet(squaremeter.UsSurveySquareFeet).SquareMeters, UsSurveySquareFeetTolerance);
+            Area<double> squaremeter = Area<double>.FromSquareMeters(1);
+            AssertEx.EqualTolerance(1, Area<double>.FromAcres(squaremeter.Acres).SquareMeters, AcresTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromHectares(squaremeter.Hectares).SquareMeters, HectaresTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareCentimeters(squaremeter.SquareCentimeters).SquareMeters, SquareCentimetersTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareDecimeters(squaremeter.SquareDecimeters).SquareMeters, SquareDecimetersTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareFeet(squaremeter.SquareFeet).SquareMeters, SquareFeetTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareInches(squaremeter.SquareInches).SquareMeters, SquareInchesTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareKilometers(squaremeter.SquareKilometers).SquareMeters, SquareKilometersTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareMeters(squaremeter.SquareMeters).SquareMeters, SquareMetersTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareMicrometers(squaremeter.SquareMicrometers).SquareMeters, SquareMicrometersTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareMiles(squaremeter.SquareMiles).SquareMeters, SquareMilesTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareMillimeters(squaremeter.SquareMillimeters).SquareMeters, SquareMillimetersTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareNauticalMiles(squaremeter.SquareNauticalMiles).SquareMeters, SquareNauticalMilesTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromSquareYards(squaremeter.SquareYards).SquareMeters, SquareYardsTolerance);
+            AssertEx.EqualTolerance(1, Area<double>.FromUsSurveySquareFeet(squaremeter.UsSurveySquareFeet).SquareMeters, UsSurveySquareFeetTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Area v = Area.FromSquareMeters(1);
+            Area<double> v = Area<double>.FromSquareMeters(1);
             AssertEx.EqualTolerance(-1, -v.SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (Area.FromSquareMeters(3)-v).SquareMeters, SquareMetersTolerance);
+            AssertEx.EqualTolerance(2, (Area<double>.FromSquareMeters(3)-v).SquareMeters, SquareMetersTolerance);
             AssertEx.EqualTolerance(2, (v + v).SquareMeters, SquareMetersTolerance);
             AssertEx.EqualTolerance(10, (v*10).SquareMeters, SquareMetersTolerance);
             AssertEx.EqualTolerance(10, (10*v).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (Area.FromSquareMeters(10)/5).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, Area.FromSquareMeters(10)/Area.FromSquareMeters(5), SquareMetersTolerance);
+            AssertEx.EqualTolerance(2, (Area<double>.FromSquareMeters(10)/5).SquareMeters, SquareMetersTolerance);
+            AssertEx.EqualTolerance(2, Area<double>.FromSquareMeters(10)/Area<double>.FromSquareMeters(5), SquareMetersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Area oneSquareMeter = Area.FromSquareMeters(1);
-            Area twoSquareMeters = Area.FromSquareMeters(2);
+            Area<double> oneSquareMeter = Area<double>.FromSquareMeters(1);
+            Area<double> twoSquareMeters = Area<double>.FromSquareMeters(2);
 
             Assert.True(oneSquareMeter < twoSquareMeters);
             Assert.True(oneSquareMeter <= twoSquareMeters);
@@ -390,31 +390,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
+            Area<double> squaremeter = Area<double>.FromSquareMeters(1);
             Assert.Equal(0, squaremeter.CompareTo(squaremeter));
-            Assert.True(squaremeter.CompareTo(Area.Zero) > 0);
-            Assert.True(Area.Zero.CompareTo(squaremeter) < 0);
+            Assert.True(squaremeter.CompareTo(Area<double>.Zero) > 0);
+            Assert.True(Area<double>.Zero.CompareTo(squaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
+            Area<double> squaremeter = Area<double>.FromSquareMeters(1);
             Assert.Throws<ArgumentException>(() => squaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
+            Area<double> squaremeter = Area<double>.FromSquareMeters(1);
             Assert.Throws<ArgumentNullException>(() => squaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Area.FromSquareMeters(1);
-            var b = Area.FromSquareMeters(2);
+            var a = Area<double>.FromSquareMeters(1);
+            var b = Area<double>.FromSquareMeters(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -433,8 +433,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Area.FromSquareMeters(1);
-            var b = Area.FromSquareMeters(2);
+            var a = Area<double>.FromSquareMeters(1);
+            var b = Area<double>.FromSquareMeters(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -454,9 +454,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Area.FromSquareMeters(1);
-            Assert.True(v.Equals(Area.FromSquareMeters(1), SquareMetersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Area.Zero, SquareMetersTolerance, ComparisonType.Relative));
+            var v = Area<double>.FromSquareMeters(1);
+            Assert.True(v.Equals(Area<double>.FromSquareMeters(1), SquareMetersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Area<double>.Zero, SquareMetersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -469,21 +469,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
+            Area<double> squaremeter = Area<double>.FromSquareMeters(1);
             Assert.False(squaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
+            Area<double> squaremeter = Area<double>.FromSquareMeters(1);
             Assert.False(squaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(AreaUnit.Undefined, Area.Units);
+            Assert.DoesNotContain(AreaUnit.Undefined, Area<double>.Units);
         }
 
         [Fact]
@@ -502,7 +502,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Area.BaseDimensions is null);
+            Assert.False(Area<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs
index b0333008f8..1ec0d56ef4 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs
@@ -96,7 +96,7 @@ public abstract partial class BitRateTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new BitRate((decimal)0.0, BitRateUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new BitRate<double>((decimal)0.0, BitRateUnit.Undefined));
         }
 
         [Fact]
@@ -152,7 +152,7 @@ public void BitRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void BitPerSecondToBitRateUnits()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
+            BitRate<double> bitpersecond = BitRate<double>.FromBitsPerSecond(1);
             AssertEx.EqualTolerance(BitsPerSecondInOneBitPerSecond, bitpersecond.BitsPerSecond, BitsPerSecondTolerance);
             AssertEx.EqualTolerance(BytesPerSecondInOneBitPerSecond, bitpersecond.BytesPerSecond, BytesPerSecondTolerance);
             AssertEx.EqualTolerance(ExabitsPerSecondInOneBitPerSecond, bitpersecond.ExabitsPerSecond, ExabitsPerSecondTolerance);
@@ -184,107 +184,107 @@ public void BitPerSecondToBitRateUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = BitRate.From(1, BitRateUnit.BitPerSecond);
+            var quantity00 = BitRate<double>.From(1, BitRateUnit.BitPerSecond);
             AssertEx.EqualTolerance(1, quantity00.BitsPerSecond, BitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.BitPerSecond, quantity00.Unit);
 
-            var quantity01 = BitRate.From(1, BitRateUnit.BytePerSecond);
+            var quantity01 = BitRate<double>.From(1, BitRateUnit.BytePerSecond);
             AssertEx.EqualTolerance(1, quantity01.BytesPerSecond, BytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.BytePerSecond, quantity01.Unit);
 
-            var quantity02 = BitRate.From(1, BitRateUnit.ExabitPerSecond);
+            var quantity02 = BitRate<double>.From(1, BitRateUnit.ExabitPerSecond);
             AssertEx.EqualTolerance(1, quantity02.ExabitsPerSecond, ExabitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.ExabitPerSecond, quantity02.Unit);
 
-            var quantity03 = BitRate.From(1, BitRateUnit.ExabytePerSecond);
+            var quantity03 = BitRate<double>.From(1, BitRateUnit.ExabytePerSecond);
             AssertEx.EqualTolerance(1, quantity03.ExabytesPerSecond, ExabytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.ExabytePerSecond, quantity03.Unit);
 
-            var quantity04 = BitRate.From(1, BitRateUnit.ExbibitPerSecond);
+            var quantity04 = BitRate<double>.From(1, BitRateUnit.ExbibitPerSecond);
             AssertEx.EqualTolerance(1, quantity04.ExbibitsPerSecond, ExbibitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.ExbibitPerSecond, quantity04.Unit);
 
-            var quantity05 = BitRate.From(1, BitRateUnit.ExbibytePerSecond);
+            var quantity05 = BitRate<double>.From(1, BitRateUnit.ExbibytePerSecond);
             AssertEx.EqualTolerance(1, quantity05.ExbibytesPerSecond, ExbibytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.ExbibytePerSecond, quantity05.Unit);
 
-            var quantity06 = BitRate.From(1, BitRateUnit.GibibitPerSecond);
+            var quantity06 = BitRate<double>.From(1, BitRateUnit.GibibitPerSecond);
             AssertEx.EqualTolerance(1, quantity06.GibibitsPerSecond, GibibitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.GibibitPerSecond, quantity06.Unit);
 
-            var quantity07 = BitRate.From(1, BitRateUnit.GibibytePerSecond);
+            var quantity07 = BitRate<double>.From(1, BitRateUnit.GibibytePerSecond);
             AssertEx.EqualTolerance(1, quantity07.GibibytesPerSecond, GibibytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.GibibytePerSecond, quantity07.Unit);
 
-            var quantity08 = BitRate.From(1, BitRateUnit.GigabitPerSecond);
+            var quantity08 = BitRate<double>.From(1, BitRateUnit.GigabitPerSecond);
             AssertEx.EqualTolerance(1, quantity08.GigabitsPerSecond, GigabitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.GigabitPerSecond, quantity08.Unit);
 
-            var quantity09 = BitRate.From(1, BitRateUnit.GigabytePerSecond);
+            var quantity09 = BitRate<double>.From(1, BitRateUnit.GigabytePerSecond);
             AssertEx.EqualTolerance(1, quantity09.GigabytesPerSecond, GigabytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.GigabytePerSecond, quantity09.Unit);
 
-            var quantity10 = BitRate.From(1, BitRateUnit.KibibitPerSecond);
+            var quantity10 = BitRate<double>.From(1, BitRateUnit.KibibitPerSecond);
             AssertEx.EqualTolerance(1, quantity10.KibibitsPerSecond, KibibitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.KibibitPerSecond, quantity10.Unit);
 
-            var quantity11 = BitRate.From(1, BitRateUnit.KibibytePerSecond);
+            var quantity11 = BitRate<double>.From(1, BitRateUnit.KibibytePerSecond);
             AssertEx.EqualTolerance(1, quantity11.KibibytesPerSecond, KibibytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.KibibytePerSecond, quantity11.Unit);
 
-            var quantity12 = BitRate.From(1, BitRateUnit.KilobitPerSecond);
+            var quantity12 = BitRate<double>.From(1, BitRateUnit.KilobitPerSecond);
             AssertEx.EqualTolerance(1, quantity12.KilobitsPerSecond, KilobitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.KilobitPerSecond, quantity12.Unit);
 
-            var quantity13 = BitRate.From(1, BitRateUnit.KilobytePerSecond);
+            var quantity13 = BitRate<double>.From(1, BitRateUnit.KilobytePerSecond);
             AssertEx.EqualTolerance(1, quantity13.KilobytesPerSecond, KilobytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.KilobytePerSecond, quantity13.Unit);
 
-            var quantity14 = BitRate.From(1, BitRateUnit.MebibitPerSecond);
+            var quantity14 = BitRate<double>.From(1, BitRateUnit.MebibitPerSecond);
             AssertEx.EqualTolerance(1, quantity14.MebibitsPerSecond, MebibitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.MebibitPerSecond, quantity14.Unit);
 
-            var quantity15 = BitRate.From(1, BitRateUnit.MebibytePerSecond);
+            var quantity15 = BitRate<double>.From(1, BitRateUnit.MebibytePerSecond);
             AssertEx.EqualTolerance(1, quantity15.MebibytesPerSecond, MebibytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.MebibytePerSecond, quantity15.Unit);
 
-            var quantity16 = BitRate.From(1, BitRateUnit.MegabitPerSecond);
+            var quantity16 = BitRate<double>.From(1, BitRateUnit.MegabitPerSecond);
             AssertEx.EqualTolerance(1, quantity16.MegabitsPerSecond, MegabitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.MegabitPerSecond, quantity16.Unit);
 
-            var quantity17 = BitRate.From(1, BitRateUnit.MegabytePerSecond);
+            var quantity17 = BitRate<double>.From(1, BitRateUnit.MegabytePerSecond);
             AssertEx.EqualTolerance(1, quantity17.MegabytesPerSecond, MegabytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.MegabytePerSecond, quantity17.Unit);
 
-            var quantity18 = BitRate.From(1, BitRateUnit.PebibitPerSecond);
+            var quantity18 = BitRate<double>.From(1, BitRateUnit.PebibitPerSecond);
             AssertEx.EqualTolerance(1, quantity18.PebibitsPerSecond, PebibitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.PebibitPerSecond, quantity18.Unit);
 
-            var quantity19 = BitRate.From(1, BitRateUnit.PebibytePerSecond);
+            var quantity19 = BitRate<double>.From(1, BitRateUnit.PebibytePerSecond);
             AssertEx.EqualTolerance(1, quantity19.PebibytesPerSecond, PebibytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.PebibytePerSecond, quantity19.Unit);
 
-            var quantity20 = BitRate.From(1, BitRateUnit.PetabitPerSecond);
+            var quantity20 = BitRate<double>.From(1, BitRateUnit.PetabitPerSecond);
             AssertEx.EqualTolerance(1, quantity20.PetabitsPerSecond, PetabitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.PetabitPerSecond, quantity20.Unit);
 
-            var quantity21 = BitRate.From(1, BitRateUnit.PetabytePerSecond);
+            var quantity21 = BitRate<double>.From(1, BitRateUnit.PetabytePerSecond);
             AssertEx.EqualTolerance(1, quantity21.PetabytesPerSecond, PetabytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.PetabytePerSecond, quantity21.Unit);
 
-            var quantity22 = BitRate.From(1, BitRateUnit.TebibitPerSecond);
+            var quantity22 = BitRate<double>.From(1, BitRateUnit.TebibitPerSecond);
             AssertEx.EqualTolerance(1, quantity22.TebibitsPerSecond, TebibitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.TebibitPerSecond, quantity22.Unit);
 
-            var quantity23 = BitRate.From(1, BitRateUnit.TebibytePerSecond);
+            var quantity23 = BitRate<double>.From(1, BitRateUnit.TebibytePerSecond);
             AssertEx.EqualTolerance(1, quantity23.TebibytesPerSecond, TebibytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.TebibytePerSecond, quantity23.Unit);
 
-            var quantity24 = BitRate.From(1, BitRateUnit.TerabitPerSecond);
+            var quantity24 = BitRate<double>.From(1, BitRateUnit.TerabitPerSecond);
             AssertEx.EqualTolerance(1, quantity24.TerabitsPerSecond, TerabitsPerSecondTolerance);
             Assert.Equal(BitRateUnit.TerabitPerSecond, quantity24.Unit);
 
-            var quantity25 = BitRate.From(1, BitRateUnit.TerabytePerSecond);
+            var quantity25 = BitRate<double>.From(1, BitRateUnit.TerabytePerSecond);
             AssertEx.EqualTolerance(1, quantity25.TerabytesPerSecond, TerabytesPerSecondTolerance);
             Assert.Equal(BitRateUnit.TerabytePerSecond, quantity25.Unit);
 
@@ -293,7 +293,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void As()
         {
-            var bitpersecond = BitRate.FromBitsPerSecond(1);
+            var bitpersecond = BitRate<double>.FromBitsPerSecond(1);
             AssertEx.EqualTolerance(BitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.BitPerSecond), BitsPerSecondTolerance);
             AssertEx.EqualTolerance(BytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.BytePerSecond), BytesPerSecondTolerance);
             AssertEx.EqualTolerance(ExabitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.ExabitPerSecond), ExabitsPerSecondTolerance);
@@ -342,7 +342,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var bitpersecond = BitRate.FromBitsPerSecond(1);
+            var bitpersecond = BitRate<double>.FromBitsPerSecond(1);
 
             var bitpersecondQuantity = bitpersecond.ToUnit(BitRateUnit.BitPerSecond);
             AssertEx.EqualTolerance(BitsPerSecondInOneBitPerSecond, (double)bitpersecondQuantity.Value, BitsPerSecondTolerance);
@@ -459,53 +459,53 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
-            AssertEx.EqualTolerance(1, BitRate.FromBitsPerSecond(bitpersecond.BitsPerSecond).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromBytesPerSecond(bitpersecond.BytesPerSecond).BitsPerSecond, BytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExabitsPerSecond(bitpersecond.ExabitsPerSecond).BitsPerSecond, ExabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExabytesPerSecond(bitpersecond.ExabytesPerSecond).BitsPerSecond, ExabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExbibitsPerSecond(bitpersecond.ExbibitsPerSecond).BitsPerSecond, ExbibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExbibytesPerSecond(bitpersecond.ExbibytesPerSecond).BitsPerSecond, ExbibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGibibitsPerSecond(bitpersecond.GibibitsPerSecond).BitsPerSecond, GibibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGibibytesPerSecond(bitpersecond.GibibytesPerSecond).BitsPerSecond, GibibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGigabitsPerSecond(bitpersecond.GigabitsPerSecond).BitsPerSecond, GigabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGigabytesPerSecond(bitpersecond.GigabytesPerSecond).BitsPerSecond, GigabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKibibitsPerSecond(bitpersecond.KibibitsPerSecond).BitsPerSecond, KibibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKibibytesPerSecond(bitpersecond.KibibytesPerSecond).BitsPerSecond, KibibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKilobitsPerSecond(bitpersecond.KilobitsPerSecond).BitsPerSecond, KilobitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKilobytesPerSecond(bitpersecond.KilobytesPerSecond).BitsPerSecond, KilobytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMebibitsPerSecond(bitpersecond.MebibitsPerSecond).BitsPerSecond, MebibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMebibytesPerSecond(bitpersecond.MebibytesPerSecond).BitsPerSecond, MebibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMegabitsPerSecond(bitpersecond.MegabitsPerSecond).BitsPerSecond, MegabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMegabytesPerSecond(bitpersecond.MegabytesPerSecond).BitsPerSecond, MegabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPebibitsPerSecond(bitpersecond.PebibitsPerSecond).BitsPerSecond, PebibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPebibytesPerSecond(bitpersecond.PebibytesPerSecond).BitsPerSecond, PebibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPetabitsPerSecond(bitpersecond.PetabitsPerSecond).BitsPerSecond, PetabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPetabytesPerSecond(bitpersecond.PetabytesPerSecond).BitsPerSecond, PetabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTebibitsPerSecond(bitpersecond.TebibitsPerSecond).BitsPerSecond, TebibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTebibytesPerSecond(bitpersecond.TebibytesPerSecond).BitsPerSecond, TebibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTerabitsPerSecond(bitpersecond.TerabitsPerSecond).BitsPerSecond, TerabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTerabytesPerSecond(bitpersecond.TerabytesPerSecond).BitsPerSecond, TerabytesPerSecondTolerance);
+            BitRate<double> bitpersecond = BitRate<double>.FromBitsPerSecond(1);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromBitsPerSecond(bitpersecond.BitsPerSecond).BitsPerSecond, BitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromBytesPerSecond(bitpersecond.BytesPerSecond).BitsPerSecond, BytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromExabitsPerSecond(bitpersecond.ExabitsPerSecond).BitsPerSecond, ExabitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromExabytesPerSecond(bitpersecond.ExabytesPerSecond).BitsPerSecond, ExabytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromExbibitsPerSecond(bitpersecond.ExbibitsPerSecond).BitsPerSecond, ExbibitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromExbibytesPerSecond(bitpersecond.ExbibytesPerSecond).BitsPerSecond, ExbibytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromGibibitsPerSecond(bitpersecond.GibibitsPerSecond).BitsPerSecond, GibibitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromGibibytesPerSecond(bitpersecond.GibibytesPerSecond).BitsPerSecond, GibibytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromGigabitsPerSecond(bitpersecond.GigabitsPerSecond).BitsPerSecond, GigabitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromGigabytesPerSecond(bitpersecond.GigabytesPerSecond).BitsPerSecond, GigabytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromKibibitsPerSecond(bitpersecond.KibibitsPerSecond).BitsPerSecond, KibibitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromKibibytesPerSecond(bitpersecond.KibibytesPerSecond).BitsPerSecond, KibibytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromKilobitsPerSecond(bitpersecond.KilobitsPerSecond).BitsPerSecond, KilobitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromKilobytesPerSecond(bitpersecond.KilobytesPerSecond).BitsPerSecond, KilobytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromMebibitsPerSecond(bitpersecond.MebibitsPerSecond).BitsPerSecond, MebibitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromMebibytesPerSecond(bitpersecond.MebibytesPerSecond).BitsPerSecond, MebibytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromMegabitsPerSecond(bitpersecond.MegabitsPerSecond).BitsPerSecond, MegabitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromMegabytesPerSecond(bitpersecond.MegabytesPerSecond).BitsPerSecond, MegabytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromPebibitsPerSecond(bitpersecond.PebibitsPerSecond).BitsPerSecond, PebibitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromPebibytesPerSecond(bitpersecond.PebibytesPerSecond).BitsPerSecond, PebibytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromPetabitsPerSecond(bitpersecond.PetabitsPerSecond).BitsPerSecond, PetabitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromPetabytesPerSecond(bitpersecond.PetabytesPerSecond).BitsPerSecond, PetabytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromTebibitsPerSecond(bitpersecond.TebibitsPerSecond).BitsPerSecond, TebibitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromTebibytesPerSecond(bitpersecond.TebibytesPerSecond).BitsPerSecond, TebibytesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromTerabitsPerSecond(bitpersecond.TerabitsPerSecond).BitsPerSecond, TerabitsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, BitRate<double>.FromTerabytesPerSecond(bitpersecond.TerabytesPerSecond).BitsPerSecond, TerabytesPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            BitRate v = BitRate.FromBitsPerSecond(1);
+            BitRate<double> v = BitRate<double>.FromBitsPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (BitRate.FromBitsPerSecond(3)-v).BitsPerSecond, BitsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (BitRate<double>.FromBitsPerSecond(3)-v).BitsPerSecond, BitsPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).BitsPerSecond, BitsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).BitsPerSecond, BitsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (BitRate.FromBitsPerSecond(10)/5).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, BitRate.FromBitsPerSecond(10)/BitRate.FromBitsPerSecond(5), BitsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (BitRate<double>.FromBitsPerSecond(10)/5).BitsPerSecond, BitsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, BitRate<double>.FromBitsPerSecond(10)/BitRate<double>.FromBitsPerSecond(5), BitsPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            BitRate oneBitPerSecond = BitRate.FromBitsPerSecond(1);
-            BitRate twoBitsPerSecond = BitRate.FromBitsPerSecond(2);
+            BitRate<double> oneBitPerSecond = BitRate<double>.FromBitsPerSecond(1);
+            BitRate<double> twoBitsPerSecond = BitRate<double>.FromBitsPerSecond(2);
 
             Assert.True(oneBitPerSecond < twoBitsPerSecond);
             Assert.True(oneBitPerSecond <= twoBitsPerSecond);
@@ -521,31 +521,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
+            BitRate<double> bitpersecond = BitRate<double>.FromBitsPerSecond(1);
             Assert.Equal(0, bitpersecond.CompareTo(bitpersecond));
-            Assert.True(bitpersecond.CompareTo(BitRate.Zero) > 0);
-            Assert.True(BitRate.Zero.CompareTo(bitpersecond) < 0);
+            Assert.True(bitpersecond.CompareTo(BitRate<double>.Zero) > 0);
+            Assert.True(BitRate<double>.Zero.CompareTo(bitpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
+            BitRate<double> bitpersecond = BitRate<double>.FromBitsPerSecond(1);
             Assert.Throws<ArgumentException>(() => bitpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
+            BitRate<double> bitpersecond = BitRate<double>.FromBitsPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => bitpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = BitRate.FromBitsPerSecond(1);
-            var b = BitRate.FromBitsPerSecond(2);
+            var a = BitRate<double>.FromBitsPerSecond(1);
+            var b = BitRate<double>.FromBitsPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -564,8 +564,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = BitRate.FromBitsPerSecond(1);
-            var b = BitRate.FromBitsPerSecond(2);
+            var a = BitRate<double>.FromBitsPerSecond(1);
+            var b = BitRate<double>.FromBitsPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -585,9 +585,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = BitRate.FromBitsPerSecond(1);
-            Assert.True(v.Equals(BitRate.FromBitsPerSecond(1), BitsPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(BitRate.Zero, BitsPerSecondTolerance, ComparisonType.Relative));
+            var v = BitRate<double>.FromBitsPerSecond(1);
+            Assert.True(v.Equals(BitRate<double>.FromBitsPerSecond(1), BitsPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(BitRate<double>.Zero, BitsPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -600,21 +600,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
+            BitRate<double> bitpersecond = BitRate<double>.FromBitsPerSecond(1);
             Assert.False(bitpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
+            BitRate<double> bitpersecond = BitRate<double>.FromBitsPerSecond(1);
             Assert.False(bitpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(BitRateUnit.Undefined, BitRate.Units);
+            Assert.DoesNotContain(BitRateUnit.Undefined, BitRate<double>.Units);
         }
 
         [Fact]
@@ -633,7 +633,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(BitRate.BaseDimensions is null);
+            Assert.False(BitRate<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs
index 30231fa5e2..c058c46a9b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class BrakeSpecificFuelConsumptionTestsBase : QuantityTe
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption((double)0.0, BrakeSpecificFuelConsumptionUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>((double)0.0, BrakeSpecificFuelConsumptionUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption(double.PositiveInfinity, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
-            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption(double.NegativeInfinity, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>(double.PositiveInfinity, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>(double.NegativeInfinity, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption(double.NaN, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
+            Assert.Throws<ArgumentException>(() => new BrakeSpecificFuelConsumption<double>(double.NaN, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void BrakeSpecificFuelConsumption_QuantityInfo_ReturnsQuantityInfoDescrib
         [Fact]
         public void KilogramPerJouleToBrakeSpecificFuelConsumptionUnits()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             AssertEx.EqualTolerance(GramsPerKiloWattHourInOneKilogramPerJoule, kilogramperjoule.GramsPerKiloWattHour, GramsPerKiloWattHourTolerance);
             AssertEx.EqualTolerance(KilogramsPerJouleInOneKilogramPerJoule, kilogramperjoule.KilogramsPerJoule, KilogramsPerJouleTolerance);
             AssertEx.EqualTolerance(PoundsPerMechanicalHorsepowerHourInOneKilogramPerJoule, kilogramperjoule.PoundsPerMechanicalHorsepowerHour, PoundsPerMechanicalHorsepowerHourTolerance);
@@ -127,15 +127,15 @@ public void KilogramPerJouleToBrakeSpecificFuelConsumptionUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = BrakeSpecificFuelConsumption.From(1, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
+            var quantity00 = BrakeSpecificFuelConsumption<double>.From(1, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
             AssertEx.EqualTolerance(1, quantity00.GramsPerKiloWattHour, GramsPerKiloWattHourTolerance);
             Assert.Equal(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, quantity00.Unit);
 
-            var quantity01 = BrakeSpecificFuelConsumption.From(1, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
+            var quantity01 = BrakeSpecificFuelConsumption<double>.From(1, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
             AssertEx.EqualTolerance(1, quantity01.KilogramsPerJoule, KilogramsPerJouleTolerance);
             Assert.Equal(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, quantity01.Unit);
 
-            var quantity02 = BrakeSpecificFuelConsumption.From(1, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
+            var quantity02 = BrakeSpecificFuelConsumption<double>.From(1, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
             AssertEx.EqualTolerance(1, quantity02.PoundsPerMechanicalHorsepowerHour, PoundsPerMechanicalHorsepowerHourTolerance);
             Assert.Equal(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramsPerJoule_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramsPerJoule_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double.NaN));
+            Assert.Throws<ArgumentException>(() => BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            var kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             AssertEx.EqualTolerance(GramsPerKiloWattHourInOneKilogramPerJoule, kilogramperjoule.As(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour), GramsPerKiloWattHourTolerance);
             AssertEx.EqualTolerance(KilogramsPerJouleInOneKilogramPerJoule, kilogramperjoule.As(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule), KilogramsPerJouleTolerance);
             AssertEx.EqualTolerance(PoundsPerMechanicalHorsepowerHourInOneKilogramPerJoule, kilogramperjoule.As(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour), PoundsPerMechanicalHorsepowerHourTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            var kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
 
             var gramperkilowatthourQuantity = kilogramperjoule.ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
             AssertEx.EqualTolerance(GramsPerKiloWattHourInOneKilogramPerJoule, (double)gramperkilowatthourQuantity.Value, GramsPerKiloWattHourTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(kilogramperjoule.GramsPerKiloWattHour).KilogramsPerJoule, GramsPerKiloWattHourTolerance);
-            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(kilogramperjoule.KilogramsPerJoule).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(kilogramperjoule.PoundsPerMechanicalHorsepowerHour).KilogramsPerJoule, PoundsPerMechanicalHorsepowerHourTolerance);
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.FromGramsPerKiloWattHour(kilogramperjoule.GramsPerKiloWattHour).KilogramsPerJoule, GramsPerKiloWattHourTolerance);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(kilogramperjoule.KilogramsPerJoule).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption<double>.FromPoundsPerMechanicalHorsepowerHour(kilogramperjoule.PoundsPerMechanicalHorsepowerHour).KilogramsPerJoule, PoundsPerMechanicalHorsepowerHourTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            BrakeSpecificFuelConsumption v = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> v = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             AssertEx.EqualTolerance(-1, -v.KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption.FromKilogramsPerJoule(3)-v).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(3)-v).KilogramsPerJoule, KilogramsPerJouleTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramsPerJoule, KilogramsPerJouleTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramsPerJoule, KilogramsPerJouleTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10)/5).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(2, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10)/BrakeSpecificFuelConsumption.FromKilogramsPerJoule(5), KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(10)/5).KilogramsPerJoule, KilogramsPerJouleTolerance);
+            AssertEx.EqualTolerance(2, BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(10)/BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(5), KilogramsPerJouleTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            BrakeSpecificFuelConsumption oneKilogramPerJoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            BrakeSpecificFuelConsumption twoKilogramsPerJoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2);
+            BrakeSpecificFuelConsumption<double> oneKilogramPerJoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> twoKilogramsPerJoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(2);
 
             Assert.True(oneKilogramPerJoule < twoKilogramsPerJoule);
             Assert.True(oneKilogramPerJoule <= twoKilogramsPerJoule);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             Assert.Equal(0, kilogramperjoule.CompareTo(kilogramperjoule));
-            Assert.True(kilogramperjoule.CompareTo(BrakeSpecificFuelConsumption.Zero) > 0);
-            Assert.True(BrakeSpecificFuelConsumption.Zero.CompareTo(kilogramperjoule) < 0);
+            Assert.True(kilogramperjoule.CompareTo(BrakeSpecificFuelConsumption<double>.Zero) > 0);
+            Assert.True(BrakeSpecificFuelConsumption<double>.Zero.CompareTo(kilogramperjoule) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             Assert.Throws<ArgumentException>(() => kilogramperjoule.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             Assert.Throws<ArgumentNullException>(() => kilogramperjoule.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            var b = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2);
+            var a = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            var b = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            var b = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2);
+            var a = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            var b = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            Assert.True(v.Equals(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1), KilogramsPerJouleTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(BrakeSpecificFuelConsumption.Zero, KilogramsPerJouleTolerance, ComparisonType.Relative));
+            var v = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
+            Assert.True(v.Equals(BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1), KilogramsPerJouleTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(BrakeSpecificFuelConsumption<double>.Zero, KilogramsPerJouleTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             Assert.False(kilogramperjoule.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
+            BrakeSpecificFuelConsumption<double> kilogramperjoule = BrakeSpecificFuelConsumption<double>.FromKilogramsPerJoule(1);
             Assert.False(kilogramperjoule.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(BrakeSpecificFuelConsumptionUnit.Undefined, BrakeSpecificFuelConsumption.Units);
+            Assert.DoesNotContain(BrakeSpecificFuelConsumptionUnit.Undefined, BrakeSpecificFuelConsumption<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(BrakeSpecificFuelConsumption.BaseDimensions is null);
+            Assert.False(BrakeSpecificFuelConsumption<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CapacitanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CapacitanceTestsBase.g.cs
index 0164f114ac..95dc5e8f3c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/CapacitanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CapacitanceTestsBase.g.cs
@@ -58,7 +58,7 @@ public abstract partial class CapacitanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Capacitance((double)0.0, CapacitanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>((double)0.0, CapacitanceUnit.Undefined));
         }
 
         [Fact]
@@ -73,14 +73,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Capacitance(double.PositiveInfinity, CapacitanceUnit.Farad));
-            Assert.Throws<ArgumentException>(() => new Capacitance(double.NegativeInfinity, CapacitanceUnit.Farad));
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>(double.PositiveInfinity, CapacitanceUnit.Farad));
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>(double.NegativeInfinity, CapacitanceUnit.Farad));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Capacitance(double.NaN, CapacitanceUnit.Farad));
+            Assert.Throws<ArgumentException>(() => new Capacitance<double>(double.NaN, CapacitanceUnit.Farad));
         }
 
         [Fact]
@@ -126,7 +126,7 @@ public void Capacitance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void FaradToCapacitanceUnits()
         {
-            Capacitance farad = Capacitance.FromFarads(1);
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
             AssertEx.EqualTolerance(FaradsInOneFarad, farad.Farads, FaradsTolerance);
             AssertEx.EqualTolerance(KilofaradsInOneFarad, farad.Kilofarads, KilofaradsTolerance);
             AssertEx.EqualTolerance(MegafaradsInOneFarad, farad.Megafarads, MegafaradsTolerance);
@@ -139,31 +139,31 @@ public void FaradToCapacitanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Capacitance.From(1, CapacitanceUnit.Farad);
+            var quantity00 = Capacitance<double>.From(1, CapacitanceUnit.Farad);
             AssertEx.EqualTolerance(1, quantity00.Farads, FaradsTolerance);
             Assert.Equal(CapacitanceUnit.Farad, quantity00.Unit);
 
-            var quantity01 = Capacitance.From(1, CapacitanceUnit.Kilofarad);
+            var quantity01 = Capacitance<double>.From(1, CapacitanceUnit.Kilofarad);
             AssertEx.EqualTolerance(1, quantity01.Kilofarads, KilofaradsTolerance);
             Assert.Equal(CapacitanceUnit.Kilofarad, quantity01.Unit);
 
-            var quantity02 = Capacitance.From(1, CapacitanceUnit.Megafarad);
+            var quantity02 = Capacitance<double>.From(1, CapacitanceUnit.Megafarad);
             AssertEx.EqualTolerance(1, quantity02.Megafarads, MegafaradsTolerance);
             Assert.Equal(CapacitanceUnit.Megafarad, quantity02.Unit);
 
-            var quantity03 = Capacitance.From(1, CapacitanceUnit.Microfarad);
+            var quantity03 = Capacitance<double>.From(1, CapacitanceUnit.Microfarad);
             AssertEx.EqualTolerance(1, quantity03.Microfarads, MicrofaradsTolerance);
             Assert.Equal(CapacitanceUnit.Microfarad, quantity03.Unit);
 
-            var quantity04 = Capacitance.From(1, CapacitanceUnit.Millifarad);
+            var quantity04 = Capacitance<double>.From(1, CapacitanceUnit.Millifarad);
             AssertEx.EqualTolerance(1, quantity04.Millifarads, MillifaradsTolerance);
             Assert.Equal(CapacitanceUnit.Millifarad, quantity04.Unit);
 
-            var quantity05 = Capacitance.From(1, CapacitanceUnit.Nanofarad);
+            var quantity05 = Capacitance<double>.From(1, CapacitanceUnit.Nanofarad);
             AssertEx.EqualTolerance(1, quantity05.Nanofarads, NanofaradsTolerance);
             Assert.Equal(CapacitanceUnit.Nanofarad, quantity05.Unit);
 
-            var quantity06 = Capacitance.From(1, CapacitanceUnit.Picofarad);
+            var quantity06 = Capacitance<double>.From(1, CapacitanceUnit.Picofarad);
             AssertEx.EqualTolerance(1, quantity06.Picofarads, PicofaradsTolerance);
             Assert.Equal(CapacitanceUnit.Picofarad, quantity06.Unit);
 
@@ -172,20 +172,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromFarads_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Capacitance.FromFarads(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Capacitance.FromFarads(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Capacitance<double>.FromFarads(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Capacitance<double>.FromFarads(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromFarads_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Capacitance.FromFarads(double.NaN));
+            Assert.Throws<ArgumentException>(() => Capacitance<double>.FromFarads(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var farad = Capacitance.FromFarads(1);
+            var farad = Capacitance<double>.FromFarads(1);
             AssertEx.EqualTolerance(FaradsInOneFarad, farad.As(CapacitanceUnit.Farad), FaradsTolerance);
             AssertEx.EqualTolerance(KilofaradsInOneFarad, farad.As(CapacitanceUnit.Kilofarad), KilofaradsTolerance);
             AssertEx.EqualTolerance(MegafaradsInOneFarad, farad.As(CapacitanceUnit.Megafarad), MegafaradsTolerance);
@@ -215,7 +215,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var farad = Capacitance.FromFarads(1);
+            var farad = Capacitance<double>.FromFarads(1);
 
             var faradQuantity = farad.ToUnit(CapacitanceUnit.Farad);
             AssertEx.EqualTolerance(FaradsInOneFarad, (double)faradQuantity.Value, FaradsTolerance);
@@ -256,34 +256,34 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Capacitance farad = Capacitance.FromFarads(1);
-            AssertEx.EqualTolerance(1, Capacitance.FromFarads(farad.Farads).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(1, Capacitance.FromKilofarads(farad.Kilofarads).Farads, KilofaradsTolerance);
-            AssertEx.EqualTolerance(1, Capacitance.FromMegafarads(farad.Megafarads).Farads, MegafaradsTolerance);
-            AssertEx.EqualTolerance(1, Capacitance.FromMicrofarads(farad.Microfarads).Farads, MicrofaradsTolerance);
-            AssertEx.EqualTolerance(1, Capacitance.FromMillifarads(farad.Millifarads).Farads, MillifaradsTolerance);
-            AssertEx.EqualTolerance(1, Capacitance.FromNanofarads(farad.Nanofarads).Farads, NanofaradsTolerance);
-            AssertEx.EqualTolerance(1, Capacitance.FromPicofarads(farad.Picofarads).Farads, PicofaradsTolerance);
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromFarads(farad.Farads).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromKilofarads(farad.Kilofarads).Farads, KilofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromMegafarads(farad.Megafarads).Farads, MegafaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromMicrofarads(farad.Microfarads).Farads, MicrofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromMillifarads(farad.Millifarads).Farads, MillifaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromNanofarads(farad.Nanofarads).Farads, NanofaradsTolerance);
+            AssertEx.EqualTolerance(1, Capacitance<double>.FromPicofarads(farad.Picofarads).Farads, PicofaradsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Capacitance v = Capacitance.FromFarads(1);
+            Capacitance<double> v = Capacitance<double>.FromFarads(1);
             AssertEx.EqualTolerance(-1, -v.Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(2, (Capacitance.FromFarads(3)-v).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(2, (Capacitance<double>.FromFarads(3)-v).Farads, FaradsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Farads, FaradsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Farads, FaradsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(2, (Capacitance.FromFarads(10)/5).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(2, Capacitance.FromFarads(10)/Capacitance.FromFarads(5), FaradsTolerance);
+            AssertEx.EqualTolerance(2, (Capacitance<double>.FromFarads(10)/5).Farads, FaradsTolerance);
+            AssertEx.EqualTolerance(2, Capacitance<double>.FromFarads(10)/Capacitance<double>.FromFarads(5), FaradsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Capacitance oneFarad = Capacitance.FromFarads(1);
-            Capacitance twoFarads = Capacitance.FromFarads(2);
+            Capacitance<double> oneFarad = Capacitance<double>.FromFarads(1);
+            Capacitance<double> twoFarads = Capacitance<double>.FromFarads(2);
 
             Assert.True(oneFarad < twoFarads);
             Assert.True(oneFarad <= twoFarads);
@@ -299,31 +299,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Capacitance farad = Capacitance.FromFarads(1);
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
             Assert.Equal(0, farad.CompareTo(farad));
-            Assert.True(farad.CompareTo(Capacitance.Zero) > 0);
-            Assert.True(Capacitance.Zero.CompareTo(farad) < 0);
+            Assert.True(farad.CompareTo(Capacitance<double>.Zero) > 0);
+            Assert.True(Capacitance<double>.Zero.CompareTo(farad) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Capacitance farad = Capacitance.FromFarads(1);
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
             Assert.Throws<ArgumentException>(() => farad.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Capacitance farad = Capacitance.FromFarads(1);
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
             Assert.Throws<ArgumentNullException>(() => farad.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Capacitance.FromFarads(1);
-            var b = Capacitance.FromFarads(2);
+            var a = Capacitance<double>.FromFarads(1);
+            var b = Capacitance<double>.FromFarads(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -342,8 +342,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Capacitance.FromFarads(1);
-            var b = Capacitance.FromFarads(2);
+            var a = Capacitance<double>.FromFarads(1);
+            var b = Capacitance<double>.FromFarads(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -363,9 +363,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Capacitance.FromFarads(1);
-            Assert.True(v.Equals(Capacitance.FromFarads(1), FaradsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Capacitance.Zero, FaradsTolerance, ComparisonType.Relative));
+            var v = Capacitance<double>.FromFarads(1);
+            Assert.True(v.Equals(Capacitance<double>.FromFarads(1), FaradsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Capacitance<double>.Zero, FaradsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -378,21 +378,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Capacitance farad = Capacitance.FromFarads(1);
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
             Assert.False(farad.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Capacitance farad = Capacitance.FromFarads(1);
+            Capacitance<double> farad = Capacitance<double>.FromFarads(1);
             Assert.False(farad.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(CapacitanceUnit.Undefined, Capacitance.Units);
+            Assert.DoesNotContain(CapacitanceUnit.Undefined, Capacitance<double>.Units);
         }
 
         [Fact]
@@ -411,7 +411,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Capacitance.BaseDimensions is null);
+            Assert.False(Capacitance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs
index bb4af39bd0..125dd676c0 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class CoefficientOfThermalExpansionTestsBase : QuantityT
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion((double)0.0, CoefficientOfThermalExpansionUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>((double)0.0, CoefficientOfThermalExpansionUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion(double.PositiveInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin));
-            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion(double.NegativeInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin));
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>(double.PositiveInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin));
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>(double.NegativeInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion(double.NaN, CoefficientOfThermalExpansionUnit.InverseKelvin));
+            Assert.Throws<ArgumentException>(() => new CoefficientOfThermalExpansion<double>(double.NaN, CoefficientOfThermalExpansionUnit.InverseKelvin));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void CoefficientOfThermalExpansion_QuantityInfo_ReturnsQuantityInfoDescri
         [Fact]
         public void InverseKelvinToCoefficientOfThermalExpansionUnits()
         {
-            CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, inversekelvin.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, inversekelvin.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
             AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, inversekelvin.InverseKelvin, InverseKelvinTolerance);
@@ -127,15 +127,15 @@ public void InverseKelvinToCoefficientOfThermalExpansionUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = CoefficientOfThermalExpansion.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
+            var quantity00 = CoefficientOfThermalExpansion<double>.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
             AssertEx.EqualTolerance(1, quantity00.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
             Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, quantity00.Unit);
 
-            var quantity01 = CoefficientOfThermalExpansion.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
+            var quantity01 = CoefficientOfThermalExpansion<double>.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
             AssertEx.EqualTolerance(1, quantity01.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
             Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, quantity01.Unit);
 
-            var quantity02 = CoefficientOfThermalExpansion.From(1, CoefficientOfThermalExpansionUnit.InverseKelvin);
+            var quantity02 = CoefficientOfThermalExpansion<double>.From(1, CoefficientOfThermalExpansionUnit.InverseKelvin);
             AssertEx.EqualTolerance(1, quantity02.InverseKelvin, InverseKelvinTolerance);
             Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromInverseKelvin_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion.FromInverseKelvin(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion.FromInverseKelvin(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion<double>.FromInverseKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion<double>.FromInverseKelvin(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromInverseKelvin_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion.FromInverseKelvin(double.NaN));
+            Assert.Throws<ArgumentException>(() => CoefficientOfThermalExpansion<double>.FromInverseKelvin(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            var inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius), InverseDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit), InverseDegreeFahrenheitTolerance);
             AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseKelvin), InverseKelvinTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            var inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
 
             var inversedegreecelsiusQuantity = inversekelvin.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
             AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, (double)inversedegreecelsiusQuantity.Value, InverseDegreeCelsiusTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromInverseDegreeCelsius(inversekelvin.InverseDegreeCelsius).InverseKelvin, InverseDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(inversekelvin.InverseDegreeFahrenheit).InverseKelvin, InverseDegreeFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromInverseKelvin(inversekelvin.InverseKelvin).InverseKelvin, InverseKelvinTolerance);
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.FromInverseDegreeCelsius(inversekelvin.InverseDegreeCelsius).InverseKelvin, InverseDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.FromInverseDegreeFahrenheit(inversekelvin.InverseDegreeFahrenheit).InverseKelvin, InverseDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion<double>.FromInverseKelvin(inversekelvin.InverseKelvin).InverseKelvin, InverseKelvinTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            CoefficientOfThermalExpansion v = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> v = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             AssertEx.EqualTolerance(-1, -v.InverseKelvin, InverseKelvinTolerance);
-            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion.FromInverseKelvin(3)-v).InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion<double>.FromInverseKelvin(3)-v).InverseKelvin, InverseKelvinTolerance);
             AssertEx.EqualTolerance(2, (v + v).InverseKelvin, InverseKelvinTolerance);
             AssertEx.EqualTolerance(10, (v*10).InverseKelvin, InverseKelvinTolerance);
             AssertEx.EqualTolerance(10, (10*v).InverseKelvin, InverseKelvinTolerance);
-            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion.FromInverseKelvin(10)/5).InverseKelvin, InverseKelvinTolerance);
-            AssertEx.EqualTolerance(2, CoefficientOfThermalExpansion.FromInverseKelvin(10)/CoefficientOfThermalExpansion.FromInverseKelvin(5), InverseKelvinTolerance);
+            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion<double>.FromInverseKelvin(10)/5).InverseKelvin, InverseKelvinTolerance);
+            AssertEx.EqualTolerance(2, CoefficientOfThermalExpansion<double>.FromInverseKelvin(10)/CoefficientOfThermalExpansion<double>.FromInverseKelvin(5), InverseKelvinTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            CoefficientOfThermalExpansion oneInverseKelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
-            CoefficientOfThermalExpansion twoInverseKelvin = CoefficientOfThermalExpansion.FromInverseKelvin(2);
+            CoefficientOfThermalExpansion<double> oneInverseKelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> twoInverseKelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(2);
 
             Assert.True(oneInverseKelvin < twoInverseKelvin);
             Assert.True(oneInverseKelvin <= twoInverseKelvin);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             Assert.Equal(0, inversekelvin.CompareTo(inversekelvin));
-            Assert.True(inversekelvin.CompareTo(CoefficientOfThermalExpansion.Zero) > 0);
-            Assert.True(CoefficientOfThermalExpansion.Zero.CompareTo(inversekelvin) < 0);
+            Assert.True(inversekelvin.CompareTo(CoefficientOfThermalExpansion<double>.Zero) > 0);
+            Assert.True(CoefficientOfThermalExpansion<double>.Zero.CompareTo(inversekelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             Assert.Throws<ArgumentException>(() => inversekelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             Assert.Throws<ArgumentNullException>(() => inversekelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = CoefficientOfThermalExpansion.FromInverseKelvin(1);
-            var b = CoefficientOfThermalExpansion.FromInverseKelvin(2);
+            var a = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            var b = CoefficientOfThermalExpansion<double>.FromInverseKelvin(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = CoefficientOfThermalExpansion.FromInverseKelvin(1);
-            var b = CoefficientOfThermalExpansion.FromInverseKelvin(2);
+            var a = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            var b = CoefficientOfThermalExpansion<double>.FromInverseKelvin(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = CoefficientOfThermalExpansion.FromInverseKelvin(1);
-            Assert.True(v.Equals(CoefficientOfThermalExpansion.FromInverseKelvin(1), InverseKelvinTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(CoefficientOfThermalExpansion.Zero, InverseKelvinTolerance, ComparisonType.Relative));
+            var v = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
+            Assert.True(v.Equals(CoefficientOfThermalExpansion<double>.FromInverseKelvin(1), InverseKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(CoefficientOfThermalExpansion<double>.Zero, InverseKelvinTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             Assert.False(inversekelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
+            CoefficientOfThermalExpansion<double> inversekelvin = CoefficientOfThermalExpansion<double>.FromInverseKelvin(1);
             Assert.False(inversekelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(CoefficientOfThermalExpansionUnit.Undefined, CoefficientOfThermalExpansion.Units);
+            Assert.DoesNotContain(CoefficientOfThermalExpansionUnit.Undefined, CoefficientOfThermalExpansion<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(CoefficientOfThermalExpansion.BaseDimensions is null);
+            Assert.False(CoefficientOfThermalExpansion<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs
index 7940becbfb..650ad6a668 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs
@@ -124,7 +124,7 @@ public abstract partial class DensityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Density((double)0.0, DensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Density<double>((double)0.0, DensityUnit.Undefined));
         }
 
         [Fact]
@@ -139,14 +139,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Density(double.PositiveInfinity, DensityUnit.KilogramPerCubicMeter));
-            Assert.Throws<ArgumentException>(() => new Density(double.NegativeInfinity, DensityUnit.KilogramPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new Density<double>(double.PositiveInfinity, DensityUnit.KilogramPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new Density<double>(double.NegativeInfinity, DensityUnit.KilogramPerCubicMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Density(double.NaN, DensityUnit.KilogramPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new Density<double>(double.NaN, DensityUnit.KilogramPerCubicMeter));
         }
 
         [Fact]
@@ -192,7 +192,7 @@ public void Density_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void KilogramPerCubicMeterToDensityUnits()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            Density<double> kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
             AssertEx.EqualTolerance(CentigramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerDeciLiter, CentigramsPerDeciLiterTolerance);
             AssertEx.EqualTolerance(CentigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerLiter, CentigramsPerLiterTolerance);
             AssertEx.EqualTolerance(CentigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerMilliliter, CentigramsPerMilliliterTolerance);
@@ -238,163 +238,163 @@ public void KilogramPerCubicMeterToDensityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Density.From(1, DensityUnit.CentigramPerDeciliter);
+            var quantity00 = Density<double>.From(1, DensityUnit.CentigramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity00.CentigramsPerDeciLiter, CentigramsPerDeciLiterTolerance);
             Assert.Equal(DensityUnit.CentigramPerDeciliter, quantity00.Unit);
 
-            var quantity01 = Density.From(1, DensityUnit.CentigramPerLiter);
+            var quantity01 = Density<double>.From(1, DensityUnit.CentigramPerLiter);
             AssertEx.EqualTolerance(1, quantity01.CentigramsPerLiter, CentigramsPerLiterTolerance);
             Assert.Equal(DensityUnit.CentigramPerLiter, quantity01.Unit);
 
-            var quantity02 = Density.From(1, DensityUnit.CentigramPerMilliliter);
+            var quantity02 = Density<double>.From(1, DensityUnit.CentigramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity02.CentigramsPerMilliliter, CentigramsPerMilliliterTolerance);
             Assert.Equal(DensityUnit.CentigramPerMilliliter, quantity02.Unit);
 
-            var quantity03 = Density.From(1, DensityUnit.DecigramPerDeciliter);
+            var quantity03 = Density<double>.From(1, DensityUnit.DecigramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity03.DecigramsPerDeciLiter, DecigramsPerDeciLiterTolerance);
             Assert.Equal(DensityUnit.DecigramPerDeciliter, quantity03.Unit);
 
-            var quantity04 = Density.From(1, DensityUnit.DecigramPerLiter);
+            var quantity04 = Density<double>.From(1, DensityUnit.DecigramPerLiter);
             AssertEx.EqualTolerance(1, quantity04.DecigramsPerLiter, DecigramsPerLiterTolerance);
             Assert.Equal(DensityUnit.DecigramPerLiter, quantity04.Unit);
 
-            var quantity05 = Density.From(1, DensityUnit.DecigramPerMilliliter);
+            var quantity05 = Density<double>.From(1, DensityUnit.DecigramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity05.DecigramsPerMilliliter, DecigramsPerMilliliterTolerance);
             Assert.Equal(DensityUnit.DecigramPerMilliliter, quantity05.Unit);
 
-            var quantity06 = Density.From(1, DensityUnit.GramPerCubicCentimeter);
+            var quantity06 = Density<double>.From(1, DensityUnit.GramPerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity06.GramsPerCubicCentimeter, GramsPerCubicCentimeterTolerance);
             Assert.Equal(DensityUnit.GramPerCubicCentimeter, quantity06.Unit);
 
-            var quantity07 = Density.From(1, DensityUnit.GramPerCubicMeter);
+            var quantity07 = Density<double>.From(1, DensityUnit.GramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity07.GramsPerCubicMeter, GramsPerCubicMeterTolerance);
             Assert.Equal(DensityUnit.GramPerCubicMeter, quantity07.Unit);
 
-            var quantity08 = Density.From(1, DensityUnit.GramPerCubicMillimeter);
+            var quantity08 = Density<double>.From(1, DensityUnit.GramPerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity08.GramsPerCubicMillimeter, GramsPerCubicMillimeterTolerance);
             Assert.Equal(DensityUnit.GramPerCubicMillimeter, quantity08.Unit);
 
-            var quantity09 = Density.From(1, DensityUnit.GramPerDeciliter);
+            var quantity09 = Density<double>.From(1, DensityUnit.GramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity09.GramsPerDeciLiter, GramsPerDeciLiterTolerance);
             Assert.Equal(DensityUnit.GramPerDeciliter, quantity09.Unit);
 
-            var quantity10 = Density.From(1, DensityUnit.GramPerLiter);
+            var quantity10 = Density<double>.From(1, DensityUnit.GramPerLiter);
             AssertEx.EqualTolerance(1, quantity10.GramsPerLiter, GramsPerLiterTolerance);
             Assert.Equal(DensityUnit.GramPerLiter, quantity10.Unit);
 
-            var quantity11 = Density.From(1, DensityUnit.GramPerMilliliter);
+            var quantity11 = Density<double>.From(1, DensityUnit.GramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity11.GramsPerMilliliter, GramsPerMilliliterTolerance);
             Assert.Equal(DensityUnit.GramPerMilliliter, quantity11.Unit);
 
-            var quantity12 = Density.From(1, DensityUnit.KilogramPerCubicCentimeter);
+            var quantity12 = Density<double>.From(1, DensityUnit.KilogramPerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity12.KilogramsPerCubicCentimeter, KilogramsPerCubicCentimeterTolerance);
             Assert.Equal(DensityUnit.KilogramPerCubicCentimeter, quantity12.Unit);
 
-            var quantity13 = Density.From(1, DensityUnit.KilogramPerCubicMeter);
+            var quantity13 = Density<double>.From(1, DensityUnit.KilogramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity13.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             Assert.Equal(DensityUnit.KilogramPerCubicMeter, quantity13.Unit);
 
-            var quantity14 = Density.From(1, DensityUnit.KilogramPerCubicMillimeter);
+            var quantity14 = Density<double>.From(1, DensityUnit.KilogramPerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity14.KilogramsPerCubicMillimeter, KilogramsPerCubicMillimeterTolerance);
             Assert.Equal(DensityUnit.KilogramPerCubicMillimeter, quantity14.Unit);
 
-            var quantity15 = Density.From(1, DensityUnit.KilogramPerLiter);
+            var quantity15 = Density<double>.From(1, DensityUnit.KilogramPerLiter);
             AssertEx.EqualTolerance(1, quantity15.KilogramsPerLiter, KilogramsPerLiterTolerance);
             Assert.Equal(DensityUnit.KilogramPerLiter, quantity15.Unit);
 
-            var quantity16 = Density.From(1, DensityUnit.KilopoundPerCubicFoot);
+            var quantity16 = Density<double>.From(1, DensityUnit.KilopoundPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity16.KilopoundsPerCubicFoot, KilopoundsPerCubicFootTolerance);
             Assert.Equal(DensityUnit.KilopoundPerCubicFoot, quantity16.Unit);
 
-            var quantity17 = Density.From(1, DensityUnit.KilopoundPerCubicInch);
+            var quantity17 = Density<double>.From(1, DensityUnit.KilopoundPerCubicInch);
             AssertEx.EqualTolerance(1, quantity17.KilopoundsPerCubicInch, KilopoundsPerCubicInchTolerance);
             Assert.Equal(DensityUnit.KilopoundPerCubicInch, quantity17.Unit);
 
-            var quantity18 = Density.From(1, DensityUnit.MicrogramPerCubicMeter);
+            var quantity18 = Density<double>.From(1, DensityUnit.MicrogramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity18.MicrogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
             Assert.Equal(DensityUnit.MicrogramPerCubicMeter, quantity18.Unit);
 
-            var quantity19 = Density.From(1, DensityUnit.MicrogramPerDeciliter);
+            var quantity19 = Density<double>.From(1, DensityUnit.MicrogramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity19.MicrogramsPerDeciLiter, MicrogramsPerDeciLiterTolerance);
             Assert.Equal(DensityUnit.MicrogramPerDeciliter, quantity19.Unit);
 
-            var quantity20 = Density.From(1, DensityUnit.MicrogramPerLiter);
+            var quantity20 = Density<double>.From(1, DensityUnit.MicrogramPerLiter);
             AssertEx.EqualTolerance(1, quantity20.MicrogramsPerLiter, MicrogramsPerLiterTolerance);
             Assert.Equal(DensityUnit.MicrogramPerLiter, quantity20.Unit);
 
-            var quantity21 = Density.From(1, DensityUnit.MicrogramPerMilliliter);
+            var quantity21 = Density<double>.From(1, DensityUnit.MicrogramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity21.MicrogramsPerMilliliter, MicrogramsPerMilliliterTolerance);
             Assert.Equal(DensityUnit.MicrogramPerMilliliter, quantity21.Unit);
 
-            var quantity22 = Density.From(1, DensityUnit.MilligramPerCubicMeter);
+            var quantity22 = Density<double>.From(1, DensityUnit.MilligramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity22.MilligramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
             Assert.Equal(DensityUnit.MilligramPerCubicMeter, quantity22.Unit);
 
-            var quantity23 = Density.From(1, DensityUnit.MilligramPerDeciliter);
+            var quantity23 = Density<double>.From(1, DensityUnit.MilligramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity23.MilligramsPerDeciLiter, MilligramsPerDeciLiterTolerance);
             Assert.Equal(DensityUnit.MilligramPerDeciliter, quantity23.Unit);
 
-            var quantity24 = Density.From(1, DensityUnit.MilligramPerLiter);
+            var quantity24 = Density<double>.From(1, DensityUnit.MilligramPerLiter);
             AssertEx.EqualTolerance(1, quantity24.MilligramsPerLiter, MilligramsPerLiterTolerance);
             Assert.Equal(DensityUnit.MilligramPerLiter, quantity24.Unit);
 
-            var quantity25 = Density.From(1, DensityUnit.MilligramPerMilliliter);
+            var quantity25 = Density<double>.From(1, DensityUnit.MilligramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity25.MilligramsPerMilliliter, MilligramsPerMilliliterTolerance);
             Assert.Equal(DensityUnit.MilligramPerMilliliter, quantity25.Unit);
 
-            var quantity26 = Density.From(1, DensityUnit.NanogramPerDeciliter);
+            var quantity26 = Density<double>.From(1, DensityUnit.NanogramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity26.NanogramsPerDeciLiter, NanogramsPerDeciLiterTolerance);
             Assert.Equal(DensityUnit.NanogramPerDeciliter, quantity26.Unit);
 
-            var quantity27 = Density.From(1, DensityUnit.NanogramPerLiter);
+            var quantity27 = Density<double>.From(1, DensityUnit.NanogramPerLiter);
             AssertEx.EqualTolerance(1, quantity27.NanogramsPerLiter, NanogramsPerLiterTolerance);
             Assert.Equal(DensityUnit.NanogramPerLiter, quantity27.Unit);
 
-            var quantity28 = Density.From(1, DensityUnit.NanogramPerMilliliter);
+            var quantity28 = Density<double>.From(1, DensityUnit.NanogramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity28.NanogramsPerMilliliter, NanogramsPerMilliliterTolerance);
             Assert.Equal(DensityUnit.NanogramPerMilliliter, quantity28.Unit);
 
-            var quantity29 = Density.From(1, DensityUnit.PicogramPerDeciliter);
+            var quantity29 = Density<double>.From(1, DensityUnit.PicogramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity29.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance);
             Assert.Equal(DensityUnit.PicogramPerDeciliter, quantity29.Unit);
 
-            var quantity30 = Density.From(1, DensityUnit.PicogramPerLiter);
+            var quantity30 = Density<double>.From(1, DensityUnit.PicogramPerLiter);
             AssertEx.EqualTolerance(1, quantity30.PicogramsPerLiter, PicogramsPerLiterTolerance);
             Assert.Equal(DensityUnit.PicogramPerLiter, quantity30.Unit);
 
-            var quantity31 = Density.From(1, DensityUnit.PicogramPerMilliliter);
+            var quantity31 = Density<double>.From(1, DensityUnit.PicogramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity31.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance);
             Assert.Equal(DensityUnit.PicogramPerMilliliter, quantity31.Unit);
 
-            var quantity32 = Density.From(1, DensityUnit.PoundPerCubicFoot);
+            var quantity32 = Density<double>.From(1, DensityUnit.PoundPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity32.PoundsPerCubicFoot, PoundsPerCubicFootTolerance);
             Assert.Equal(DensityUnit.PoundPerCubicFoot, quantity32.Unit);
 
-            var quantity33 = Density.From(1, DensityUnit.PoundPerCubicInch);
+            var quantity33 = Density<double>.From(1, DensityUnit.PoundPerCubicInch);
             AssertEx.EqualTolerance(1, quantity33.PoundsPerCubicInch, PoundsPerCubicInchTolerance);
             Assert.Equal(DensityUnit.PoundPerCubicInch, quantity33.Unit);
 
-            var quantity34 = Density.From(1, DensityUnit.PoundPerImperialGallon);
+            var quantity34 = Density<double>.From(1, DensityUnit.PoundPerImperialGallon);
             AssertEx.EqualTolerance(1, quantity34.PoundsPerImperialGallon, PoundsPerImperialGallonTolerance);
             Assert.Equal(DensityUnit.PoundPerImperialGallon, quantity34.Unit);
 
-            var quantity35 = Density.From(1, DensityUnit.PoundPerUSGallon);
+            var quantity35 = Density<double>.From(1, DensityUnit.PoundPerUSGallon);
             AssertEx.EqualTolerance(1, quantity35.PoundsPerUSGallon, PoundsPerUSGallonTolerance);
             Assert.Equal(DensityUnit.PoundPerUSGallon, quantity35.Unit);
 
-            var quantity36 = Density.From(1, DensityUnit.SlugPerCubicFoot);
+            var quantity36 = Density<double>.From(1, DensityUnit.SlugPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity36.SlugsPerCubicFoot, SlugsPerCubicFootTolerance);
             Assert.Equal(DensityUnit.SlugPerCubicFoot, quantity36.Unit);
 
-            var quantity37 = Density.From(1, DensityUnit.TonnePerCubicCentimeter);
+            var quantity37 = Density<double>.From(1, DensityUnit.TonnePerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity37.TonnesPerCubicCentimeter, TonnesPerCubicCentimeterTolerance);
             Assert.Equal(DensityUnit.TonnePerCubicCentimeter, quantity37.Unit);
 
-            var quantity38 = Density.From(1, DensityUnit.TonnePerCubicMeter);
+            var quantity38 = Density<double>.From(1, DensityUnit.TonnePerCubicMeter);
             AssertEx.EqualTolerance(1, quantity38.TonnesPerCubicMeter, TonnesPerCubicMeterTolerance);
             Assert.Equal(DensityUnit.TonnePerCubicMeter, quantity38.Unit);
 
-            var quantity39 = Density.From(1, DensityUnit.TonnePerCubicMillimeter);
+            var quantity39 = Density<double>.From(1, DensityUnit.TonnePerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity39.TonnesPerCubicMillimeter, TonnesPerCubicMillimeterTolerance);
             Assert.Equal(DensityUnit.TonnePerCubicMillimeter, quantity39.Unit);
 
@@ -403,20 +403,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramsPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Density.FromKilogramsPerCubicMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Density.FromKilogramsPerCubicMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Density<double>.FromKilogramsPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Density<double>.FromKilogramsPerCubicMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramsPerCubicMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Density.FromKilogramsPerCubicMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => Density<double>.FromKilogramsPerCubicMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            var kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
             AssertEx.EqualTolerance(CentigramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.CentigramPerDeciliter), CentigramsPerDeciLiterTolerance);
             AssertEx.EqualTolerance(CentigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.CentigramPerLiter), CentigramsPerLiterTolerance);
             AssertEx.EqualTolerance(CentigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.CentigramPerMilliliter), CentigramsPerMilliliterTolerance);
@@ -479,7 +479,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            var kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
 
             var centigramperdeciliterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.CentigramPerDeciliter);
             AssertEx.EqualTolerance(CentigramsPerDeciLiterInOneKilogramPerCubicMeter, (double)centigramperdeciliterQuantity.Value, CentigramsPerDeciLiterTolerance);
@@ -652,67 +652,67 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, Density.FromCentigramsPerDeciLiter(kilogrampercubicmeter.CentigramsPerDeciLiter).KilogramsPerCubicMeter, CentigramsPerDeciLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter, CentigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter, CentigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromDecigramsPerDeciLiter(kilogrampercubicmeter.DecigramsPerDeciLiter).KilogramsPerCubicMeter, DecigramsPerDeciLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerDeciLiter(kilogrampercubicmeter.GramsPerDeciLiter).KilogramsPerCubicMeter, GramsPerDeciLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter, GramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter, GramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter, KilogramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter, KilogramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter, KilogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter, KilopoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter, KilopoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerDeciLiter(kilogrampercubicmeter.MicrogramsPerDeciLiter).KilogramsPerCubicMeter, MicrogramsPerDeciLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter, MicrogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter, MicrogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerDeciLiter(kilogrampercubicmeter.MilligramsPerDeciLiter).KilogramsPerCubicMeter, MilligramsPerDeciLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter, MilligramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter, MilligramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromNanogramsPerDeciLiter(kilogrampercubicmeter.NanogramsPerDeciLiter).KilogramsPerCubicMeter, NanogramsPerDeciLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPicogramsPerDeciLiter(kilogrampercubicmeter.PicogramsPerDeciLiter).KilogramsPerCubicMeter, PicogramsPerDeciLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter, PoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter, PoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter, PoundsPerImperialGallonTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter, PoundsPerUSGallonTolerance);
-            AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter, SlugsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter, TonnesPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter, TonnesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter, TonnesPerCubicMillimeterTolerance);
+            Density<double> kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, Density<double>.FromCentigramsPerDeciLiter(kilogrampercubicmeter.CentigramsPerDeciLiter).KilogramsPerCubicMeter, CentigramsPerDeciLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter, CentigramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter, CentigramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromDecigramsPerDeciLiter(kilogrampercubicmeter.DecigramsPerDeciLiter).KilogramsPerCubicMeter, DecigramsPerDeciLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromGramsPerDeciLiter(kilogrampercubicmeter.GramsPerDeciLiter).KilogramsPerCubicMeter, GramsPerDeciLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter, GramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter, GramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter, KilogramsPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter, KilogramsPerCubicMillimeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter, KilogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter, KilopoundsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter, KilopoundsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMicrogramsPerDeciLiter(kilogrampercubicmeter.MicrogramsPerDeciLiter).KilogramsPerCubicMeter, MicrogramsPerDeciLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter, MicrogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter, MicrogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMilligramsPerDeciLiter(kilogrampercubicmeter.MilligramsPerDeciLiter).KilogramsPerCubicMeter, MilligramsPerDeciLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter, MilligramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter, MilligramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromNanogramsPerDeciLiter(kilogrampercubicmeter.NanogramsPerDeciLiter).KilogramsPerCubicMeter, NanogramsPerDeciLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromPicogramsPerDeciLiter(kilogrampercubicmeter.PicogramsPerDeciLiter).KilogramsPerCubicMeter, PicogramsPerDeciLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter, PoundsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter, PoundsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter, PoundsPerImperialGallonTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter, PoundsPerUSGallonTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter, SlugsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter, TonnesPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter, TonnesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Density<double>.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter, TonnesPerCubicMillimeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Density v = Density.FromKilogramsPerCubicMeter(1);
+            Density<double> v = Density<double>.FromKilogramsPerCubicMeter(1);
             AssertEx.EqualTolerance(-1, -v.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Density.FromKilogramsPerCubicMeter(3)-v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (Density<double>.FromKilogramsPerCubicMeter(3)-v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Density.FromKilogramsPerCubicMeter(10)/5).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, Density.FromKilogramsPerCubicMeter(10)/Density.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (Density<double>.FromKilogramsPerCubicMeter(10)/5).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, Density<double>.FromKilogramsPerCubicMeter(10)/Density<double>.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Density oneKilogramPerCubicMeter = Density.FromKilogramsPerCubicMeter(1);
-            Density twoKilogramsPerCubicMeter = Density.FromKilogramsPerCubicMeter(2);
+            Density<double> oneKilogramPerCubicMeter = Density<double>.FromKilogramsPerCubicMeter(1);
+            Density<double> twoKilogramsPerCubicMeter = Density<double>.FromKilogramsPerCubicMeter(2);
 
             Assert.True(oneKilogramPerCubicMeter < twoKilogramsPerCubicMeter);
             Assert.True(oneKilogramPerCubicMeter <= twoKilogramsPerCubicMeter);
@@ -728,31 +728,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            Density<double> kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
             Assert.Equal(0, kilogrampercubicmeter.CompareTo(kilogrampercubicmeter));
-            Assert.True(kilogrampercubicmeter.CompareTo(Density.Zero) > 0);
-            Assert.True(Density.Zero.CompareTo(kilogrampercubicmeter) < 0);
+            Assert.True(kilogrampercubicmeter.CompareTo(Density<double>.Zero) > 0);
+            Assert.True(Density<double>.Zero.CompareTo(kilogrampercubicmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            Density<double> kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
             Assert.Throws<ArgumentException>(() => kilogrampercubicmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            Density<double> kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
             Assert.Throws<ArgumentNullException>(() => kilogrampercubicmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Density.FromKilogramsPerCubicMeter(1);
-            var b = Density.FromKilogramsPerCubicMeter(2);
+            var a = Density<double>.FromKilogramsPerCubicMeter(1);
+            var b = Density<double>.FromKilogramsPerCubicMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -771,8 +771,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Density.FromKilogramsPerCubicMeter(1);
-            var b = Density.FromKilogramsPerCubicMeter(2);
+            var a = Density<double>.FromKilogramsPerCubicMeter(1);
+            var b = Density<double>.FromKilogramsPerCubicMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -792,9 +792,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Density.FromKilogramsPerCubicMeter(1);
-            Assert.True(v.Equals(Density.FromKilogramsPerCubicMeter(1), KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Density.Zero, KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
+            var v = Density<double>.FromKilogramsPerCubicMeter(1);
+            Assert.True(v.Equals(Density<double>.FromKilogramsPerCubicMeter(1), KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Density<double>.Zero, KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -807,21 +807,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            Density<double> kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
             Assert.False(kilogrampercubicmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
+            Density<double> kilogrampercubicmeter = Density<double>.FromKilogramsPerCubicMeter(1);
             Assert.False(kilogrampercubicmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(DensityUnit.Undefined, Density.Units);
+            Assert.DoesNotContain(DensityUnit.Undefined, Density<double>.Units);
         }
 
         [Fact]
@@ -840,7 +840,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Density.BaseDimensions is null);
+            Assert.False(Density<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs
index 567c3a8500..a02cb9de10 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs
@@ -64,7 +64,7 @@ public abstract partial class DurationTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Duration((double)0.0, DurationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Duration<double>((double)0.0, DurationUnit.Undefined));
         }
 
         [Fact]
@@ -79,14 +79,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Duration(double.PositiveInfinity, DurationUnit.Second));
-            Assert.Throws<ArgumentException>(() => new Duration(double.NegativeInfinity, DurationUnit.Second));
+            Assert.Throws<ArgumentException>(() => new Duration<double>(double.PositiveInfinity, DurationUnit.Second));
+            Assert.Throws<ArgumentException>(() => new Duration<double>(double.NegativeInfinity, DurationUnit.Second));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Duration(double.NaN, DurationUnit.Second));
+            Assert.Throws<ArgumentException>(() => new Duration<double>(double.NaN, DurationUnit.Second));
         }
 
         [Fact]
@@ -132,7 +132,7 @@ public void Duration_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void SecondToDurationUnits()
         {
-            Duration second = Duration.FromSeconds(1);
+            Duration<double> second = Duration<double>.FromSeconds(1);
             AssertEx.EqualTolerance(DaysInOneSecond, second.Days, DaysTolerance);
             AssertEx.EqualTolerance(HoursInOneSecond, second.Hours, HoursTolerance);
             AssertEx.EqualTolerance(MicrosecondsInOneSecond, second.Microseconds, MicrosecondsTolerance);
@@ -148,43 +148,43 @@ public void SecondToDurationUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Duration.From(1, DurationUnit.Day);
+            var quantity00 = Duration<double>.From(1, DurationUnit.Day);
             AssertEx.EqualTolerance(1, quantity00.Days, DaysTolerance);
             Assert.Equal(DurationUnit.Day, quantity00.Unit);
 
-            var quantity01 = Duration.From(1, DurationUnit.Hour);
+            var quantity01 = Duration<double>.From(1, DurationUnit.Hour);
             AssertEx.EqualTolerance(1, quantity01.Hours, HoursTolerance);
             Assert.Equal(DurationUnit.Hour, quantity01.Unit);
 
-            var quantity02 = Duration.From(1, DurationUnit.Microsecond);
+            var quantity02 = Duration<double>.From(1, DurationUnit.Microsecond);
             AssertEx.EqualTolerance(1, quantity02.Microseconds, MicrosecondsTolerance);
             Assert.Equal(DurationUnit.Microsecond, quantity02.Unit);
 
-            var quantity03 = Duration.From(1, DurationUnit.Millisecond);
+            var quantity03 = Duration<double>.From(1, DurationUnit.Millisecond);
             AssertEx.EqualTolerance(1, quantity03.Milliseconds, MillisecondsTolerance);
             Assert.Equal(DurationUnit.Millisecond, quantity03.Unit);
 
-            var quantity04 = Duration.From(1, DurationUnit.Minute);
+            var quantity04 = Duration<double>.From(1, DurationUnit.Minute);
             AssertEx.EqualTolerance(1, quantity04.Minutes, MinutesTolerance);
             Assert.Equal(DurationUnit.Minute, quantity04.Unit);
 
-            var quantity05 = Duration.From(1, DurationUnit.Month30);
+            var quantity05 = Duration<double>.From(1, DurationUnit.Month30);
             AssertEx.EqualTolerance(1, quantity05.Months30, Months30Tolerance);
             Assert.Equal(DurationUnit.Month30, quantity05.Unit);
 
-            var quantity06 = Duration.From(1, DurationUnit.Nanosecond);
+            var quantity06 = Duration<double>.From(1, DurationUnit.Nanosecond);
             AssertEx.EqualTolerance(1, quantity06.Nanoseconds, NanosecondsTolerance);
             Assert.Equal(DurationUnit.Nanosecond, quantity06.Unit);
 
-            var quantity07 = Duration.From(1, DurationUnit.Second);
+            var quantity07 = Duration<double>.From(1, DurationUnit.Second);
             AssertEx.EqualTolerance(1, quantity07.Seconds, SecondsTolerance);
             Assert.Equal(DurationUnit.Second, quantity07.Unit);
 
-            var quantity08 = Duration.From(1, DurationUnit.Week);
+            var quantity08 = Duration<double>.From(1, DurationUnit.Week);
             AssertEx.EqualTolerance(1, quantity08.Weeks, WeeksTolerance);
             Assert.Equal(DurationUnit.Week, quantity08.Unit);
 
-            var quantity09 = Duration.From(1, DurationUnit.Year365);
+            var quantity09 = Duration<double>.From(1, DurationUnit.Year365);
             AssertEx.EqualTolerance(1, quantity09.Years365, Years365Tolerance);
             Assert.Equal(DurationUnit.Year365, quantity09.Unit);
 
@@ -193,20 +193,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSeconds_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Duration.FromSeconds(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Duration.FromSeconds(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Duration<double>.FromSeconds(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Duration<double>.FromSeconds(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSeconds_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Duration.FromSeconds(double.NaN));
+            Assert.Throws<ArgumentException>(() => Duration<double>.FromSeconds(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var second = Duration.FromSeconds(1);
+            var second = Duration<double>.FromSeconds(1);
             AssertEx.EqualTolerance(DaysInOneSecond, second.As(DurationUnit.Day), DaysTolerance);
             AssertEx.EqualTolerance(HoursInOneSecond, second.As(DurationUnit.Hour), HoursTolerance);
             AssertEx.EqualTolerance(MicrosecondsInOneSecond, second.As(DurationUnit.Microsecond), MicrosecondsTolerance);
@@ -239,7 +239,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var second = Duration.FromSeconds(1);
+            var second = Duration<double>.FromSeconds(1);
 
             var dayQuantity = second.ToUnit(DurationUnit.Day);
             AssertEx.EqualTolerance(DaysInOneSecond, (double)dayQuantity.Value, DaysTolerance);
@@ -292,37 +292,37 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Duration second = Duration.FromSeconds(1);
-            AssertEx.EqualTolerance(1, Duration.FromDays(second.Days).Seconds, DaysTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromHours(second.Hours).Seconds, HoursTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMicroseconds(second.Microseconds).Seconds, MicrosecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMilliseconds(second.Milliseconds).Seconds, MillisecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMinutes(second.Minutes).Seconds, MinutesTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMonths30(second.Months30).Seconds, Months30Tolerance);
-            AssertEx.EqualTolerance(1, Duration.FromNanoseconds(second.Nanoseconds).Seconds, NanosecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromSeconds(second.Seconds).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromWeeks(second.Weeks).Seconds, WeeksTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromYears365(second.Years365).Seconds, Years365Tolerance);
+            Duration<double> second = Duration<double>.FromSeconds(1);
+            AssertEx.EqualTolerance(1, Duration<double>.FromDays(second.Days).Seconds, DaysTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromHours(second.Hours).Seconds, HoursTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMicroseconds(second.Microseconds).Seconds, MicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMilliseconds(second.Milliseconds).Seconds, MillisecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMinutes(second.Minutes).Seconds, MinutesTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromMonths30(second.Months30).Seconds, Months30Tolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromNanoseconds(second.Nanoseconds).Seconds, NanosecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromSeconds(second.Seconds).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromWeeks(second.Weeks).Seconds, WeeksTolerance);
+            AssertEx.EqualTolerance(1, Duration<double>.FromYears365(second.Years365).Seconds, Years365Tolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Duration v = Duration.FromSeconds(1);
+            Duration<double> v = Duration<double>.FromSeconds(1);
             AssertEx.EqualTolerance(-1, -v.Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(2, (Duration.FromSeconds(3)-v).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(2, (Duration<double>.FromSeconds(3)-v).Seconds, SecondsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Seconds, SecondsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Seconds, SecondsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(2, (Duration.FromSeconds(10)/5).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(2, Duration.FromSeconds(10)/Duration.FromSeconds(5), SecondsTolerance);
+            AssertEx.EqualTolerance(2, (Duration<double>.FromSeconds(10)/5).Seconds, SecondsTolerance);
+            AssertEx.EqualTolerance(2, Duration<double>.FromSeconds(10)/Duration<double>.FromSeconds(5), SecondsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Duration oneSecond = Duration.FromSeconds(1);
-            Duration twoSeconds = Duration.FromSeconds(2);
+            Duration<double> oneSecond = Duration<double>.FromSeconds(1);
+            Duration<double> twoSeconds = Duration<double>.FromSeconds(2);
 
             Assert.True(oneSecond < twoSeconds);
             Assert.True(oneSecond <= twoSeconds);
@@ -338,31 +338,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Duration second = Duration.FromSeconds(1);
+            Duration<double> second = Duration<double>.FromSeconds(1);
             Assert.Equal(0, second.CompareTo(second));
-            Assert.True(second.CompareTo(Duration.Zero) > 0);
-            Assert.True(Duration.Zero.CompareTo(second) < 0);
+            Assert.True(second.CompareTo(Duration<double>.Zero) > 0);
+            Assert.True(Duration<double>.Zero.CompareTo(second) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Duration second = Duration.FromSeconds(1);
+            Duration<double> second = Duration<double>.FromSeconds(1);
             Assert.Throws<ArgumentException>(() => second.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Duration second = Duration.FromSeconds(1);
+            Duration<double> second = Duration<double>.FromSeconds(1);
             Assert.Throws<ArgumentNullException>(() => second.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Duration.FromSeconds(1);
-            var b = Duration.FromSeconds(2);
+            var a = Duration<double>.FromSeconds(1);
+            var b = Duration<double>.FromSeconds(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -381,8 +381,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Duration.FromSeconds(1);
-            var b = Duration.FromSeconds(2);
+            var a = Duration<double>.FromSeconds(1);
+            var b = Duration<double>.FromSeconds(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -402,9 +402,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Duration.FromSeconds(1);
-            Assert.True(v.Equals(Duration.FromSeconds(1), SecondsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Duration.Zero, SecondsTolerance, ComparisonType.Relative));
+            var v = Duration<double>.FromSeconds(1);
+            Assert.True(v.Equals(Duration<double>.FromSeconds(1), SecondsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Duration<double>.Zero, SecondsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -417,21 +417,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Duration second = Duration.FromSeconds(1);
+            Duration<double> second = Duration<double>.FromSeconds(1);
             Assert.False(second.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Duration second = Duration.FromSeconds(1);
+            Duration<double> second = Duration<double>.FromSeconds(1);
             Assert.False(second.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(DurationUnit.Undefined, Duration.Units);
+            Assert.DoesNotContain(DurationUnit.Undefined, Duration<double>.Units);
         }
 
         [Fact]
@@ -450,7 +450,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Duration.BaseDimensions is null);
+            Assert.False(Duration<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs
index 2bc9f438bc..ff70927e93 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs
@@ -64,7 +64,7 @@ public abstract partial class DynamicViscosityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new DynamicViscosity((double)0.0, DynamicViscosityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>((double)0.0, DynamicViscosityUnit.Undefined));
         }
 
         [Fact]
@@ -79,14 +79,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new DynamicViscosity(double.PositiveInfinity, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            Assert.Throws<ArgumentException>(() => new DynamicViscosity(double.NegativeInfinity, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>(double.PositiveInfinity, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>(double.NegativeInfinity, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new DynamicViscosity(double.NaN, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
+            Assert.Throws<ArgumentException>(() => new DynamicViscosity<double>(double.NaN, DynamicViscosityUnit.NewtonSecondPerMeterSquared));
         }
 
         [Fact]
@@ -132,7 +132,7 @@ public void DynamicViscosity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
         [Fact]
         public void NewtonSecondPerMeterSquaredToDynamicViscosityUnits()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             AssertEx.EqualTolerance(CentipoiseInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.Centipoise, CentipoiseTolerance);
             AssertEx.EqualTolerance(MicropascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.MicropascalSeconds, MicropascalSecondsTolerance);
             AssertEx.EqualTolerance(MillipascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.MillipascalSeconds, MillipascalSecondsTolerance);
@@ -148,43 +148,43 @@ public void NewtonSecondPerMeterSquaredToDynamicViscosityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = DynamicViscosity.From(1, DynamicViscosityUnit.Centipoise);
+            var quantity00 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.Centipoise);
             AssertEx.EqualTolerance(1, quantity00.Centipoise, CentipoiseTolerance);
             Assert.Equal(DynamicViscosityUnit.Centipoise, quantity00.Unit);
 
-            var quantity01 = DynamicViscosity.From(1, DynamicViscosityUnit.MicropascalSecond);
+            var quantity01 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.MicropascalSecond);
             AssertEx.EqualTolerance(1, quantity01.MicropascalSeconds, MicropascalSecondsTolerance);
             Assert.Equal(DynamicViscosityUnit.MicropascalSecond, quantity01.Unit);
 
-            var quantity02 = DynamicViscosity.From(1, DynamicViscosityUnit.MillipascalSecond);
+            var quantity02 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.MillipascalSecond);
             AssertEx.EqualTolerance(1, quantity02.MillipascalSeconds, MillipascalSecondsTolerance);
             Assert.Equal(DynamicViscosityUnit.MillipascalSecond, quantity02.Unit);
 
-            var quantity03 = DynamicViscosity.From(1, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
+            var quantity03 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
             AssertEx.EqualTolerance(1, quantity03.NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
             Assert.Equal(DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity03.Unit);
 
-            var quantity04 = DynamicViscosity.From(1, DynamicViscosityUnit.PascalSecond);
+            var quantity04 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.PascalSecond);
             AssertEx.EqualTolerance(1, quantity04.PascalSeconds, PascalSecondsTolerance);
             Assert.Equal(DynamicViscosityUnit.PascalSecond, quantity04.Unit);
 
-            var quantity05 = DynamicViscosity.From(1, DynamicViscosityUnit.Poise);
+            var quantity05 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.Poise);
             AssertEx.EqualTolerance(1, quantity05.Poise, PoiseTolerance);
             Assert.Equal(DynamicViscosityUnit.Poise, quantity05.Unit);
 
-            var quantity06 = DynamicViscosity.From(1, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
+            var quantity06 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
             AssertEx.EqualTolerance(1, quantity06.PoundsForceSecondPerSquareFoot, PoundsForceSecondPerSquareFootTolerance);
             Assert.Equal(DynamicViscosityUnit.PoundForceSecondPerSquareFoot, quantity06.Unit);
 
-            var quantity07 = DynamicViscosity.From(1, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
+            var quantity07 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
             AssertEx.EqualTolerance(1, quantity07.PoundsForceSecondPerSquareInch, PoundsForceSecondPerSquareInchTolerance);
             Assert.Equal(DynamicViscosityUnit.PoundForceSecondPerSquareInch, quantity07.Unit);
 
-            var quantity08 = DynamicViscosity.From(1, DynamicViscosityUnit.PoundPerFootSecond);
+            var quantity08 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.PoundPerFootSecond);
             AssertEx.EqualTolerance(1, quantity08.PoundsPerFootSecond, PoundsPerFootSecondTolerance);
             Assert.Equal(DynamicViscosityUnit.PoundPerFootSecond, quantity08.Unit);
 
-            var quantity09 = DynamicViscosity.From(1, DynamicViscosityUnit.Reyn);
+            var quantity09 = DynamicViscosity<double>.From(1, DynamicViscosityUnit.Reyn);
             AssertEx.EqualTolerance(1, quantity09.Reyns, ReynsTolerance);
             Assert.Equal(DynamicViscosityUnit.Reyn, quantity09.Unit);
 
@@ -193,20 +193,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonSecondsPerMeterSquared_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => DynamicViscosity.FromNewtonSecondsPerMeterSquared(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => DynamicViscosity.FromNewtonSecondsPerMeterSquared(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonSecondsPerMeterSquared_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => DynamicViscosity.FromNewtonSecondsPerMeterSquared(double.NaN));
+            Assert.Throws<ArgumentException>(() => DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            var newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             AssertEx.EqualTolerance(CentipoiseInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.Centipoise), CentipoiseTolerance);
             AssertEx.EqualTolerance(MicropascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.MicropascalSecond), MicropascalSecondsTolerance);
             AssertEx.EqualTolerance(MillipascalSecondsInOneNewtonSecondPerMeterSquared, newtonsecondpermetersquared.As(DynamicViscosityUnit.MillipascalSecond), MillipascalSecondsTolerance);
@@ -239,7 +239,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            var newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
 
             var centipoiseQuantity = newtonsecondpermetersquared.ToUnit(DynamicViscosityUnit.Centipoise);
             AssertEx.EqualTolerance(CentipoiseInOneNewtonSecondPerMeterSquared, (double)centipoiseQuantity.Value, CentipoiseTolerance);
@@ -292,37 +292,37 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromCentipoise(newtonsecondpermetersquared.Centipoise).NewtonSecondsPerMeterSquared, CentipoiseTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromMicropascalSeconds(newtonsecondpermetersquared.MicropascalSeconds).NewtonSecondsPerMeterSquared, MicropascalSecondsTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromMillipascalSeconds(newtonsecondpermetersquared.MillipascalSeconds).NewtonSecondsPerMeterSquared, MillipascalSecondsTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromNewtonSecondsPerMeterSquared(newtonsecondpermetersquared.NewtonSecondsPerMeterSquared).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPascalSeconds(newtonsecondpermetersquared.PascalSeconds).NewtonSecondsPerMeterSquared, PascalSecondsTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoise(newtonsecondpermetersquared.Poise).NewtonSecondsPerMeterSquared, PoiseTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoundsForceSecondPerSquareFoot(newtonsecondpermetersquared.PoundsForceSecondPerSquareFoot).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoundsForceSecondPerSquareInch(newtonsecondpermetersquared.PoundsForceSecondPerSquareInch).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoundsPerFootSecond(newtonsecondpermetersquared.PoundsPerFootSecond).NewtonSecondsPerMeterSquared, PoundsPerFootSecondTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromReyns(newtonsecondpermetersquared.Reyns).NewtonSecondsPerMeterSquared, ReynsTolerance);
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromCentipoise(newtonsecondpermetersquared.Centipoise).NewtonSecondsPerMeterSquared, CentipoiseTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromMicropascalSeconds(newtonsecondpermetersquared.MicropascalSeconds).NewtonSecondsPerMeterSquared, MicropascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromMillipascalSeconds(newtonsecondpermetersquared.MillipascalSeconds).NewtonSecondsPerMeterSquared, MillipascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(newtonsecondpermetersquared.NewtonSecondsPerMeterSquared).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPascalSeconds(newtonsecondpermetersquared.PascalSeconds).NewtonSecondsPerMeterSquared, PascalSecondsTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPoise(newtonsecondpermetersquared.Poise).NewtonSecondsPerMeterSquared, PoiseTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPoundsForceSecondPerSquareFoot(newtonsecondpermetersquared.PoundsForceSecondPerSquareFoot).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPoundsForceSecondPerSquareInch(newtonsecondpermetersquared.PoundsForceSecondPerSquareInch).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromPoundsPerFootSecond(newtonsecondpermetersquared.PoundsPerFootSecond).NewtonSecondsPerMeterSquared, PoundsPerFootSecondTolerance);
+            AssertEx.EqualTolerance(1, DynamicViscosity<double>.FromReyns(newtonsecondpermetersquared.Reyns).NewtonSecondsPerMeterSquared, ReynsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            DynamicViscosity v = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> v = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             AssertEx.EqualTolerance(-1, -v.NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(2, (DynamicViscosity.FromNewtonSecondsPerMeterSquared(3)-v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(2, (DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(3)-v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(2, (DynamicViscosity.FromNewtonSecondsPerMeterSquared(10)/5).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(2, DynamicViscosity.FromNewtonSecondsPerMeterSquared(10)/DynamicViscosity.FromNewtonSecondsPerMeterSquared(5), NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(2, (DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(10)/5).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
+            AssertEx.EqualTolerance(2, DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(10)/DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(5), NewtonSecondsPerMeterSquaredTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            DynamicViscosity oneNewtonSecondPerMeterSquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            DynamicViscosity twoNewtonSecondsPerMeterSquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(2);
+            DynamicViscosity<double> oneNewtonSecondPerMeterSquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> twoNewtonSecondsPerMeterSquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(2);
 
             Assert.True(oneNewtonSecondPerMeterSquared < twoNewtonSecondsPerMeterSquared);
             Assert.True(oneNewtonSecondPerMeterSquared <= twoNewtonSecondsPerMeterSquared);
@@ -338,31 +338,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             Assert.Equal(0, newtonsecondpermetersquared.CompareTo(newtonsecondpermetersquared));
-            Assert.True(newtonsecondpermetersquared.CompareTo(DynamicViscosity.Zero) > 0);
-            Assert.True(DynamicViscosity.Zero.CompareTo(newtonsecondpermetersquared) < 0);
+            Assert.True(newtonsecondpermetersquared.CompareTo(DynamicViscosity<double>.Zero) > 0);
+            Assert.True(DynamicViscosity<double>.Zero.CompareTo(newtonsecondpermetersquared) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             Assert.Throws<ArgumentException>(() => newtonsecondpermetersquared.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             Assert.Throws<ArgumentNullException>(() => newtonsecondpermetersquared.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            var b = DynamicViscosity.FromNewtonSecondsPerMeterSquared(2);
+            var a = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            var b = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -381,8 +381,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            var b = DynamicViscosity.FromNewtonSecondsPerMeterSquared(2);
+            var a = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            var b = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -402,9 +402,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            Assert.True(v.Equals(DynamicViscosity.FromNewtonSecondsPerMeterSquared(1), NewtonSecondsPerMeterSquaredTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(DynamicViscosity.Zero, NewtonSecondsPerMeterSquaredTolerance, ComparisonType.Relative));
+            var v = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
+            Assert.True(v.Equals(DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1), NewtonSecondsPerMeterSquaredTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(DynamicViscosity<double>.Zero, NewtonSecondsPerMeterSquaredTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -417,21 +417,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             Assert.False(newtonsecondpermetersquared.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
+            DynamicViscosity<double> newtonsecondpermetersquared = DynamicViscosity<double>.FromNewtonSecondsPerMeterSquared(1);
             Assert.False(newtonsecondpermetersquared.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(DynamicViscosityUnit.Undefined, DynamicViscosity.Units);
+            Assert.DoesNotContain(DynamicViscosityUnit.Undefined, DynamicViscosity<double>.Units);
         }
 
         [Fact]
@@ -450,7 +450,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(DynamicViscosity.BaseDimensions is null);
+            Assert.False(DynamicViscosity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs
index 5ebbe0c836..db026c3663 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class ElectricAdmittanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricAdmittance((double)0.0, ElectricAdmittanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>((double)0.0, ElectricAdmittanceUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricAdmittance(double.PositiveInfinity, ElectricAdmittanceUnit.Siemens));
-            Assert.Throws<ArgumentException>(() => new ElectricAdmittance(double.NegativeInfinity, ElectricAdmittanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>(double.PositiveInfinity, ElectricAdmittanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>(double.NegativeInfinity, ElectricAdmittanceUnit.Siemens));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricAdmittance(double.NaN, ElectricAdmittanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricAdmittance<double>(double.NaN, ElectricAdmittanceUnit.Siemens));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void ElectricAdmittance_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
         [Fact]
         public void SiemensToElectricAdmittanceUnits()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
             AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.Microsiemens, MicrosiemensTolerance);
             AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.Millisiemens, MillisiemensTolerance);
             AssertEx.EqualTolerance(NanosiemensInOneSiemens, siemens.Nanosiemens, NanosiemensTolerance);
@@ -130,19 +130,19 @@ public void SiemensToElectricAdmittanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricAdmittance.From(1, ElectricAdmittanceUnit.Microsiemens);
+            var quantity00 = ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Microsiemens);
             AssertEx.EqualTolerance(1, quantity00.Microsiemens, MicrosiemensTolerance);
             Assert.Equal(ElectricAdmittanceUnit.Microsiemens, quantity00.Unit);
 
-            var quantity01 = ElectricAdmittance.From(1, ElectricAdmittanceUnit.Millisiemens);
+            var quantity01 = ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Millisiemens);
             AssertEx.EqualTolerance(1, quantity01.Millisiemens, MillisiemensTolerance);
             Assert.Equal(ElectricAdmittanceUnit.Millisiemens, quantity01.Unit);
 
-            var quantity02 = ElectricAdmittance.From(1, ElectricAdmittanceUnit.Nanosiemens);
+            var quantity02 = ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Nanosiemens);
             AssertEx.EqualTolerance(1, quantity02.Nanosiemens, NanosiemensTolerance);
             Assert.Equal(ElectricAdmittanceUnit.Nanosiemens, quantity02.Unit);
 
-            var quantity03 = ElectricAdmittance.From(1, ElectricAdmittanceUnit.Siemens);
+            var quantity03 = ElectricAdmittance<double>.From(1, ElectricAdmittanceUnit.Siemens);
             AssertEx.EqualTolerance(1, quantity03.Siemens, SiemensTolerance);
             Assert.Equal(ElectricAdmittanceUnit.Siemens, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSiemens_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricAdmittance.FromSiemens(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricAdmittance.FromSiemens(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricAdmittance<double>.FromSiemens(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricAdmittance<double>.FromSiemens(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSiemens_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricAdmittance.FromSiemens(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricAdmittance<double>.FromSiemens(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var siemens = ElectricAdmittance.FromSiemens(1);
+            var siemens = ElectricAdmittance<double>.FromSiemens(1);
             AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.As(ElectricAdmittanceUnit.Microsiemens), MicrosiemensTolerance);
             AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.As(ElectricAdmittanceUnit.Millisiemens), MillisiemensTolerance);
             AssertEx.EqualTolerance(NanosiemensInOneSiemens, siemens.As(ElectricAdmittanceUnit.Nanosiemens), NanosiemensTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var siemens = ElectricAdmittance.FromSiemens(1);
+            var siemens = ElectricAdmittance<double>.FromSiemens(1);
 
             var microsiemensQuantity = siemens.ToUnit(ElectricAdmittanceUnit.Microsiemens);
             AssertEx.EqualTolerance(MicrosiemensInOneSiemens, (double)microsiemensQuantity.Value, MicrosiemensTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromNanosiemens(siemens.Nanosiemens).Siemens, NanosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromNanosiemens(siemens.Nanosiemens).Siemens, NanosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricAdmittance<double>.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricAdmittance v = ElectricAdmittance.FromSiemens(1);
+            ElectricAdmittance<double> v = ElectricAdmittance<double>.FromSiemens(1);
             AssertEx.EqualTolerance(-1, -v.Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricAdmittance.FromSiemens(3)-v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricAdmittance<double>.FromSiemens(3)-v).Siemens, SiemensTolerance);
             AssertEx.EqualTolerance(2, (v + v).Siemens, SiemensTolerance);
             AssertEx.EqualTolerance(10, (v*10).Siemens, SiemensTolerance);
             AssertEx.EqualTolerance(10, (10*v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricAdmittance.FromSiemens(10)/5).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, ElectricAdmittance.FromSiemens(10)/ElectricAdmittance.FromSiemens(5), SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricAdmittance<double>.FromSiemens(10)/5).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, ElectricAdmittance<double>.FromSiemens(10)/ElectricAdmittance<double>.FromSiemens(5), SiemensTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricAdmittance oneSiemens = ElectricAdmittance.FromSiemens(1);
-            ElectricAdmittance twoSiemens = ElectricAdmittance.FromSiemens(2);
+            ElectricAdmittance<double> oneSiemens = ElectricAdmittance<double>.FromSiemens(1);
+            ElectricAdmittance<double> twoSiemens = ElectricAdmittance<double>.FromSiemens(2);
 
             Assert.True(oneSiemens < twoSiemens);
             Assert.True(oneSiemens <= twoSiemens);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
             Assert.Equal(0, siemens.CompareTo(siemens));
-            Assert.True(siemens.CompareTo(ElectricAdmittance.Zero) > 0);
-            Assert.True(ElectricAdmittance.Zero.CompareTo(siemens) < 0);
+            Assert.True(siemens.CompareTo(ElectricAdmittance<double>.Zero) > 0);
+            Assert.True(ElectricAdmittance<double>.Zero.CompareTo(siemens) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
             Assert.Throws<ArgumentException>(() => siemens.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
             Assert.Throws<ArgumentNullException>(() => siemens.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricAdmittance.FromSiemens(1);
-            var b = ElectricAdmittance.FromSiemens(2);
+            var a = ElectricAdmittance<double>.FromSiemens(1);
+            var b = ElectricAdmittance<double>.FromSiemens(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricAdmittance.FromSiemens(1);
-            var b = ElectricAdmittance.FromSiemens(2);
+            var a = ElectricAdmittance<double>.FromSiemens(1);
+            var b = ElectricAdmittance<double>.FromSiemens(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricAdmittance.FromSiemens(1);
-            Assert.True(v.Equals(ElectricAdmittance.FromSiemens(1), SiemensTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricAdmittance.Zero, SiemensTolerance, ComparisonType.Relative));
+            var v = ElectricAdmittance<double>.FromSiemens(1);
+            Assert.True(v.Equals(ElectricAdmittance<double>.FromSiemens(1), SiemensTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricAdmittance<double>.Zero, SiemensTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
             Assert.False(siemens.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
+            ElectricAdmittance<double> siemens = ElectricAdmittance<double>.FromSiemens(1);
             Assert.False(siemens.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricAdmittanceUnit.Undefined, ElectricAdmittance.Units);
+            Assert.DoesNotContain(ElectricAdmittanceUnit.Undefined, ElectricAdmittance<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricAdmittance.BaseDimensions is null);
+            Assert.False(ElectricAdmittance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs
index f99e06cc8c..4941d2729b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class ElectricChargeDensityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity((double)0.0, ElectricChargeDensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>((double)0.0, ElectricChargeDensityUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity(double.PositiveInfinity, ElectricChargeDensityUnit.CoulombPerCubicMeter));
-            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity(double.NegativeInfinity, ElectricChargeDensityUnit.CoulombPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>(double.PositiveInfinity, ElectricChargeDensityUnit.CoulombPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>(double.NegativeInfinity, ElectricChargeDensityUnit.CoulombPerCubicMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity(double.NaN, ElectricChargeDensityUnit.CoulombPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricChargeDensity<double>(double.NaN, ElectricChargeDensityUnit.CoulombPerCubicMeter));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void ElectricChargeDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuan
         [Fact]
         public void CoulombPerCubicMeterToElectricChargeDensityUnits()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             AssertEx.EqualTolerance(CoulombsPerCubicMeterInOneCoulombPerCubicMeter, coulombpercubicmeter.CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricChargeDensity.From(1, ElectricChargeDensityUnit.CoulombPerCubicMeter);
+            var quantity00 = ElectricChargeDensity<double>.From(1, ElectricChargeDensityUnit.CoulombPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity00.CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
             Assert.Equal(ElectricChargeDensityUnit.CoulombPerCubicMeter, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCoulombsPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricChargeDensity.FromCoulombsPerCubicMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricChargeDensity.FromCoulombsPerCubicMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCoulombsPerCubicMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricChargeDensity.FromCoulombsPerCubicMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            var coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             AssertEx.EqualTolerance(CoulombsPerCubicMeterInOneCoulombPerCubicMeter, coulombpercubicmeter.As(ElectricChargeDensityUnit.CoulombPerCubicMeter), CoulombsPerCubicMeterTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            var coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
 
             var coulombpercubicmeterQuantity = coulombpercubicmeter.ToUnit(ElectricChargeDensityUnit.CoulombPerCubicMeter);
             AssertEx.EqualTolerance(CoulombsPerCubicMeterInOneCoulombPerCubicMeter, (double)coulombpercubicmeterQuantity.Value, CoulombsPerCubicMeterTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, ElectricChargeDensity.FromCoulombsPerCubicMeter(coulombpercubicmeter.CoulombsPerCubicMeter).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(coulombpercubicmeter.CoulombsPerCubicMeter).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricChargeDensity v = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> v = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             AssertEx.EqualTolerance(-1, -v.CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricChargeDensity.FromCoulombsPerCubicMeter(3)-v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(3)-v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricChargeDensity.FromCoulombsPerCubicMeter(10)/5).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricChargeDensity.FromCoulombsPerCubicMeter(10)/ElectricChargeDensity.FromCoulombsPerCubicMeter(5), CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(10)/5).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(10)/ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(5), CoulombsPerCubicMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricChargeDensity oneCoulombPerCubicMeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
-            ElectricChargeDensity twoCoulombsPerCubicMeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(2);
+            ElectricChargeDensity<double> oneCoulombPerCubicMeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> twoCoulombsPerCubicMeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(2);
 
             Assert.True(oneCoulombPerCubicMeter < twoCoulombsPerCubicMeter);
             Assert.True(oneCoulombPerCubicMeter <= twoCoulombsPerCubicMeter);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             Assert.Equal(0, coulombpercubicmeter.CompareTo(coulombpercubicmeter));
-            Assert.True(coulombpercubicmeter.CompareTo(ElectricChargeDensity.Zero) > 0);
-            Assert.True(ElectricChargeDensity.Zero.CompareTo(coulombpercubicmeter) < 0);
+            Assert.True(coulombpercubicmeter.CompareTo(ElectricChargeDensity<double>.Zero) > 0);
+            Assert.True(ElectricChargeDensity<double>.Zero.CompareTo(coulombpercubicmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             Assert.Throws<ArgumentException>(() => coulombpercubicmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             Assert.Throws<ArgumentNullException>(() => coulombpercubicmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
-            var b = ElectricChargeDensity.FromCoulombsPerCubicMeter(2);
+            var a = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            var b = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
-            var b = ElectricChargeDensity.FromCoulombsPerCubicMeter(2);
+            var a = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            var b = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
-            Assert.True(v.Equals(ElectricChargeDensity.FromCoulombsPerCubicMeter(1), CoulombsPerCubicMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricChargeDensity.Zero, CoulombsPerCubicMeterTolerance, ComparisonType.Relative));
+            var v = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
+            Assert.True(v.Equals(ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1), CoulombsPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricChargeDensity<double>.Zero, CoulombsPerCubicMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             Assert.False(coulombpercubicmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
+            ElectricChargeDensity<double> coulombpercubicmeter = ElectricChargeDensity<double>.FromCoulombsPerCubicMeter(1);
             Assert.False(coulombpercubicmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricChargeDensityUnit.Undefined, ElectricChargeDensity.Units);
+            Assert.DoesNotContain(ElectricChargeDensityUnit.Undefined, ElectricChargeDensity<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricChargeDensity.BaseDimensions is null);
+            Assert.False(ElectricChargeDensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs
index 8c8e7fb08f..8bb490d764 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs
@@ -54,7 +54,7 @@ public abstract partial class ElectricChargeTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCharge((double)0.0, ElectricChargeUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>((double)0.0, ElectricChargeUnit.Undefined));
         }
 
         [Fact]
@@ -69,14 +69,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCharge(double.PositiveInfinity, ElectricChargeUnit.Coulomb));
-            Assert.Throws<ArgumentException>(() => new ElectricCharge(double.NegativeInfinity, ElectricChargeUnit.Coulomb));
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>(double.PositiveInfinity, ElectricChargeUnit.Coulomb));
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>(double.NegativeInfinity, ElectricChargeUnit.Coulomb));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCharge(double.NaN, ElectricChargeUnit.Coulomb));
+            Assert.Throws<ArgumentException>(() => new ElectricCharge<double>(double.NaN, ElectricChargeUnit.Coulomb));
         }
 
         [Fact]
@@ -122,7 +122,7 @@ public void ElectricCharge_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void CoulombToElectricChargeUnits()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
             AssertEx.EqualTolerance(AmpereHoursInOneCoulomb, coulomb.AmpereHours, AmpereHoursTolerance);
             AssertEx.EqualTolerance(CoulombsInOneCoulomb, coulomb.Coulombs, CoulombsTolerance);
             AssertEx.EqualTolerance(KiloampereHoursInOneCoulomb, coulomb.KiloampereHours, KiloampereHoursTolerance);
@@ -133,23 +133,23 @@ public void CoulombToElectricChargeUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricCharge.From(1, ElectricChargeUnit.AmpereHour);
+            var quantity00 = ElectricCharge<double>.From(1, ElectricChargeUnit.AmpereHour);
             AssertEx.EqualTolerance(1, quantity00.AmpereHours, AmpereHoursTolerance);
             Assert.Equal(ElectricChargeUnit.AmpereHour, quantity00.Unit);
 
-            var quantity01 = ElectricCharge.From(1, ElectricChargeUnit.Coulomb);
+            var quantity01 = ElectricCharge<double>.From(1, ElectricChargeUnit.Coulomb);
             AssertEx.EqualTolerance(1, quantity01.Coulombs, CoulombsTolerance);
             Assert.Equal(ElectricChargeUnit.Coulomb, quantity01.Unit);
 
-            var quantity02 = ElectricCharge.From(1, ElectricChargeUnit.KiloampereHour);
+            var quantity02 = ElectricCharge<double>.From(1, ElectricChargeUnit.KiloampereHour);
             AssertEx.EqualTolerance(1, quantity02.KiloampereHours, KiloampereHoursTolerance);
             Assert.Equal(ElectricChargeUnit.KiloampereHour, quantity02.Unit);
 
-            var quantity03 = ElectricCharge.From(1, ElectricChargeUnit.MegaampereHour);
+            var quantity03 = ElectricCharge<double>.From(1, ElectricChargeUnit.MegaampereHour);
             AssertEx.EqualTolerance(1, quantity03.MegaampereHours, MegaampereHoursTolerance);
             Assert.Equal(ElectricChargeUnit.MegaampereHour, quantity03.Unit);
 
-            var quantity04 = ElectricCharge.From(1, ElectricChargeUnit.MilliampereHour);
+            var quantity04 = ElectricCharge<double>.From(1, ElectricChargeUnit.MilliampereHour);
             AssertEx.EqualTolerance(1, quantity04.MilliampereHours, MilliampereHoursTolerance);
             Assert.Equal(ElectricChargeUnit.MilliampereHour, quantity04.Unit);
 
@@ -158,20 +158,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCoulombs_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCharge.FromCoulombs(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricCharge.FromCoulombs(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCharge<double>.FromCoulombs(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCharge<double>.FromCoulombs(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCoulombs_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCharge.FromCoulombs(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricCharge<double>.FromCoulombs(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var coulomb = ElectricCharge.FromCoulombs(1);
+            var coulomb = ElectricCharge<double>.FromCoulombs(1);
             AssertEx.EqualTolerance(AmpereHoursInOneCoulomb, coulomb.As(ElectricChargeUnit.AmpereHour), AmpereHoursTolerance);
             AssertEx.EqualTolerance(CoulombsInOneCoulomb, coulomb.As(ElectricChargeUnit.Coulomb), CoulombsTolerance);
             AssertEx.EqualTolerance(KiloampereHoursInOneCoulomb, coulomb.As(ElectricChargeUnit.KiloampereHour), KiloampereHoursTolerance);
@@ -199,7 +199,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var coulomb = ElectricCharge.FromCoulombs(1);
+            var coulomb = ElectricCharge<double>.FromCoulombs(1);
 
             var amperehourQuantity = coulomb.ToUnit(ElectricChargeUnit.AmpereHour);
             AssertEx.EqualTolerance(AmpereHoursInOneCoulomb, (double)amperehourQuantity.Value, AmpereHoursTolerance);
@@ -232,32 +232,32 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromAmpereHours(coulomb.AmpereHours).Coulombs, AmpereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromCoulombs(coulomb.Coulombs).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromKiloampereHours(coulomb.KiloampereHours).Coulombs, KiloampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromMegaampereHours(coulomb.MegaampereHours).Coulombs, MegaampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromMilliampereHours(coulomb.MilliampereHours).Coulombs, MilliampereHoursTolerance);
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromAmpereHours(coulomb.AmpereHours).Coulombs, AmpereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromCoulombs(coulomb.Coulombs).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromKiloampereHours(coulomb.KiloampereHours).Coulombs, KiloampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromMegaampereHours(coulomb.MegaampereHours).Coulombs, MegaampereHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricCharge<double>.FromMilliampereHours(coulomb.MilliampereHours).Coulombs, MilliampereHoursTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricCharge v = ElectricCharge.FromCoulombs(1);
+            ElectricCharge<double> v = ElectricCharge<double>.FromCoulombs(1);
             AssertEx.EqualTolerance(-1, -v.Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCharge.FromCoulombs(3)-v).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCharge<double>.FromCoulombs(3)-v).Coulombs, CoulombsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Coulombs, CoulombsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Coulombs, CoulombsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCharge.FromCoulombs(10)/5).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(2, ElectricCharge.FromCoulombs(10)/ElectricCharge.FromCoulombs(5), CoulombsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCharge<double>.FromCoulombs(10)/5).Coulombs, CoulombsTolerance);
+            AssertEx.EqualTolerance(2, ElectricCharge<double>.FromCoulombs(10)/ElectricCharge<double>.FromCoulombs(5), CoulombsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricCharge oneCoulomb = ElectricCharge.FromCoulombs(1);
-            ElectricCharge twoCoulombs = ElectricCharge.FromCoulombs(2);
+            ElectricCharge<double> oneCoulomb = ElectricCharge<double>.FromCoulombs(1);
+            ElectricCharge<double> twoCoulombs = ElectricCharge<double>.FromCoulombs(2);
 
             Assert.True(oneCoulomb < twoCoulombs);
             Assert.True(oneCoulomb <= twoCoulombs);
@@ -273,31 +273,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
             Assert.Equal(0, coulomb.CompareTo(coulomb));
-            Assert.True(coulomb.CompareTo(ElectricCharge.Zero) > 0);
-            Assert.True(ElectricCharge.Zero.CompareTo(coulomb) < 0);
+            Assert.True(coulomb.CompareTo(ElectricCharge<double>.Zero) > 0);
+            Assert.True(ElectricCharge<double>.Zero.CompareTo(coulomb) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
             Assert.Throws<ArgumentException>(() => coulomb.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
             Assert.Throws<ArgumentNullException>(() => coulomb.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricCharge.FromCoulombs(1);
-            var b = ElectricCharge.FromCoulombs(2);
+            var a = ElectricCharge<double>.FromCoulombs(1);
+            var b = ElectricCharge<double>.FromCoulombs(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -316,8 +316,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricCharge.FromCoulombs(1);
-            var b = ElectricCharge.FromCoulombs(2);
+            var a = ElectricCharge<double>.FromCoulombs(1);
+            var b = ElectricCharge<double>.FromCoulombs(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -337,9 +337,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricCharge.FromCoulombs(1);
-            Assert.True(v.Equals(ElectricCharge.FromCoulombs(1), CoulombsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricCharge.Zero, CoulombsTolerance, ComparisonType.Relative));
+            var v = ElectricCharge<double>.FromCoulombs(1);
+            Assert.True(v.Equals(ElectricCharge<double>.FromCoulombs(1), CoulombsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCharge<double>.Zero, CoulombsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -352,21 +352,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
             Assert.False(coulomb.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
+            ElectricCharge<double> coulomb = ElectricCharge<double>.FromCoulombs(1);
             Assert.False(coulomb.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricChargeUnit.Undefined, ElectricCharge.Units);
+            Assert.DoesNotContain(ElectricChargeUnit.Undefined, ElectricCharge<double>.Units);
         }
 
         [Fact]
@@ -385,7 +385,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricCharge.BaseDimensions is null);
+            Assert.False(ElectricCharge<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs
index bcdb3ecf9a..185a93c99d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class ElectricConductanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricConductance((double)0.0, ElectricConductanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>((double)0.0, ElectricConductanceUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricConductance(double.PositiveInfinity, ElectricConductanceUnit.Siemens));
-            Assert.Throws<ArgumentException>(() => new ElectricConductance(double.NegativeInfinity, ElectricConductanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>(double.PositiveInfinity, ElectricConductanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>(double.NegativeInfinity, ElectricConductanceUnit.Siemens));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricConductance(double.NaN, ElectricConductanceUnit.Siemens));
+            Assert.Throws<ArgumentException>(() => new ElectricConductance<double>(double.NaN, ElectricConductanceUnit.Siemens));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void ElectricConductance_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void SiemensToElectricConductanceUnits()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
             AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.Microsiemens, MicrosiemensTolerance);
             AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.Millisiemens, MillisiemensTolerance);
             AssertEx.EqualTolerance(SiemensInOneSiemens, siemens.Siemens, SiemensTolerance);
@@ -127,15 +127,15 @@ public void SiemensToElectricConductanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricConductance.From(1, ElectricConductanceUnit.Microsiemens);
+            var quantity00 = ElectricConductance<double>.From(1, ElectricConductanceUnit.Microsiemens);
             AssertEx.EqualTolerance(1, quantity00.Microsiemens, MicrosiemensTolerance);
             Assert.Equal(ElectricConductanceUnit.Microsiemens, quantity00.Unit);
 
-            var quantity01 = ElectricConductance.From(1, ElectricConductanceUnit.Millisiemens);
+            var quantity01 = ElectricConductance<double>.From(1, ElectricConductanceUnit.Millisiemens);
             AssertEx.EqualTolerance(1, quantity01.Millisiemens, MillisiemensTolerance);
             Assert.Equal(ElectricConductanceUnit.Millisiemens, quantity01.Unit);
 
-            var quantity02 = ElectricConductance.From(1, ElectricConductanceUnit.Siemens);
+            var quantity02 = ElectricConductance<double>.From(1, ElectricConductanceUnit.Siemens);
             AssertEx.EqualTolerance(1, quantity02.Siemens, SiemensTolerance);
             Assert.Equal(ElectricConductanceUnit.Siemens, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSiemens_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricConductance.FromSiemens(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricConductance.FromSiemens(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricConductance<double>.FromSiemens(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricConductance<double>.FromSiemens(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSiemens_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricConductance.FromSiemens(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricConductance<double>.FromSiemens(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var siemens = ElectricConductance.FromSiemens(1);
+            var siemens = ElectricConductance<double>.FromSiemens(1);
             AssertEx.EqualTolerance(MicrosiemensInOneSiemens, siemens.As(ElectricConductanceUnit.Microsiemens), MicrosiemensTolerance);
             AssertEx.EqualTolerance(MillisiemensInOneSiemens, siemens.As(ElectricConductanceUnit.Millisiemens), MillisiemensTolerance);
             AssertEx.EqualTolerance(SiemensInOneSiemens, siemens.As(ElectricConductanceUnit.Siemens), SiemensTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var siemens = ElectricConductance.FromSiemens(1);
+            var siemens = ElectricConductance<double>.FromSiemens(1);
 
             var microsiemensQuantity = siemens.ToUnit(ElectricConductanceUnit.Microsiemens);
             AssertEx.EqualTolerance(MicrosiemensInOneSiemens, (double)microsiemensQuantity.Value, MicrosiemensTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductance<double>.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricConductance v = ElectricConductance.FromSiemens(1);
+            ElectricConductance<double> v = ElectricConductance<double>.FromSiemens(1);
             AssertEx.EqualTolerance(-1, -v.Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductance.FromSiemens(3)-v).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductance<double>.FromSiemens(3)-v).Siemens, SiemensTolerance);
             AssertEx.EqualTolerance(2, (v + v).Siemens, SiemensTolerance);
             AssertEx.EqualTolerance(10, (v*10).Siemens, SiemensTolerance);
             AssertEx.EqualTolerance(10, (10*v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductance.FromSiemens(10)/5).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, ElectricConductance.FromSiemens(10)/ElectricConductance.FromSiemens(5), SiemensTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductance<double>.FromSiemens(10)/5).Siemens, SiemensTolerance);
+            AssertEx.EqualTolerance(2, ElectricConductance<double>.FromSiemens(10)/ElectricConductance<double>.FromSiemens(5), SiemensTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricConductance oneSiemens = ElectricConductance.FromSiemens(1);
-            ElectricConductance twoSiemens = ElectricConductance.FromSiemens(2);
+            ElectricConductance<double> oneSiemens = ElectricConductance<double>.FromSiemens(1);
+            ElectricConductance<double> twoSiemens = ElectricConductance<double>.FromSiemens(2);
 
             Assert.True(oneSiemens < twoSiemens);
             Assert.True(oneSiemens <= twoSiemens);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
             Assert.Equal(0, siemens.CompareTo(siemens));
-            Assert.True(siemens.CompareTo(ElectricConductance.Zero) > 0);
-            Assert.True(ElectricConductance.Zero.CompareTo(siemens) < 0);
+            Assert.True(siemens.CompareTo(ElectricConductance<double>.Zero) > 0);
+            Assert.True(ElectricConductance<double>.Zero.CompareTo(siemens) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
             Assert.Throws<ArgumentException>(() => siemens.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
             Assert.Throws<ArgumentNullException>(() => siemens.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricConductance.FromSiemens(1);
-            var b = ElectricConductance.FromSiemens(2);
+            var a = ElectricConductance<double>.FromSiemens(1);
+            var b = ElectricConductance<double>.FromSiemens(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricConductance.FromSiemens(1);
-            var b = ElectricConductance.FromSiemens(2);
+            var a = ElectricConductance<double>.FromSiemens(1);
+            var b = ElectricConductance<double>.FromSiemens(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricConductance.FromSiemens(1);
-            Assert.True(v.Equals(ElectricConductance.FromSiemens(1), SiemensTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricConductance.Zero, SiemensTolerance, ComparisonType.Relative));
+            var v = ElectricConductance<double>.FromSiemens(1);
+            Assert.True(v.Equals(ElectricConductance<double>.FromSiemens(1), SiemensTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricConductance<double>.Zero, SiemensTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
             Assert.False(siemens.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
+            ElectricConductance<double> siemens = ElectricConductance<double>.FromSiemens(1);
             Assert.False(siemens.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricConductanceUnit.Undefined, ElectricConductance.Units);
+            Assert.DoesNotContain(ElectricConductanceUnit.Undefined, ElectricConductance<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricConductance.BaseDimensions is null);
+            Assert.False(ElectricConductance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs
index 255593e2c6..21b17edc45 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class ElectricConductivityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricConductivity((double)0.0, ElectricConductivityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>((double)0.0, ElectricConductivityUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricConductivity(double.PositiveInfinity, ElectricConductivityUnit.SiemensPerMeter));
-            Assert.Throws<ArgumentException>(() => new ElectricConductivity(double.NegativeInfinity, ElectricConductivityUnit.SiemensPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>(double.PositiveInfinity, ElectricConductivityUnit.SiemensPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>(double.NegativeInfinity, ElectricConductivityUnit.SiemensPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricConductivity(double.NaN, ElectricConductivityUnit.SiemensPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricConductivity<double>(double.NaN, ElectricConductivityUnit.SiemensPerMeter));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void ElectricConductivity_QuantityInfo_ReturnsQuantityInfoDescribingQuant
         [Fact]
         public void SiemensPerMeterToElectricConductivityUnits()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
             AssertEx.EqualTolerance(SiemensPerFootInOneSiemensPerMeter, siemenspermeter.SiemensPerFoot, SiemensPerFootTolerance);
             AssertEx.EqualTolerance(SiemensPerInchInOneSiemensPerMeter, siemenspermeter.SiemensPerInch, SiemensPerInchTolerance);
             AssertEx.EqualTolerance(SiemensPerMeterInOneSiemensPerMeter, siemenspermeter.SiemensPerMeter, SiemensPerMeterTolerance);
@@ -127,15 +127,15 @@ public void SiemensPerMeterToElectricConductivityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricConductivity.From(1, ElectricConductivityUnit.SiemensPerFoot);
+            var quantity00 = ElectricConductivity<double>.From(1, ElectricConductivityUnit.SiemensPerFoot);
             AssertEx.EqualTolerance(1, quantity00.SiemensPerFoot, SiemensPerFootTolerance);
             Assert.Equal(ElectricConductivityUnit.SiemensPerFoot, quantity00.Unit);
 
-            var quantity01 = ElectricConductivity.From(1, ElectricConductivityUnit.SiemensPerInch);
+            var quantity01 = ElectricConductivity<double>.From(1, ElectricConductivityUnit.SiemensPerInch);
             AssertEx.EqualTolerance(1, quantity01.SiemensPerInch, SiemensPerInchTolerance);
             Assert.Equal(ElectricConductivityUnit.SiemensPerInch, quantity01.Unit);
 
-            var quantity02 = ElectricConductivity.From(1, ElectricConductivityUnit.SiemensPerMeter);
+            var quantity02 = ElectricConductivity<double>.From(1, ElectricConductivityUnit.SiemensPerMeter);
             AssertEx.EqualTolerance(1, quantity02.SiemensPerMeter, SiemensPerMeterTolerance);
             Assert.Equal(ElectricConductivityUnit.SiemensPerMeter, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSiemensPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricConductivity.FromSiemensPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricConductivity.FromSiemensPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricConductivity<double>.FromSiemensPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricConductivity<double>.FromSiemensPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSiemensPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricConductivity.FromSiemensPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricConductivity<double>.FromSiemensPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            var siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
             AssertEx.EqualTolerance(SiemensPerFootInOneSiemensPerMeter, siemenspermeter.As(ElectricConductivityUnit.SiemensPerFoot), SiemensPerFootTolerance);
             AssertEx.EqualTolerance(SiemensPerInchInOneSiemensPerMeter, siemenspermeter.As(ElectricConductivityUnit.SiemensPerInch), SiemensPerInchTolerance);
             AssertEx.EqualTolerance(SiemensPerMeterInOneSiemensPerMeter, siemenspermeter.As(ElectricConductivityUnit.SiemensPerMeter), SiemensPerMeterTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            var siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
 
             var siemensperfootQuantity = siemenspermeter.ToUnit(ElectricConductivityUnit.SiemensPerFoot);
             AssertEx.EqualTolerance(SiemensPerFootInOneSiemensPerMeter, (double)siemensperfootQuantity.Value, SiemensPerFootTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromSiemensPerFoot(siemenspermeter.SiemensPerFoot).SiemensPerMeter, SiemensPerFootTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromSiemensPerInch(siemenspermeter.SiemensPerInch).SiemensPerMeter, SiemensPerInchTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromSiemensPerMeter(siemenspermeter.SiemensPerMeter).SiemensPerMeter, SiemensPerMeterTolerance);
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.FromSiemensPerFoot(siemenspermeter.SiemensPerFoot).SiemensPerMeter, SiemensPerFootTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.FromSiemensPerInch(siemenspermeter.SiemensPerInch).SiemensPerMeter, SiemensPerInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricConductivity<double>.FromSiemensPerMeter(siemenspermeter.SiemensPerMeter).SiemensPerMeter, SiemensPerMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricConductivity v = ElectricConductivity.FromSiemensPerMeter(1);
+            ElectricConductivity<double> v = ElectricConductivity<double>.FromSiemensPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductivity.FromSiemensPerMeter(3)-v).SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductivity<double>.FromSiemensPerMeter(3)-v).SiemensPerMeter, SiemensPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).SiemensPerMeter, SiemensPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).SiemensPerMeter, SiemensPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductivity.FromSiemensPerMeter(10)/5).SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricConductivity.FromSiemensPerMeter(10)/ElectricConductivity.FromSiemensPerMeter(5), SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricConductivity<double>.FromSiemensPerMeter(10)/5).SiemensPerMeter, SiemensPerMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricConductivity<double>.FromSiemensPerMeter(10)/ElectricConductivity<double>.FromSiemensPerMeter(5), SiemensPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricConductivity oneSiemensPerMeter = ElectricConductivity.FromSiemensPerMeter(1);
-            ElectricConductivity twoSiemensPerMeter = ElectricConductivity.FromSiemensPerMeter(2);
+            ElectricConductivity<double> oneSiemensPerMeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            ElectricConductivity<double> twoSiemensPerMeter = ElectricConductivity<double>.FromSiemensPerMeter(2);
 
             Assert.True(oneSiemensPerMeter < twoSiemensPerMeter);
             Assert.True(oneSiemensPerMeter <= twoSiemensPerMeter);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
             Assert.Equal(0, siemenspermeter.CompareTo(siemenspermeter));
-            Assert.True(siemenspermeter.CompareTo(ElectricConductivity.Zero) > 0);
-            Assert.True(ElectricConductivity.Zero.CompareTo(siemenspermeter) < 0);
+            Assert.True(siemenspermeter.CompareTo(ElectricConductivity<double>.Zero) > 0);
+            Assert.True(ElectricConductivity<double>.Zero.CompareTo(siemenspermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
             Assert.Throws<ArgumentException>(() => siemenspermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => siemenspermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricConductivity.FromSiemensPerMeter(1);
-            var b = ElectricConductivity.FromSiemensPerMeter(2);
+            var a = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            var b = ElectricConductivity<double>.FromSiemensPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricConductivity.FromSiemensPerMeter(1);
-            var b = ElectricConductivity.FromSiemensPerMeter(2);
+            var a = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            var b = ElectricConductivity<double>.FromSiemensPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricConductivity.FromSiemensPerMeter(1);
-            Assert.True(v.Equals(ElectricConductivity.FromSiemensPerMeter(1), SiemensPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricConductivity.Zero, SiemensPerMeterTolerance, ComparisonType.Relative));
+            var v = ElectricConductivity<double>.FromSiemensPerMeter(1);
+            Assert.True(v.Equals(ElectricConductivity<double>.FromSiemensPerMeter(1), SiemensPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricConductivity<double>.Zero, SiemensPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
             Assert.False(siemenspermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
+            ElectricConductivity<double> siemenspermeter = ElectricConductivity<double>.FromSiemensPerMeter(1);
             Assert.False(siemenspermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricConductivityUnit.Undefined, ElectricConductivity.Units);
+            Assert.DoesNotContain(ElectricConductivityUnit.Undefined, ElectricConductivity<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricConductivity.BaseDimensions is null);
+            Assert.False(ElectricConductivity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs
index 4f2c5b9463..8f55321b2a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class ElectricCurrentDensityTestsBase : QuantityTestsBas
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity((double)0.0, ElectricCurrentDensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>((double)0.0, ElectricCurrentDensityUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity(double.PositiveInfinity, ElectricCurrentDensityUnit.AmperePerSquareMeter));
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity(double.NegativeInfinity, ElectricCurrentDensityUnit.AmperePerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>(double.PositiveInfinity, ElectricCurrentDensityUnit.AmperePerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>(double.NegativeInfinity, ElectricCurrentDensityUnit.AmperePerSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity(double.NaN, ElectricCurrentDensityUnit.AmperePerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentDensity<double>(double.NaN, ElectricCurrentDensityUnit.AmperePerSquareMeter));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void ElectricCurrentDensity_QuantityInfo_ReturnsQuantityInfoDescribingQua
         [Fact]
         public void AmperePerSquareMeterToElectricCurrentDensityUnits()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             AssertEx.EqualTolerance(AmperesPerSquareFootInOneAmperePerSquareMeter, amperepersquaremeter.AmperesPerSquareFoot, AmperesPerSquareFootTolerance);
             AssertEx.EqualTolerance(AmperesPerSquareInchInOneAmperePerSquareMeter, amperepersquaremeter.AmperesPerSquareInch, AmperesPerSquareInchTolerance);
             AssertEx.EqualTolerance(AmperesPerSquareMeterInOneAmperePerSquareMeter, amperepersquaremeter.AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
@@ -127,15 +127,15 @@ public void AmperePerSquareMeterToElectricCurrentDensityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricCurrentDensity.From(1, ElectricCurrentDensityUnit.AmperePerSquareFoot);
+            var quantity00 = ElectricCurrentDensity<double>.From(1, ElectricCurrentDensityUnit.AmperePerSquareFoot);
             AssertEx.EqualTolerance(1, quantity00.AmperesPerSquareFoot, AmperesPerSquareFootTolerance);
             Assert.Equal(ElectricCurrentDensityUnit.AmperePerSquareFoot, quantity00.Unit);
 
-            var quantity01 = ElectricCurrentDensity.From(1, ElectricCurrentDensityUnit.AmperePerSquareInch);
+            var quantity01 = ElectricCurrentDensity<double>.From(1, ElectricCurrentDensityUnit.AmperePerSquareInch);
             AssertEx.EqualTolerance(1, quantity01.AmperesPerSquareInch, AmperesPerSquareInchTolerance);
             Assert.Equal(ElectricCurrentDensityUnit.AmperePerSquareInch, quantity01.Unit);
 
-            var quantity02 = ElectricCurrentDensity.From(1, ElectricCurrentDensityUnit.AmperePerSquareMeter);
+            var quantity02 = ElectricCurrentDensity<double>.From(1, ElectricCurrentDensityUnit.AmperePerSquareMeter);
             AssertEx.EqualTolerance(1, quantity02.AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
             Assert.Equal(ElectricCurrentDensityUnit.AmperePerSquareMeter, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromAmperesPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity.FromAmperesPerSquareMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity.FromAmperesPerSquareMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromAmperesPerSquareMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity.FromAmperesPerSquareMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            var amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             AssertEx.EqualTolerance(AmperesPerSquareFootInOneAmperePerSquareMeter, amperepersquaremeter.As(ElectricCurrentDensityUnit.AmperePerSquareFoot), AmperesPerSquareFootTolerance);
             AssertEx.EqualTolerance(AmperesPerSquareInchInOneAmperePerSquareMeter, amperepersquaremeter.As(ElectricCurrentDensityUnit.AmperePerSquareInch), AmperesPerSquareInchTolerance);
             AssertEx.EqualTolerance(AmperesPerSquareMeterInOneAmperePerSquareMeter, amperepersquaremeter.As(ElectricCurrentDensityUnit.AmperePerSquareMeter), AmperesPerSquareMeterTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            var amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
 
             var amperepersquarefootQuantity = amperepersquaremeter.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareFoot);
             AssertEx.EqualTolerance(AmperesPerSquareFootInOneAmperePerSquareMeter, (double)amperepersquarefootQuantity.Value, AmperesPerSquareFootTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, ElectricCurrentDensity.FromAmperesPerSquareFoot(amperepersquaremeter.AmperesPerSquareFoot).AmperesPerSquareMeter, AmperesPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentDensity.FromAmperesPerSquareInch(amperepersquaremeter.AmperesPerSquareInch).AmperesPerSquareMeter, AmperesPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentDensity.FromAmperesPerSquareMeter(amperepersquaremeter.AmperesPerSquareMeter).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.FromAmperesPerSquareFoot(amperepersquaremeter.AmperesPerSquareFoot).AmperesPerSquareMeter, AmperesPerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.FromAmperesPerSquareInch(amperepersquaremeter.AmperesPerSquareInch).AmperesPerSquareMeter, AmperesPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(amperepersquaremeter.AmperesPerSquareMeter).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricCurrentDensity v = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> v = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             AssertEx.EqualTolerance(-1, -v.AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentDensity.FromAmperesPerSquareMeter(3)-v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(3)-v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentDensity.FromAmperesPerSquareMeter(10)/5).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricCurrentDensity.FromAmperesPerSquareMeter(10)/ElectricCurrentDensity.FromAmperesPerSquareMeter(5), AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(10)/5).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(10)/ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(5), AmperesPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricCurrentDensity oneAmperePerSquareMeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
-            ElectricCurrentDensity twoAmperesPerSquareMeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(2);
+            ElectricCurrentDensity<double> oneAmperePerSquareMeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> twoAmperesPerSquareMeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(2);
 
             Assert.True(oneAmperePerSquareMeter < twoAmperesPerSquareMeter);
             Assert.True(oneAmperePerSquareMeter <= twoAmperesPerSquareMeter);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             Assert.Equal(0, amperepersquaremeter.CompareTo(amperepersquaremeter));
-            Assert.True(amperepersquaremeter.CompareTo(ElectricCurrentDensity.Zero) > 0);
-            Assert.True(ElectricCurrentDensity.Zero.CompareTo(amperepersquaremeter) < 0);
+            Assert.True(amperepersquaremeter.CompareTo(ElectricCurrentDensity<double>.Zero) > 0);
+            Assert.True(ElectricCurrentDensity<double>.Zero.CompareTo(amperepersquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             Assert.Throws<ArgumentException>(() => amperepersquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             Assert.Throws<ArgumentNullException>(() => amperepersquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
-            var b = ElectricCurrentDensity.FromAmperesPerSquareMeter(2);
+            var a = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            var b = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
-            var b = ElectricCurrentDensity.FromAmperesPerSquareMeter(2);
+            var a = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            var b = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
-            Assert.True(v.Equals(ElectricCurrentDensity.FromAmperesPerSquareMeter(1), AmperesPerSquareMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricCurrentDensity.Zero, AmperesPerSquareMeterTolerance, ComparisonType.Relative));
+            var v = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
+            Assert.True(v.Equals(ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1), AmperesPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCurrentDensity<double>.Zero, AmperesPerSquareMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             Assert.False(amperepersquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
+            ElectricCurrentDensity<double> amperepersquaremeter = ElectricCurrentDensity<double>.FromAmperesPerSquareMeter(1);
             Assert.False(amperepersquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricCurrentDensityUnit.Undefined, ElectricCurrentDensity.Units);
+            Assert.DoesNotContain(ElectricCurrentDensityUnit.Undefined, ElectricCurrentDensity<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricCurrentDensity.BaseDimensions is null);
+            Assert.False(ElectricCurrentDensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs
index 60c2c0e312..0d6980e031 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class ElectricCurrentGradientTestsBase : QuantityTestsBa
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient((double)0.0, ElectricCurrentGradientUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>((double)0.0, ElectricCurrentGradientUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient(double.PositiveInfinity, ElectricCurrentGradientUnit.AmperePerSecond));
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient(double.NegativeInfinity, ElectricCurrentGradientUnit.AmperePerSecond));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>(double.PositiveInfinity, ElectricCurrentGradientUnit.AmperePerSecond));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>(double.NegativeInfinity, ElectricCurrentGradientUnit.AmperePerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient(double.NaN, ElectricCurrentGradientUnit.AmperePerSecond));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrentGradient<double>(double.NaN, ElectricCurrentGradientUnit.AmperePerSecond));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void ElectricCurrentGradient_QuantityInfo_ReturnsQuantityInfoDescribingQu
         [Fact]
         public void AmperePerSecondToElectricCurrentGradientUnits()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             AssertEx.EqualTolerance(AmperesPerMicrosecondInOneAmperePerSecond, amperepersecond.AmperesPerMicrosecond, AmperesPerMicrosecondTolerance);
             AssertEx.EqualTolerance(AmperesPerMillisecondInOneAmperePerSecond, amperepersecond.AmperesPerMillisecond, AmperesPerMillisecondTolerance);
             AssertEx.EqualTolerance(AmperesPerNanosecondInOneAmperePerSecond, amperepersecond.AmperesPerNanosecond, AmperesPerNanosecondTolerance);
@@ -130,19 +130,19 @@ public void AmperePerSecondToElectricCurrentGradientUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerMicrosecond);
+            var quantity00 = ElectricCurrentGradient<double>.From(1, ElectricCurrentGradientUnit.AmperePerMicrosecond);
             AssertEx.EqualTolerance(1, quantity00.AmperesPerMicrosecond, AmperesPerMicrosecondTolerance);
             Assert.Equal(ElectricCurrentGradientUnit.AmperePerMicrosecond, quantity00.Unit);
 
-            var quantity01 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerMillisecond);
+            var quantity01 = ElectricCurrentGradient<double>.From(1, ElectricCurrentGradientUnit.AmperePerMillisecond);
             AssertEx.EqualTolerance(1, quantity01.AmperesPerMillisecond, AmperesPerMillisecondTolerance);
             Assert.Equal(ElectricCurrentGradientUnit.AmperePerMillisecond, quantity01.Unit);
 
-            var quantity02 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerNanosecond);
+            var quantity02 = ElectricCurrentGradient<double>.From(1, ElectricCurrentGradientUnit.AmperePerNanosecond);
             AssertEx.EqualTolerance(1, quantity02.AmperesPerNanosecond, AmperesPerNanosecondTolerance);
             Assert.Equal(ElectricCurrentGradientUnit.AmperePerNanosecond, quantity02.Unit);
 
-            var quantity03 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerSecond);
+            var quantity03 = ElectricCurrentGradient<double>.From(1, ElectricCurrentGradientUnit.AmperePerSecond);
             AssertEx.EqualTolerance(1, quantity03.AmperesPerSecond, AmperesPerSecondTolerance);
             Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromAmperesPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient.FromAmperesPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient.FromAmperesPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient<double>.FromAmperesPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient<double>.FromAmperesPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromAmperesPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient.FromAmperesPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricCurrentGradient<double>.FromAmperesPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            var amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             AssertEx.EqualTolerance(AmperesPerMicrosecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerMicrosecond), AmperesPerMicrosecondTolerance);
             AssertEx.EqualTolerance(AmperesPerMillisecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerMillisecond), AmperesPerMillisecondTolerance);
             AssertEx.EqualTolerance(AmperesPerNanosecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerNanosecond), AmperesPerNanosecondTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            var amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
 
             var amperepermicrosecondQuantity = amperepersecond.ToUnit(ElectricCurrentGradientUnit.AmperePerMicrosecond);
             AssertEx.EqualTolerance(AmperesPerMicrosecondInOneAmperePerSecond, (double)amperepermicrosecondQuantity.Value, AmperesPerMicrosecondTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMicrosecond(amperepersecond.AmperesPerMicrosecond).AmperesPerSecond, AmperesPerMicrosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMillisecond(amperepersecond.AmperesPerMillisecond).AmperesPerSecond, AmperesPerMillisecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerNanosecond(amperepersecond.AmperesPerNanosecond).AmperesPerSecond, AmperesPerNanosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerSecond(amperepersecond.AmperesPerSecond).AmperesPerSecond, AmperesPerSecondTolerance);
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            AssertEx.EqualTolerance(1, ElectricCurrentGradient<double>.FromAmperesPerMicrosecond(amperepersecond.AmperesPerMicrosecond).AmperesPerSecond, AmperesPerMicrosecondTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentGradient<double>.FromAmperesPerMillisecond(amperepersecond.AmperesPerMillisecond).AmperesPerSecond, AmperesPerMillisecondTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentGradient<double>.FromAmperesPerNanosecond(amperepersecond.AmperesPerNanosecond).AmperesPerSecond, AmperesPerNanosecondTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrentGradient<double>.FromAmperesPerSecond(amperepersecond.AmperesPerSecond).AmperesPerSecond, AmperesPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricCurrentGradient v = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> v = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentGradient.FromAmperesPerSecond(3)-v).AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentGradient<double>.FromAmperesPerSecond(3)-v).AmperesPerSecond, AmperesPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).AmperesPerSecond, AmperesPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).AmperesPerSecond, AmperesPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentGradient.FromAmperesPerSecond(10)/5).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, ElectricCurrentGradient.FromAmperesPerSecond(10)/ElectricCurrentGradient.FromAmperesPerSecond(5), AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrentGradient<double>.FromAmperesPerSecond(10)/5).AmperesPerSecond, AmperesPerSecondTolerance);
+            AssertEx.EqualTolerance(2, ElectricCurrentGradient<double>.FromAmperesPerSecond(10)/ElectricCurrentGradient<double>.FromAmperesPerSecond(5), AmperesPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricCurrentGradient oneAmperePerSecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
-            ElectricCurrentGradient twoAmperesPerSecond = ElectricCurrentGradient.FromAmperesPerSecond(2);
+            ElectricCurrentGradient<double> oneAmperePerSecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> twoAmperesPerSecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(2);
 
             Assert.True(oneAmperePerSecond < twoAmperesPerSecond);
             Assert.True(oneAmperePerSecond <= twoAmperesPerSecond);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             Assert.Equal(0, amperepersecond.CompareTo(amperepersecond));
-            Assert.True(amperepersecond.CompareTo(ElectricCurrentGradient.Zero) > 0);
-            Assert.True(ElectricCurrentGradient.Zero.CompareTo(amperepersecond) < 0);
+            Assert.True(amperepersecond.CompareTo(ElectricCurrentGradient<double>.Zero) > 0);
+            Assert.True(ElectricCurrentGradient<double>.Zero.CompareTo(amperepersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             Assert.Throws<ArgumentException>(() => amperepersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => amperepersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricCurrentGradient.FromAmperesPerSecond(1);
-            var b = ElectricCurrentGradient.FromAmperesPerSecond(2);
+            var a = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            var b = ElectricCurrentGradient<double>.FromAmperesPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricCurrentGradient.FromAmperesPerSecond(1);
-            var b = ElectricCurrentGradient.FromAmperesPerSecond(2);
+            var a = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            var b = ElectricCurrentGradient<double>.FromAmperesPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricCurrentGradient.FromAmperesPerSecond(1);
-            Assert.True(v.Equals(ElectricCurrentGradient.FromAmperesPerSecond(1), AmperesPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricCurrentGradient.Zero, AmperesPerSecondTolerance, ComparisonType.Relative));
+            var v = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
+            Assert.True(v.Equals(ElectricCurrentGradient<double>.FromAmperesPerSecond(1), AmperesPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCurrentGradient<double>.Zero, AmperesPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             Assert.False(amperepersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
+            ElectricCurrentGradient<double> amperepersecond = ElectricCurrentGradient<double>.FromAmperesPerSecond(1);
             Assert.False(amperepersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricCurrentGradientUnit.Undefined, ElectricCurrentGradient.Units);
+            Assert.DoesNotContain(ElectricCurrentGradientUnit.Undefined, ElectricCurrentGradient<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricCurrentGradient.BaseDimensions is null);
+            Assert.False(ElectricCurrentGradient<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs
index cc0e631732..0a747a39e9 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs
@@ -60,7 +60,7 @@ public abstract partial class ElectricCurrentTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrent((double)0.0, ElectricCurrentUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>((double)0.0, ElectricCurrentUnit.Undefined));
         }
 
         [Fact]
@@ -75,14 +75,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrent(double.PositiveInfinity, ElectricCurrentUnit.Ampere));
-            Assert.Throws<ArgumentException>(() => new ElectricCurrent(double.NegativeInfinity, ElectricCurrentUnit.Ampere));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>(double.PositiveInfinity, ElectricCurrentUnit.Ampere));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>(double.NegativeInfinity, ElectricCurrentUnit.Ampere));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricCurrent(double.NaN, ElectricCurrentUnit.Ampere));
+            Assert.Throws<ArgumentException>(() => new ElectricCurrent<double>(double.NaN, ElectricCurrentUnit.Ampere));
         }
 
         [Fact]
@@ -128,7 +128,7 @@ public void ElectricCurrent_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void AmpereToElectricCurrentUnits()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
             AssertEx.EqualTolerance(AmperesInOneAmpere, ampere.Amperes, AmperesTolerance);
             AssertEx.EqualTolerance(CentiamperesInOneAmpere, ampere.Centiamperes, CentiamperesTolerance);
             AssertEx.EqualTolerance(KiloamperesInOneAmpere, ampere.Kiloamperes, KiloamperesTolerance);
@@ -142,35 +142,35 @@ public void AmpereToElectricCurrentUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere);
+            var quantity00 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Ampere);
             AssertEx.EqualTolerance(1, quantity00.Amperes, AmperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Ampere, quantity00.Unit);
 
-            var quantity01 = ElectricCurrent.From(1, ElectricCurrentUnit.Centiampere);
+            var quantity01 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Centiampere);
             AssertEx.EqualTolerance(1, quantity01.Centiamperes, CentiamperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Centiampere, quantity01.Unit);
 
-            var quantity02 = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere);
+            var quantity02 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Kiloampere);
             AssertEx.EqualTolerance(1, quantity02.Kiloamperes, KiloamperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Kiloampere, quantity02.Unit);
 
-            var quantity03 = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere);
+            var quantity03 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Megaampere);
             AssertEx.EqualTolerance(1, quantity03.Megaamperes, MegaamperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Megaampere, quantity03.Unit);
 
-            var quantity04 = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere);
+            var quantity04 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Microampere);
             AssertEx.EqualTolerance(1, quantity04.Microamperes, MicroamperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Microampere, quantity04.Unit);
 
-            var quantity05 = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere);
+            var quantity05 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Milliampere);
             AssertEx.EqualTolerance(1, quantity05.Milliamperes, MilliamperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Milliampere, quantity05.Unit);
 
-            var quantity06 = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere);
+            var quantity06 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Nanoampere);
             AssertEx.EqualTolerance(1, quantity06.Nanoamperes, NanoamperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Nanoampere, quantity06.Unit);
 
-            var quantity07 = ElectricCurrent.From(1, ElectricCurrentUnit.Picoampere);
+            var quantity07 = ElectricCurrent<double>.From(1, ElectricCurrentUnit.Picoampere);
             AssertEx.EqualTolerance(1, quantity07.Picoamperes, PicoamperesTolerance);
             Assert.Equal(ElectricCurrentUnit.Picoampere, quantity07.Unit);
 
@@ -179,20 +179,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromAmperes_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCurrent.FromAmperes(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricCurrent.FromAmperes(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrent<double>.FromAmperes(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricCurrent<double>.FromAmperes(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromAmperes_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricCurrent.FromAmperes(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricCurrent<double>.FromAmperes(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var ampere = ElectricCurrent.FromAmperes(1);
+            var ampere = ElectricCurrent<double>.FromAmperes(1);
             AssertEx.EqualTolerance(AmperesInOneAmpere, ampere.As(ElectricCurrentUnit.Ampere), AmperesTolerance);
             AssertEx.EqualTolerance(CentiamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Centiampere), CentiamperesTolerance);
             AssertEx.EqualTolerance(KiloamperesInOneAmpere, ampere.As(ElectricCurrentUnit.Kiloampere), KiloamperesTolerance);
@@ -223,7 +223,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var ampere = ElectricCurrent.FromAmperes(1);
+            var ampere = ElectricCurrent<double>.FromAmperes(1);
 
             var ampereQuantity = ampere.ToUnit(ElectricCurrentUnit.Ampere);
             AssertEx.EqualTolerance(AmperesInOneAmpere, (double)ampereQuantity.Value, AmperesTolerance);
@@ -268,35 +268,35 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromAmperes(ampere.Amperes).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromCentiamperes(ampere.Centiamperes).Amperes, CentiamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromKiloamperes(ampere.Kiloamperes).Amperes, KiloamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromMegaamperes(ampere.Megaamperes).Amperes, MegaamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromMicroamperes(ampere.Microamperes).Amperes, MicroamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromMilliamperes(ampere.Milliamperes).Amperes, MilliamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromNanoamperes(ampere.Nanoamperes).Amperes, NanoamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromPicoamperes(ampere.Picoamperes).Amperes, PicoamperesTolerance);
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromAmperes(ampere.Amperes).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromCentiamperes(ampere.Centiamperes).Amperes, CentiamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromKiloamperes(ampere.Kiloamperes).Amperes, KiloamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromMegaamperes(ampere.Megaamperes).Amperes, MegaamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromMicroamperes(ampere.Microamperes).Amperes, MicroamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromMilliamperes(ampere.Milliamperes).Amperes, MilliamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromNanoamperes(ampere.Nanoamperes).Amperes, NanoamperesTolerance);
+            AssertEx.EqualTolerance(1, ElectricCurrent<double>.FromPicoamperes(ampere.Picoamperes).Amperes, PicoamperesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricCurrent v = ElectricCurrent.FromAmperes(1);
+            ElectricCurrent<double> v = ElectricCurrent<double>.FromAmperes(1);
             AssertEx.EqualTolerance(-1, -v.Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrent.FromAmperes(3)-v).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrent<double>.FromAmperes(3)-v).Amperes, AmperesTolerance);
             AssertEx.EqualTolerance(2, (v + v).Amperes, AmperesTolerance);
             AssertEx.EqualTolerance(10, (v*10).Amperes, AmperesTolerance);
             AssertEx.EqualTolerance(10, (10*v).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrent.FromAmperes(10)/5).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(2, ElectricCurrent.FromAmperes(10)/ElectricCurrent.FromAmperes(5), AmperesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricCurrent<double>.FromAmperes(10)/5).Amperes, AmperesTolerance);
+            AssertEx.EqualTolerance(2, ElectricCurrent<double>.FromAmperes(10)/ElectricCurrent<double>.FromAmperes(5), AmperesTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricCurrent oneAmpere = ElectricCurrent.FromAmperes(1);
-            ElectricCurrent twoAmperes = ElectricCurrent.FromAmperes(2);
+            ElectricCurrent<double> oneAmpere = ElectricCurrent<double>.FromAmperes(1);
+            ElectricCurrent<double> twoAmperes = ElectricCurrent<double>.FromAmperes(2);
 
             Assert.True(oneAmpere < twoAmperes);
             Assert.True(oneAmpere <= twoAmperes);
@@ -312,31 +312,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
             Assert.Equal(0, ampere.CompareTo(ampere));
-            Assert.True(ampere.CompareTo(ElectricCurrent.Zero) > 0);
-            Assert.True(ElectricCurrent.Zero.CompareTo(ampere) < 0);
+            Assert.True(ampere.CompareTo(ElectricCurrent<double>.Zero) > 0);
+            Assert.True(ElectricCurrent<double>.Zero.CompareTo(ampere) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
             Assert.Throws<ArgumentException>(() => ampere.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
             Assert.Throws<ArgumentNullException>(() => ampere.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricCurrent.FromAmperes(1);
-            var b = ElectricCurrent.FromAmperes(2);
+            var a = ElectricCurrent<double>.FromAmperes(1);
+            var b = ElectricCurrent<double>.FromAmperes(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -355,8 +355,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricCurrent.FromAmperes(1);
-            var b = ElectricCurrent.FromAmperes(2);
+            var a = ElectricCurrent<double>.FromAmperes(1);
+            var b = ElectricCurrent<double>.FromAmperes(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -376,9 +376,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricCurrent.FromAmperes(1);
-            Assert.True(v.Equals(ElectricCurrent.FromAmperes(1), AmperesTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricCurrent.Zero, AmperesTolerance, ComparisonType.Relative));
+            var v = ElectricCurrent<double>.FromAmperes(1);
+            Assert.True(v.Equals(ElectricCurrent<double>.FromAmperes(1), AmperesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricCurrent<double>.Zero, AmperesTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -391,21 +391,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
             Assert.False(ampere.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
+            ElectricCurrent<double> ampere = ElectricCurrent<double>.FromAmperes(1);
             Assert.False(ampere.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricCurrentUnit.Undefined, ElectricCurrent.Units);
+            Assert.DoesNotContain(ElectricCurrentUnit.Undefined, ElectricCurrent<double>.Units);
         }
 
         [Fact]
@@ -424,7 +424,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricCurrent.BaseDimensions is null);
+            Assert.False(ElectricCurrent<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs
index 4addc812cc..a4ae65d2db 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class ElectricFieldTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricField((double)0.0, ElectricFieldUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>((double)0.0, ElectricFieldUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricField(double.PositiveInfinity, ElectricFieldUnit.VoltPerMeter));
-            Assert.Throws<ArgumentException>(() => new ElectricField(double.NegativeInfinity, ElectricFieldUnit.VoltPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>(double.PositiveInfinity, ElectricFieldUnit.VoltPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>(double.NegativeInfinity, ElectricFieldUnit.VoltPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricField(double.NaN, ElectricFieldUnit.VoltPerMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricField<double>(double.NaN, ElectricFieldUnit.VoltPerMeter));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void ElectricField_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void VoltPerMeterToElectricFieldUnits()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
             AssertEx.EqualTolerance(VoltsPerMeterInOneVoltPerMeter, voltpermeter.VoltsPerMeter, VoltsPerMeterTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricField.From(1, ElectricFieldUnit.VoltPerMeter);
+            var quantity00 = ElectricField<double>.From(1, ElectricFieldUnit.VoltPerMeter);
             AssertEx.EqualTolerance(1, quantity00.VoltsPerMeter, VoltsPerMeterTolerance);
             Assert.Equal(ElectricFieldUnit.VoltPerMeter, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltsPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricField.FromVoltsPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricField.FromVoltsPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricField<double>.FromVoltsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricField<double>.FromVoltsPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltsPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricField.FromVoltsPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricField<double>.FromVoltsPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            var voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
             AssertEx.EqualTolerance(VoltsPerMeterInOneVoltPerMeter, voltpermeter.As(ElectricFieldUnit.VoltPerMeter), VoltsPerMeterTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            var voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
 
             var voltpermeterQuantity = voltpermeter.ToUnit(ElectricFieldUnit.VoltPerMeter);
             AssertEx.EqualTolerance(VoltsPerMeterInOneVoltPerMeter, (double)voltpermeterQuantity.Value, VoltsPerMeterTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
-            AssertEx.EqualTolerance(1, ElectricField.FromVoltsPerMeter(voltpermeter.VoltsPerMeter).VoltsPerMeter, VoltsPerMeterTolerance);
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
+            AssertEx.EqualTolerance(1, ElectricField<double>.FromVoltsPerMeter(voltpermeter.VoltsPerMeter).VoltsPerMeter, VoltsPerMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricField v = ElectricField.FromVoltsPerMeter(1);
+            ElectricField<double> v = ElectricField<double>.FromVoltsPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricField.FromVoltsPerMeter(3)-v).VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricField<double>.FromVoltsPerMeter(3)-v).VoltsPerMeter, VoltsPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).VoltsPerMeter, VoltsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).VoltsPerMeter, VoltsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricField.FromVoltsPerMeter(10)/5).VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricField.FromVoltsPerMeter(10)/ElectricField.FromVoltsPerMeter(5), VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricField<double>.FromVoltsPerMeter(10)/5).VoltsPerMeter, VoltsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricField<double>.FromVoltsPerMeter(10)/ElectricField<double>.FromVoltsPerMeter(5), VoltsPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricField oneVoltPerMeter = ElectricField.FromVoltsPerMeter(1);
-            ElectricField twoVoltsPerMeter = ElectricField.FromVoltsPerMeter(2);
+            ElectricField<double> oneVoltPerMeter = ElectricField<double>.FromVoltsPerMeter(1);
+            ElectricField<double> twoVoltsPerMeter = ElectricField<double>.FromVoltsPerMeter(2);
 
             Assert.True(oneVoltPerMeter < twoVoltsPerMeter);
             Assert.True(oneVoltPerMeter <= twoVoltsPerMeter);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
             Assert.Equal(0, voltpermeter.CompareTo(voltpermeter));
-            Assert.True(voltpermeter.CompareTo(ElectricField.Zero) > 0);
-            Assert.True(ElectricField.Zero.CompareTo(voltpermeter) < 0);
+            Assert.True(voltpermeter.CompareTo(ElectricField<double>.Zero) > 0);
+            Assert.True(ElectricField<double>.Zero.CompareTo(voltpermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
             Assert.Throws<ArgumentException>(() => voltpermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => voltpermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricField.FromVoltsPerMeter(1);
-            var b = ElectricField.FromVoltsPerMeter(2);
+            var a = ElectricField<double>.FromVoltsPerMeter(1);
+            var b = ElectricField<double>.FromVoltsPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricField.FromVoltsPerMeter(1);
-            var b = ElectricField.FromVoltsPerMeter(2);
+            var a = ElectricField<double>.FromVoltsPerMeter(1);
+            var b = ElectricField<double>.FromVoltsPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricField.FromVoltsPerMeter(1);
-            Assert.True(v.Equals(ElectricField.FromVoltsPerMeter(1), VoltsPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricField.Zero, VoltsPerMeterTolerance, ComparisonType.Relative));
+            var v = ElectricField<double>.FromVoltsPerMeter(1);
+            Assert.True(v.Equals(ElectricField<double>.FromVoltsPerMeter(1), VoltsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricField<double>.Zero, VoltsPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
             Assert.False(voltpermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
+            ElectricField<double> voltpermeter = ElectricField<double>.FromVoltsPerMeter(1);
             Assert.False(voltpermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricFieldUnit.Undefined, ElectricField.Units);
+            Assert.DoesNotContain(ElectricFieldUnit.Undefined, ElectricField<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricField.BaseDimensions is null);
+            Assert.False(ElectricField<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs
index 391f99ff85..b5cd3b06f5 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class ElectricInductanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricInductance((double)0.0, ElectricInductanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>((double)0.0, ElectricInductanceUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricInductance(double.PositiveInfinity, ElectricInductanceUnit.Henry));
-            Assert.Throws<ArgumentException>(() => new ElectricInductance(double.NegativeInfinity, ElectricInductanceUnit.Henry));
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>(double.PositiveInfinity, ElectricInductanceUnit.Henry));
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>(double.NegativeInfinity, ElectricInductanceUnit.Henry));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricInductance(double.NaN, ElectricInductanceUnit.Henry));
+            Assert.Throws<ArgumentException>(() => new ElectricInductance<double>(double.NaN, ElectricInductanceUnit.Henry));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void ElectricInductance_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
         [Fact]
         public void HenryToElectricInductanceUnits()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
             AssertEx.EqualTolerance(HenriesInOneHenry, henry.Henries, HenriesTolerance);
             AssertEx.EqualTolerance(MicrohenriesInOneHenry, henry.Microhenries, MicrohenriesTolerance);
             AssertEx.EqualTolerance(MillihenriesInOneHenry, henry.Millihenries, MillihenriesTolerance);
@@ -130,19 +130,19 @@ public void HenryToElectricInductanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricInductance.From(1, ElectricInductanceUnit.Henry);
+            var quantity00 = ElectricInductance<double>.From(1, ElectricInductanceUnit.Henry);
             AssertEx.EqualTolerance(1, quantity00.Henries, HenriesTolerance);
             Assert.Equal(ElectricInductanceUnit.Henry, quantity00.Unit);
 
-            var quantity01 = ElectricInductance.From(1, ElectricInductanceUnit.Microhenry);
+            var quantity01 = ElectricInductance<double>.From(1, ElectricInductanceUnit.Microhenry);
             AssertEx.EqualTolerance(1, quantity01.Microhenries, MicrohenriesTolerance);
             Assert.Equal(ElectricInductanceUnit.Microhenry, quantity01.Unit);
 
-            var quantity02 = ElectricInductance.From(1, ElectricInductanceUnit.Millihenry);
+            var quantity02 = ElectricInductance<double>.From(1, ElectricInductanceUnit.Millihenry);
             AssertEx.EqualTolerance(1, quantity02.Millihenries, MillihenriesTolerance);
             Assert.Equal(ElectricInductanceUnit.Millihenry, quantity02.Unit);
 
-            var quantity03 = ElectricInductance.From(1, ElectricInductanceUnit.Nanohenry);
+            var quantity03 = ElectricInductance<double>.From(1, ElectricInductanceUnit.Nanohenry);
             AssertEx.EqualTolerance(1, quantity03.Nanohenries, NanohenriesTolerance);
             Assert.Equal(ElectricInductanceUnit.Nanohenry, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromHenries_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricInductance.FromHenries(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricInductance.FromHenries(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricInductance<double>.FromHenries(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricInductance<double>.FromHenries(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromHenries_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricInductance.FromHenries(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricInductance<double>.FromHenries(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var henry = ElectricInductance.FromHenries(1);
+            var henry = ElectricInductance<double>.FromHenries(1);
             AssertEx.EqualTolerance(HenriesInOneHenry, henry.As(ElectricInductanceUnit.Henry), HenriesTolerance);
             AssertEx.EqualTolerance(MicrohenriesInOneHenry, henry.As(ElectricInductanceUnit.Microhenry), MicrohenriesTolerance);
             AssertEx.EqualTolerance(MillihenriesInOneHenry, henry.As(ElectricInductanceUnit.Millihenry), MillihenriesTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var henry = ElectricInductance.FromHenries(1);
+            var henry = ElectricInductance<double>.FromHenries(1);
 
             var henryQuantity = henry.ToUnit(ElectricInductanceUnit.Henry);
             AssertEx.EqualTolerance(HenriesInOneHenry, (double)henryQuantity.Value, HenriesTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromHenries(henry.Henries).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromMicrohenries(henry.Microhenries).Henries, MicrohenriesTolerance);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromMillihenries(henry.Millihenries).Henries, MillihenriesTolerance);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromNanohenries(henry.Nanohenries).Henries, NanohenriesTolerance);
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromHenries(henry.Henries).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromMicrohenries(henry.Microhenries).Henries, MicrohenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromMillihenries(henry.Millihenries).Henries, MillihenriesTolerance);
+            AssertEx.EqualTolerance(1, ElectricInductance<double>.FromNanohenries(henry.Nanohenries).Henries, NanohenriesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricInductance v = ElectricInductance.FromHenries(1);
+            ElectricInductance<double> v = ElectricInductance<double>.FromHenries(1);
             AssertEx.EqualTolerance(-1, -v.Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricInductance.FromHenries(3)-v).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricInductance<double>.FromHenries(3)-v).Henries, HenriesTolerance);
             AssertEx.EqualTolerance(2, (v + v).Henries, HenriesTolerance);
             AssertEx.EqualTolerance(10, (v*10).Henries, HenriesTolerance);
             AssertEx.EqualTolerance(10, (10*v).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricInductance.FromHenries(10)/5).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(2, ElectricInductance.FromHenries(10)/ElectricInductance.FromHenries(5), HenriesTolerance);
+            AssertEx.EqualTolerance(2, (ElectricInductance<double>.FromHenries(10)/5).Henries, HenriesTolerance);
+            AssertEx.EqualTolerance(2, ElectricInductance<double>.FromHenries(10)/ElectricInductance<double>.FromHenries(5), HenriesTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricInductance oneHenry = ElectricInductance.FromHenries(1);
-            ElectricInductance twoHenries = ElectricInductance.FromHenries(2);
+            ElectricInductance<double> oneHenry = ElectricInductance<double>.FromHenries(1);
+            ElectricInductance<double> twoHenries = ElectricInductance<double>.FromHenries(2);
 
             Assert.True(oneHenry < twoHenries);
             Assert.True(oneHenry <= twoHenries);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
             Assert.Equal(0, henry.CompareTo(henry));
-            Assert.True(henry.CompareTo(ElectricInductance.Zero) > 0);
-            Assert.True(ElectricInductance.Zero.CompareTo(henry) < 0);
+            Assert.True(henry.CompareTo(ElectricInductance<double>.Zero) > 0);
+            Assert.True(ElectricInductance<double>.Zero.CompareTo(henry) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
             Assert.Throws<ArgumentException>(() => henry.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
             Assert.Throws<ArgumentNullException>(() => henry.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricInductance.FromHenries(1);
-            var b = ElectricInductance.FromHenries(2);
+            var a = ElectricInductance<double>.FromHenries(1);
+            var b = ElectricInductance<double>.FromHenries(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricInductance.FromHenries(1);
-            var b = ElectricInductance.FromHenries(2);
+            var a = ElectricInductance<double>.FromHenries(1);
+            var b = ElectricInductance<double>.FromHenries(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricInductance.FromHenries(1);
-            Assert.True(v.Equals(ElectricInductance.FromHenries(1), HenriesTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricInductance.Zero, HenriesTolerance, ComparisonType.Relative));
+            var v = ElectricInductance<double>.FromHenries(1);
+            Assert.True(v.Equals(ElectricInductance<double>.FromHenries(1), HenriesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricInductance<double>.Zero, HenriesTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
             Assert.False(henry.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
+            ElectricInductance<double> henry = ElectricInductance<double>.FromHenries(1);
             Assert.False(henry.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricInductanceUnit.Undefined, ElectricInductance.Units);
+            Assert.DoesNotContain(ElectricInductanceUnit.Undefined, ElectricInductance<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricInductance.BaseDimensions is null);
+            Assert.False(ElectricInductance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialAcTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialAcTestsBase.g.cs
index 78023e6689..cf4e7ccfe1 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialAcTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialAcTestsBase.g.cs
@@ -54,7 +54,7 @@ public abstract partial class ElectricPotentialAcTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc((double)0.0, ElectricPotentialAcUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>((double)0.0, ElectricPotentialAcUnit.Undefined));
         }
 
         [Fact]
@@ -69,14 +69,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc(double.PositiveInfinity, ElectricPotentialAcUnit.VoltAc));
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc(double.NegativeInfinity, ElectricPotentialAcUnit.VoltAc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>(double.PositiveInfinity, ElectricPotentialAcUnit.VoltAc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>(double.NegativeInfinity, ElectricPotentialAcUnit.VoltAc));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc(double.NaN, ElectricPotentialAcUnit.VoltAc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialAc<double>(double.NaN, ElectricPotentialAcUnit.VoltAc));
         }
 
         [Fact]
@@ -122,7 +122,7 @@ public void ElectricPotentialAc_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void VoltAcToElectricPotentialAcUnits()
         {
-            ElectricPotentialAc voltac = ElectricPotentialAc.FromVoltsAc(1);
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
             AssertEx.EqualTolerance(KilovoltsAcInOneVoltAc, voltac.KilovoltsAc, KilovoltsAcTolerance);
             AssertEx.EqualTolerance(MegavoltsAcInOneVoltAc, voltac.MegavoltsAc, MegavoltsAcTolerance);
             AssertEx.EqualTolerance(MicrovoltsAcInOneVoltAc, voltac.MicrovoltsAc, MicrovoltsAcTolerance);
@@ -133,23 +133,23 @@ public void VoltAcToElectricPotentialAcUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricPotentialAc.From(1, ElectricPotentialAcUnit.KilovoltAc);
+            var quantity00 = ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.KilovoltAc);
             AssertEx.EqualTolerance(1, quantity00.KilovoltsAc, KilovoltsAcTolerance);
             Assert.Equal(ElectricPotentialAcUnit.KilovoltAc, quantity00.Unit);
 
-            var quantity01 = ElectricPotentialAc.From(1, ElectricPotentialAcUnit.MegavoltAc);
+            var quantity01 = ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.MegavoltAc);
             AssertEx.EqualTolerance(1, quantity01.MegavoltsAc, MegavoltsAcTolerance);
             Assert.Equal(ElectricPotentialAcUnit.MegavoltAc, quantity01.Unit);
 
-            var quantity02 = ElectricPotentialAc.From(1, ElectricPotentialAcUnit.MicrovoltAc);
+            var quantity02 = ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.MicrovoltAc);
             AssertEx.EqualTolerance(1, quantity02.MicrovoltsAc, MicrovoltsAcTolerance);
             Assert.Equal(ElectricPotentialAcUnit.MicrovoltAc, quantity02.Unit);
 
-            var quantity03 = ElectricPotentialAc.From(1, ElectricPotentialAcUnit.MillivoltAc);
+            var quantity03 = ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.MillivoltAc);
             AssertEx.EqualTolerance(1, quantity03.MillivoltsAc, MillivoltsAcTolerance);
             Assert.Equal(ElectricPotentialAcUnit.MillivoltAc, quantity03.Unit);
 
-            var quantity04 = ElectricPotentialAc.From(1, ElectricPotentialAcUnit.VoltAc);
+            var quantity04 = ElectricPotentialAc<double>.From(1, ElectricPotentialAcUnit.VoltAc);
             AssertEx.EqualTolerance(1, quantity04.VoltsAc, VoltsAcTolerance);
             Assert.Equal(ElectricPotentialAcUnit.VoltAc, quantity04.Unit);
 
@@ -158,20 +158,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltsAc_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotentialAc.FromVoltsAc(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricPotentialAc.FromVoltsAc(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialAc<double>.FromVoltsAc(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialAc<double>.FromVoltsAc(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltsAc_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotentialAc.FromVoltsAc(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialAc<double>.FromVoltsAc(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltac = ElectricPotentialAc.FromVoltsAc(1);
+            var voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
             AssertEx.EqualTolerance(KilovoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.KilovoltAc), KilovoltsAcTolerance);
             AssertEx.EqualTolerance(MegavoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.MegavoltAc), MegavoltsAcTolerance);
             AssertEx.EqualTolerance(MicrovoltsAcInOneVoltAc, voltac.As(ElectricPotentialAcUnit.MicrovoltAc), MicrovoltsAcTolerance);
@@ -199,7 +199,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltac = ElectricPotentialAc.FromVoltsAc(1);
+            var voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
 
             var kilovoltacQuantity = voltac.ToUnit(ElectricPotentialAcUnit.KilovoltAc);
             AssertEx.EqualTolerance(KilovoltsAcInOneVoltAc, (double)kilovoltacQuantity.Value, KilovoltsAcTolerance);
@@ -232,32 +232,32 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricPotentialAc voltac = ElectricPotentialAc.FromVoltsAc(1);
-            AssertEx.EqualTolerance(1, ElectricPotentialAc.FromKilovoltsAc(voltac.KilovoltsAc).VoltsAc, KilovoltsAcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialAc.FromMegavoltsAc(voltac.MegavoltsAc).VoltsAc, MegavoltsAcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialAc.FromMicrovoltsAc(voltac.MicrovoltsAc).VoltsAc, MicrovoltsAcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialAc.FromMillivoltsAc(voltac.MillivoltsAc).VoltsAc, MillivoltsAcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialAc.FromVoltsAc(voltac.VoltsAc).VoltsAc, VoltsAcTolerance);
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromKilovoltsAc(voltac.KilovoltsAc).VoltsAc, KilovoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromMegavoltsAc(voltac.MegavoltsAc).VoltsAc, MegavoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromMicrovoltsAc(voltac.MicrovoltsAc).VoltsAc, MicrovoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromMillivoltsAc(voltac.MillivoltsAc).VoltsAc, MillivoltsAcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialAc<double>.FromVoltsAc(voltac.VoltsAc).VoltsAc, VoltsAcTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricPotentialAc v = ElectricPotentialAc.FromVoltsAc(1);
+            ElectricPotentialAc<double> v = ElectricPotentialAc<double>.FromVoltsAc(1);
             AssertEx.EqualTolerance(-1, -v.VoltsAc, VoltsAcTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialAc.FromVoltsAc(3)-v).VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialAc<double>.FromVoltsAc(3)-v).VoltsAc, VoltsAcTolerance);
             AssertEx.EqualTolerance(2, (v + v).VoltsAc, VoltsAcTolerance);
             AssertEx.EqualTolerance(10, (v*10).VoltsAc, VoltsAcTolerance);
             AssertEx.EqualTolerance(10, (10*v).VoltsAc, VoltsAcTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialAc.FromVoltsAc(10)/5).VoltsAc, VoltsAcTolerance);
-            AssertEx.EqualTolerance(2, ElectricPotentialAc.FromVoltsAc(10)/ElectricPotentialAc.FromVoltsAc(5), VoltsAcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialAc<double>.FromVoltsAc(10)/5).VoltsAc, VoltsAcTolerance);
+            AssertEx.EqualTolerance(2, ElectricPotentialAc<double>.FromVoltsAc(10)/ElectricPotentialAc<double>.FromVoltsAc(5), VoltsAcTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricPotentialAc oneVoltAc = ElectricPotentialAc.FromVoltsAc(1);
-            ElectricPotentialAc twoVoltsAc = ElectricPotentialAc.FromVoltsAc(2);
+            ElectricPotentialAc<double> oneVoltAc = ElectricPotentialAc<double>.FromVoltsAc(1);
+            ElectricPotentialAc<double> twoVoltsAc = ElectricPotentialAc<double>.FromVoltsAc(2);
 
             Assert.True(oneVoltAc < twoVoltsAc);
             Assert.True(oneVoltAc <= twoVoltsAc);
@@ -273,31 +273,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricPotentialAc voltac = ElectricPotentialAc.FromVoltsAc(1);
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
             Assert.Equal(0, voltac.CompareTo(voltac));
-            Assert.True(voltac.CompareTo(ElectricPotentialAc.Zero) > 0);
-            Assert.True(ElectricPotentialAc.Zero.CompareTo(voltac) < 0);
+            Assert.True(voltac.CompareTo(ElectricPotentialAc<double>.Zero) > 0);
+            Assert.True(ElectricPotentialAc<double>.Zero.CompareTo(voltac) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricPotentialAc voltac = ElectricPotentialAc.FromVoltsAc(1);
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
             Assert.Throws<ArgumentException>(() => voltac.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricPotentialAc voltac = ElectricPotentialAc.FromVoltsAc(1);
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
             Assert.Throws<ArgumentNullException>(() => voltac.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricPotentialAc.FromVoltsAc(1);
-            var b = ElectricPotentialAc.FromVoltsAc(2);
+            var a = ElectricPotentialAc<double>.FromVoltsAc(1);
+            var b = ElectricPotentialAc<double>.FromVoltsAc(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -316,8 +316,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricPotentialAc.FromVoltsAc(1);
-            var b = ElectricPotentialAc.FromVoltsAc(2);
+            var a = ElectricPotentialAc<double>.FromVoltsAc(1);
+            var b = ElectricPotentialAc<double>.FromVoltsAc(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -337,9 +337,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricPotentialAc.FromVoltsAc(1);
-            Assert.True(v.Equals(ElectricPotentialAc.FromVoltsAc(1), VoltsAcTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricPotentialAc.Zero, VoltsAcTolerance, ComparisonType.Relative));
+            var v = ElectricPotentialAc<double>.FromVoltsAc(1);
+            Assert.True(v.Equals(ElectricPotentialAc<double>.FromVoltsAc(1), VoltsAcTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricPotentialAc<double>.Zero, VoltsAcTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -352,21 +352,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricPotentialAc voltac = ElectricPotentialAc.FromVoltsAc(1);
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
             Assert.False(voltac.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricPotentialAc voltac = ElectricPotentialAc.FromVoltsAc(1);
+            ElectricPotentialAc<double> voltac = ElectricPotentialAc<double>.FromVoltsAc(1);
             Assert.False(voltac.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricPotentialAcUnit.Undefined, ElectricPotentialAc.Units);
+            Assert.DoesNotContain(ElectricPotentialAcUnit.Undefined, ElectricPotentialAc<double>.Units);
         }
 
         [Fact]
@@ -385,7 +385,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricPotentialAc.BaseDimensions is null);
+            Assert.False(ElectricPotentialAc<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs
index 6693f2b0f8..5f47a68efc 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs
@@ -84,7 +84,7 @@ public abstract partial class ElectricPotentialChangeRateTestsBase : QuantityTes
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate((double)0.0, ElectricPotentialChangeRateUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate<double>((double)0.0, ElectricPotentialChangeRateUnit.Undefined));
         }
 
         [Fact]
@@ -99,14 +99,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate(double.PositiveInfinity, ElectricPotentialChangeRateUnit.VoltPerSecond));
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate(double.NegativeInfinity, ElectricPotentialChangeRateUnit.VoltPerSecond));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate<double>(double.PositiveInfinity, ElectricPotentialChangeRateUnit.VoltPerSecond));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate<double>(double.NegativeInfinity, ElectricPotentialChangeRateUnit.VoltPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate(double.NaN, ElectricPotentialChangeRateUnit.VoltPerSecond));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialChangeRate<double>(double.NaN, ElectricPotentialChangeRateUnit.VoltPerSecond));
         }
 
         [Fact]
@@ -152,7 +152,7 @@ public void ElectricPotentialChangeRate_QuantityInfo_ReturnsQuantityInfoDescribi
         [Fact]
         public void VoltPerSecondToElectricPotentialChangeRateUnits()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             AssertEx.EqualTolerance(KilovoltsPerHoursInOneVoltPerSecond, voltpersecond.KilovoltsPerHours, KilovoltsPerHoursTolerance);
             AssertEx.EqualTolerance(KilovoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.KilovoltsPerMicroseconds, KilovoltsPerMicrosecondsTolerance);
             AssertEx.EqualTolerance(KilovoltsPerMinutesInOneVoltPerSecond, voltpersecond.KilovoltsPerMinutes, KilovoltsPerMinutesTolerance);
@@ -178,83 +178,83 @@ public void VoltPerSecondToElectricPotentialChangeRateUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerHour);
+            var quantity00 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.KilovoltPerHour);
             AssertEx.EqualTolerance(1, quantity00.KilovoltsPerHours, KilovoltsPerHoursTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerHour, quantity00.Unit);
 
-            var quantity01 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
+            var quantity01 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
             AssertEx.EqualTolerance(1, quantity01.KilovoltsPerMicroseconds, KilovoltsPerMicrosecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, quantity01.Unit);
 
-            var quantity02 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
+            var quantity02 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
             AssertEx.EqualTolerance(1, quantity02.KilovoltsPerMinutes, KilovoltsPerMinutesTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMinute, quantity02.Unit);
 
-            var quantity03 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
+            var quantity03 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
             AssertEx.EqualTolerance(1, quantity03.KilovoltsPerSeconds, KilovoltsPerSecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerSecond, quantity03.Unit);
 
-            var quantity04 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerHour);
+            var quantity04 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MegavoltPerHour);
             AssertEx.EqualTolerance(1, quantity04.MegavoltsPerHours, MegavoltsPerHoursTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerHour, quantity04.Unit);
 
-            var quantity05 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
+            var quantity05 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
             AssertEx.EqualTolerance(1, quantity05.MegavoltsPerMicroseconds, MegavoltsPerMicrosecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, quantity05.Unit);
 
-            var quantity06 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
+            var quantity06 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
             AssertEx.EqualTolerance(1, quantity06.MegavoltsPerMinutes, MegavoltsPerMinutesTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerMinute, quantity06.Unit);
 
-            var quantity07 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
+            var quantity07 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
             AssertEx.EqualTolerance(1, quantity07.MegavoltsPerSeconds, MegavoltsPerSecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerSecond, quantity07.Unit);
 
-            var quantity08 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
+            var quantity08 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
             AssertEx.EqualTolerance(1, quantity08.MicrovoltsPerHours, MicrovoltsPerHoursTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerHour, quantity08.Unit);
 
-            var quantity09 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
+            var quantity09 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
             AssertEx.EqualTolerance(1, quantity09.MicrovoltsPerMicroseconds, MicrovoltsPerMicrosecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, quantity09.Unit);
 
-            var quantity10 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
+            var quantity10 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
             AssertEx.EqualTolerance(1, quantity10.MicrovoltsPerMinutes, MicrovoltsPerMinutesTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, quantity10.Unit);
 
-            var quantity11 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
+            var quantity11 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
             AssertEx.EqualTolerance(1, quantity11.MicrovoltsPerSeconds, MicrovoltsPerSecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, quantity11.Unit);
 
-            var quantity12 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerHour);
+            var quantity12 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MillivoltPerHour);
             AssertEx.EqualTolerance(1, quantity12.MillivoltsPerHours, MillivoltsPerHoursTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerHour, quantity12.Unit);
 
-            var quantity13 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
+            var quantity13 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
             AssertEx.EqualTolerance(1, quantity13.MillivoltsPerMicroseconds, MillivoltsPerMicrosecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, quantity13.Unit);
 
-            var quantity14 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
+            var quantity14 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
             AssertEx.EqualTolerance(1, quantity14.MillivoltsPerMinutes, MillivoltsPerMinutesTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerMinute, quantity14.Unit);
 
-            var quantity15 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
+            var quantity15 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
             AssertEx.EqualTolerance(1, quantity15.MillivoltsPerSeconds, MillivoltsPerSecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerSecond, quantity15.Unit);
 
-            var quantity16 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerHour);
+            var quantity16 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.VoltPerHour);
             AssertEx.EqualTolerance(1, quantity16.VoltsPerHours, VoltsPerHoursTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerHour, quantity16.Unit);
 
-            var quantity17 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
+            var quantity17 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
             AssertEx.EqualTolerance(1, quantity17.VoltsPerMicroseconds, VoltsPerMicrosecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, quantity17.Unit);
 
-            var quantity18 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerMinute);
+            var quantity18 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.VoltPerMinute);
             AssertEx.EqualTolerance(1, quantity18.VoltsPerMinutes, VoltsPerMinutesTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMinute, quantity18.Unit);
 
-            var quantity19 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerSecond);
+            var quantity19 = ElectricPotentialChangeRate<double>.From(1, ElectricPotentialChangeRateUnit.VoltPerSecond);
             AssertEx.EqualTolerance(1, quantity19.VoltsPerSeconds, VoltsPerSecondsTolerance);
             Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerSecond, quantity19.Unit);
 
@@ -263,20 +263,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltsPerSeconds_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotentialChangeRate.FromVoltsPerSeconds(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricPotentialChangeRate.FromVoltsPerSeconds(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltsPerSeconds_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotentialChangeRate.FromVoltsPerSeconds(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            var voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             AssertEx.EqualTolerance(KilovoltsPerHoursInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerHour), KilovoltsPerHoursTolerance);
             AssertEx.EqualTolerance(KilovoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond), KilovoltsPerMicrosecondsTolerance);
             AssertEx.EqualTolerance(KilovoltsPerMinutesInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerMinute), KilovoltsPerMinutesTolerance);
@@ -319,7 +319,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            var voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
 
             var kilovoltperhourQuantity = voltpersecond.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerHour);
             AssertEx.EqualTolerance(KilovoltsPerHoursInOneVoltPerSecond, (double)kilovoltperhourQuantity.Value, KilovoltsPerHoursTolerance);
@@ -412,47 +412,47 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerHours(voltpersecond.KilovoltsPerHours).VoltsPerSeconds, KilovoltsPerHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMicroseconds(voltpersecond.KilovoltsPerMicroseconds).VoltsPerSeconds, KilovoltsPerMicrosecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMinutes(voltpersecond.KilovoltsPerMinutes).VoltsPerSeconds, KilovoltsPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerSeconds(voltpersecond.KilovoltsPerSeconds).VoltsPerSeconds, KilovoltsPerSecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerHours(voltpersecond.MegavoltsPerHours).VoltsPerSeconds, MegavoltsPerHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMicroseconds(voltpersecond.MegavoltsPerMicroseconds).VoltsPerSeconds, MegavoltsPerMicrosecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMinutes(voltpersecond.MegavoltsPerMinutes).VoltsPerSeconds, MegavoltsPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerSeconds(voltpersecond.MegavoltsPerSeconds).VoltsPerSeconds, MegavoltsPerSecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerHours(voltpersecond.MicrovoltsPerHours).VoltsPerSeconds, MicrovoltsPerHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMicroseconds(voltpersecond.MicrovoltsPerMicroseconds).VoltsPerSeconds, MicrovoltsPerMicrosecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMinutes(voltpersecond.MicrovoltsPerMinutes).VoltsPerSeconds, MicrovoltsPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerSeconds(voltpersecond.MicrovoltsPerSeconds).VoltsPerSeconds, MicrovoltsPerSecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerHours(voltpersecond.MillivoltsPerHours).VoltsPerSeconds, MillivoltsPerHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMicroseconds(voltpersecond.MillivoltsPerMicroseconds).VoltsPerSeconds, MillivoltsPerMicrosecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMinutes(voltpersecond.MillivoltsPerMinutes).VoltsPerSeconds, MillivoltsPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerSeconds(voltpersecond.MillivoltsPerSeconds).VoltsPerSeconds, MillivoltsPerSecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerHours(voltpersecond.VoltsPerHours).VoltsPerSeconds, VoltsPerHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMicroseconds(voltpersecond.VoltsPerMicroseconds).VoltsPerSeconds, VoltsPerMicrosecondsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMinutes(voltpersecond.VoltsPerMinutes).VoltsPerSeconds, VoltsPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerSeconds(voltpersecond.VoltsPerSeconds).VoltsPerSeconds, VoltsPerSecondsTolerance);
+            ElectricPotentialChangeRate<double> voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromKilovoltsPerHours(voltpersecond.KilovoltsPerHours).VoltsPerSeconds, KilovoltsPerHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromKilovoltsPerMicroseconds(voltpersecond.KilovoltsPerMicroseconds).VoltsPerSeconds, KilovoltsPerMicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromKilovoltsPerMinutes(voltpersecond.KilovoltsPerMinutes).VoltsPerSeconds, KilovoltsPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromKilovoltsPerSeconds(voltpersecond.KilovoltsPerSeconds).VoltsPerSeconds, KilovoltsPerSecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMegavoltsPerHours(voltpersecond.MegavoltsPerHours).VoltsPerSeconds, MegavoltsPerHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMegavoltsPerMicroseconds(voltpersecond.MegavoltsPerMicroseconds).VoltsPerSeconds, MegavoltsPerMicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMegavoltsPerMinutes(voltpersecond.MegavoltsPerMinutes).VoltsPerSeconds, MegavoltsPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMegavoltsPerSeconds(voltpersecond.MegavoltsPerSeconds).VoltsPerSeconds, MegavoltsPerSecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMicrovoltsPerHours(voltpersecond.MicrovoltsPerHours).VoltsPerSeconds, MicrovoltsPerHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMicrovoltsPerMicroseconds(voltpersecond.MicrovoltsPerMicroseconds).VoltsPerSeconds, MicrovoltsPerMicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMicrovoltsPerMinutes(voltpersecond.MicrovoltsPerMinutes).VoltsPerSeconds, MicrovoltsPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMicrovoltsPerSeconds(voltpersecond.MicrovoltsPerSeconds).VoltsPerSeconds, MicrovoltsPerSecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMillivoltsPerHours(voltpersecond.MillivoltsPerHours).VoltsPerSeconds, MillivoltsPerHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMillivoltsPerMicroseconds(voltpersecond.MillivoltsPerMicroseconds).VoltsPerSeconds, MillivoltsPerMicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMillivoltsPerMinutes(voltpersecond.MillivoltsPerMinutes).VoltsPerSeconds, MillivoltsPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromMillivoltsPerSeconds(voltpersecond.MillivoltsPerSeconds).VoltsPerSeconds, MillivoltsPerSecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromVoltsPerHours(voltpersecond.VoltsPerHours).VoltsPerSeconds, VoltsPerHoursTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromVoltsPerMicroseconds(voltpersecond.VoltsPerMicroseconds).VoltsPerSeconds, VoltsPerMicrosecondsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromVoltsPerMinutes(voltpersecond.VoltsPerMinutes).VoltsPerSeconds, VoltsPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(voltpersecond.VoltsPerSeconds).VoltsPerSeconds, VoltsPerSecondsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricPotentialChangeRate v = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> v = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             AssertEx.EqualTolerance(-1, -v.VoltsPerSeconds, VoltsPerSecondsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSeconds(3)-v).VoltsPerSeconds, VoltsPerSecondsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(3)-v).VoltsPerSeconds, VoltsPerSecondsTolerance);
             AssertEx.EqualTolerance(2, (v + v).VoltsPerSeconds, VoltsPerSecondsTolerance);
             AssertEx.EqualTolerance(10, (v*10).VoltsPerSeconds, VoltsPerSecondsTolerance);
             AssertEx.EqualTolerance(10, (10*v).VoltsPerSeconds, VoltsPerSecondsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSeconds(10)/5).VoltsPerSeconds, VoltsPerSecondsTolerance);
-            AssertEx.EqualTolerance(2, ElectricPotentialChangeRate.FromVoltsPerSeconds(10)/ElectricPotentialChangeRate.FromVoltsPerSeconds(5), VoltsPerSecondsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(10)/5).VoltsPerSeconds, VoltsPerSecondsTolerance);
+            AssertEx.EqualTolerance(2, ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(10)/ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(5), VoltsPerSecondsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricPotentialChangeRate oneVoltPerSecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
-            ElectricPotentialChangeRate twoVoltsPerSeconds = ElectricPotentialChangeRate.FromVoltsPerSeconds(2);
+            ElectricPotentialChangeRate<double> oneVoltPerSecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> twoVoltsPerSeconds = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(2);
 
             Assert.True(oneVoltPerSecond < twoVoltsPerSeconds);
             Assert.True(oneVoltPerSecond <= twoVoltsPerSeconds);
@@ -468,31 +468,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             Assert.Equal(0, voltpersecond.CompareTo(voltpersecond));
-            Assert.True(voltpersecond.CompareTo(ElectricPotentialChangeRate.Zero) > 0);
-            Assert.True(ElectricPotentialChangeRate.Zero.CompareTo(voltpersecond) < 0);
+            Assert.True(voltpersecond.CompareTo(ElectricPotentialChangeRate<double>.Zero) > 0);
+            Assert.True(ElectricPotentialChangeRate<double>.Zero.CompareTo(voltpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             Assert.Throws<ArgumentException>(() => voltpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             Assert.Throws<ArgumentNullException>(() => voltpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
-            var b = ElectricPotentialChangeRate.FromVoltsPerSeconds(2);
+            var a = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
+            var b = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -511,8 +511,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
-            var b = ElectricPotentialChangeRate.FromVoltsPerSeconds(2);
+            var a = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
+            var b = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -532,9 +532,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
-            Assert.True(v.Equals(ElectricPotentialChangeRate.FromVoltsPerSeconds(1), VoltsPerSecondsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricPotentialChangeRate.Zero, VoltsPerSecondsTolerance, ComparisonType.Relative));
+            var v = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
+            Assert.True(v.Equals(ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1), VoltsPerSecondsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricPotentialChangeRate<double>.Zero, VoltsPerSecondsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -547,21 +547,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             Assert.False(voltpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1);
+            ElectricPotentialChangeRate<double> voltpersecond = ElectricPotentialChangeRate<double>.FromVoltsPerSeconds(1);
             Assert.False(voltpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricPotentialChangeRateUnit.Undefined, ElectricPotentialChangeRate.Units);
+            Assert.DoesNotContain(ElectricPotentialChangeRateUnit.Undefined, ElectricPotentialChangeRate<double>.Units);
         }
 
         [Fact]
@@ -580,7 +580,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricPotentialChangeRate.BaseDimensions is null);
+            Assert.False(ElectricPotentialChangeRate<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialDcTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialDcTestsBase.g.cs
index e7f6771eba..a7034dede8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialDcTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialDcTestsBase.g.cs
@@ -54,7 +54,7 @@ public abstract partial class ElectricPotentialDcTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc((double)0.0, ElectricPotentialDcUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>((double)0.0, ElectricPotentialDcUnit.Undefined));
         }
 
         [Fact]
@@ -69,14 +69,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc(double.PositiveInfinity, ElectricPotentialDcUnit.VoltDc));
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc(double.NegativeInfinity, ElectricPotentialDcUnit.VoltDc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>(double.PositiveInfinity, ElectricPotentialDcUnit.VoltDc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>(double.NegativeInfinity, ElectricPotentialDcUnit.VoltDc));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc(double.NaN, ElectricPotentialDcUnit.VoltDc));
+            Assert.Throws<ArgumentException>(() => new ElectricPotentialDc<double>(double.NaN, ElectricPotentialDcUnit.VoltDc));
         }
 
         [Fact]
@@ -122,7 +122,7 @@ public void ElectricPotentialDc_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void VoltDcToElectricPotentialDcUnits()
         {
-            ElectricPotentialDc voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
             AssertEx.EqualTolerance(KilovoltsDcInOneVoltDc, voltdc.KilovoltsDc, KilovoltsDcTolerance);
             AssertEx.EqualTolerance(MegavoltsDcInOneVoltDc, voltdc.MegavoltsDc, MegavoltsDcTolerance);
             AssertEx.EqualTolerance(MicrovoltsDcInOneVoltDc, voltdc.MicrovoltsDc, MicrovoltsDcTolerance);
@@ -133,23 +133,23 @@ public void VoltDcToElectricPotentialDcUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricPotentialDc.From(1, ElectricPotentialDcUnit.KilovoltDc);
+            var quantity00 = ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.KilovoltDc);
             AssertEx.EqualTolerance(1, quantity00.KilovoltsDc, KilovoltsDcTolerance);
             Assert.Equal(ElectricPotentialDcUnit.KilovoltDc, quantity00.Unit);
 
-            var quantity01 = ElectricPotentialDc.From(1, ElectricPotentialDcUnit.MegavoltDc);
+            var quantity01 = ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.MegavoltDc);
             AssertEx.EqualTolerance(1, quantity01.MegavoltsDc, MegavoltsDcTolerance);
             Assert.Equal(ElectricPotentialDcUnit.MegavoltDc, quantity01.Unit);
 
-            var quantity02 = ElectricPotentialDc.From(1, ElectricPotentialDcUnit.MicrovoltDc);
+            var quantity02 = ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.MicrovoltDc);
             AssertEx.EqualTolerance(1, quantity02.MicrovoltsDc, MicrovoltsDcTolerance);
             Assert.Equal(ElectricPotentialDcUnit.MicrovoltDc, quantity02.Unit);
 
-            var quantity03 = ElectricPotentialDc.From(1, ElectricPotentialDcUnit.MillivoltDc);
+            var quantity03 = ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.MillivoltDc);
             AssertEx.EqualTolerance(1, quantity03.MillivoltsDc, MillivoltsDcTolerance);
             Assert.Equal(ElectricPotentialDcUnit.MillivoltDc, quantity03.Unit);
 
-            var quantity04 = ElectricPotentialDc.From(1, ElectricPotentialDcUnit.VoltDc);
+            var quantity04 = ElectricPotentialDc<double>.From(1, ElectricPotentialDcUnit.VoltDc);
             AssertEx.EqualTolerance(1, quantity04.VoltsDc, VoltsDcTolerance);
             Assert.Equal(ElectricPotentialDcUnit.VoltDc, quantity04.Unit);
 
@@ -158,20 +158,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltsDc_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotentialDc.FromVoltsDc(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricPotentialDc.FromVoltsDc(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialDc<double>.FromVoltsDc(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialDc<double>.FromVoltsDc(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltsDc_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotentialDc.FromVoltsDc(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricPotentialDc<double>.FromVoltsDc(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            var voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
             AssertEx.EqualTolerance(KilovoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.KilovoltDc), KilovoltsDcTolerance);
             AssertEx.EqualTolerance(MegavoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.MegavoltDc), MegavoltsDcTolerance);
             AssertEx.EqualTolerance(MicrovoltsDcInOneVoltDc, voltdc.As(ElectricPotentialDcUnit.MicrovoltDc), MicrovoltsDcTolerance);
@@ -199,7 +199,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            var voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
 
             var kilovoltdcQuantity = voltdc.ToUnit(ElectricPotentialDcUnit.KilovoltDc);
             AssertEx.EqualTolerance(KilovoltsDcInOneVoltDc, (double)kilovoltdcQuantity.Value, KilovoltsDcTolerance);
@@ -232,32 +232,32 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricPotentialDc voltdc = ElectricPotentialDc.FromVoltsDc(1);
-            AssertEx.EqualTolerance(1, ElectricPotentialDc.FromKilovoltsDc(voltdc.KilovoltsDc).VoltsDc, KilovoltsDcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialDc.FromMegavoltsDc(voltdc.MegavoltsDc).VoltsDc, MegavoltsDcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialDc.FromMicrovoltsDc(voltdc.MicrovoltsDc).VoltsDc, MicrovoltsDcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialDc.FromMillivoltsDc(voltdc.MillivoltsDc).VoltsDc, MillivoltsDcTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialDc.FromVoltsDc(voltdc.VoltsDc).VoltsDc, VoltsDcTolerance);
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromKilovoltsDc(voltdc.KilovoltsDc).VoltsDc, KilovoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromMegavoltsDc(voltdc.MegavoltsDc).VoltsDc, MegavoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromMicrovoltsDc(voltdc.MicrovoltsDc).VoltsDc, MicrovoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromMillivoltsDc(voltdc.MillivoltsDc).VoltsDc, MillivoltsDcTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotentialDc<double>.FromVoltsDc(voltdc.VoltsDc).VoltsDc, VoltsDcTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricPotentialDc v = ElectricPotentialDc.FromVoltsDc(1);
+            ElectricPotentialDc<double> v = ElectricPotentialDc<double>.FromVoltsDc(1);
             AssertEx.EqualTolerance(-1, -v.VoltsDc, VoltsDcTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialDc.FromVoltsDc(3)-v).VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialDc<double>.FromVoltsDc(3)-v).VoltsDc, VoltsDcTolerance);
             AssertEx.EqualTolerance(2, (v + v).VoltsDc, VoltsDcTolerance);
             AssertEx.EqualTolerance(10, (v*10).VoltsDc, VoltsDcTolerance);
             AssertEx.EqualTolerance(10, (10*v).VoltsDc, VoltsDcTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialDc.FromVoltsDc(10)/5).VoltsDc, VoltsDcTolerance);
-            AssertEx.EqualTolerance(2, ElectricPotentialDc.FromVoltsDc(10)/ElectricPotentialDc.FromVoltsDc(5), VoltsDcTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotentialDc<double>.FromVoltsDc(10)/5).VoltsDc, VoltsDcTolerance);
+            AssertEx.EqualTolerance(2, ElectricPotentialDc<double>.FromVoltsDc(10)/ElectricPotentialDc<double>.FromVoltsDc(5), VoltsDcTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricPotentialDc oneVoltDc = ElectricPotentialDc.FromVoltsDc(1);
-            ElectricPotentialDc twoVoltsDc = ElectricPotentialDc.FromVoltsDc(2);
+            ElectricPotentialDc<double> oneVoltDc = ElectricPotentialDc<double>.FromVoltsDc(1);
+            ElectricPotentialDc<double> twoVoltsDc = ElectricPotentialDc<double>.FromVoltsDc(2);
 
             Assert.True(oneVoltDc < twoVoltsDc);
             Assert.True(oneVoltDc <= twoVoltsDc);
@@ -273,31 +273,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricPotentialDc voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
             Assert.Equal(0, voltdc.CompareTo(voltdc));
-            Assert.True(voltdc.CompareTo(ElectricPotentialDc.Zero) > 0);
-            Assert.True(ElectricPotentialDc.Zero.CompareTo(voltdc) < 0);
+            Assert.True(voltdc.CompareTo(ElectricPotentialDc<double>.Zero) > 0);
+            Assert.True(ElectricPotentialDc<double>.Zero.CompareTo(voltdc) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricPotentialDc voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
             Assert.Throws<ArgumentException>(() => voltdc.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricPotentialDc voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
             Assert.Throws<ArgumentNullException>(() => voltdc.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricPotentialDc.FromVoltsDc(1);
-            var b = ElectricPotentialDc.FromVoltsDc(2);
+            var a = ElectricPotentialDc<double>.FromVoltsDc(1);
+            var b = ElectricPotentialDc<double>.FromVoltsDc(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -316,8 +316,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricPotentialDc.FromVoltsDc(1);
-            var b = ElectricPotentialDc.FromVoltsDc(2);
+            var a = ElectricPotentialDc<double>.FromVoltsDc(1);
+            var b = ElectricPotentialDc<double>.FromVoltsDc(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -337,9 +337,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricPotentialDc.FromVoltsDc(1);
-            Assert.True(v.Equals(ElectricPotentialDc.FromVoltsDc(1), VoltsDcTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricPotentialDc.Zero, VoltsDcTolerance, ComparisonType.Relative));
+            var v = ElectricPotentialDc<double>.FromVoltsDc(1);
+            Assert.True(v.Equals(ElectricPotentialDc<double>.FromVoltsDc(1), VoltsDcTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricPotentialDc<double>.Zero, VoltsDcTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -352,21 +352,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricPotentialDc voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
             Assert.False(voltdc.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricPotentialDc voltdc = ElectricPotentialDc.FromVoltsDc(1);
+            ElectricPotentialDc<double> voltdc = ElectricPotentialDc<double>.FromVoltsDc(1);
             Assert.False(voltdc.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricPotentialDcUnit.Undefined, ElectricPotentialDc.Units);
+            Assert.DoesNotContain(ElectricPotentialDcUnit.Undefined, ElectricPotentialDc<double>.Units);
         }
 
         [Fact]
@@ -385,7 +385,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricPotentialDc.BaseDimensions is null);
+            Assert.False(ElectricPotentialDc<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs
index 841daf881c..c4c0e84c19 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs
@@ -54,7 +54,7 @@ public abstract partial class ElectricPotentialTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotential((double)0.0, ElectricPotentialUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>((double)0.0, ElectricPotentialUnit.Undefined));
         }
 
         [Fact]
@@ -69,14 +69,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotential(double.PositiveInfinity, ElectricPotentialUnit.Volt));
-            Assert.Throws<ArgumentException>(() => new ElectricPotential(double.NegativeInfinity, ElectricPotentialUnit.Volt));
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>(double.PositiveInfinity, ElectricPotentialUnit.Volt));
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>(double.NegativeInfinity, ElectricPotentialUnit.Volt));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricPotential(double.NaN, ElectricPotentialUnit.Volt));
+            Assert.Throws<ArgumentException>(() => new ElectricPotential<double>(double.NaN, ElectricPotentialUnit.Volt));
         }
 
         [Fact]
@@ -122,7 +122,7 @@ public void ElectricPotential_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
         [Fact]
         public void VoltToElectricPotentialUnits()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
             AssertEx.EqualTolerance(KilovoltsInOneVolt, volt.Kilovolts, KilovoltsTolerance);
             AssertEx.EqualTolerance(MegavoltsInOneVolt, volt.Megavolts, MegavoltsTolerance);
             AssertEx.EqualTolerance(MicrovoltsInOneVolt, volt.Microvolts, MicrovoltsTolerance);
@@ -133,23 +133,23 @@ public void VoltToElectricPotentialUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt);
+            var quantity00 = ElectricPotential<double>.From(1, ElectricPotentialUnit.Kilovolt);
             AssertEx.EqualTolerance(1, quantity00.Kilovolts, KilovoltsTolerance);
             Assert.Equal(ElectricPotentialUnit.Kilovolt, quantity00.Unit);
 
-            var quantity01 = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt);
+            var quantity01 = ElectricPotential<double>.From(1, ElectricPotentialUnit.Megavolt);
             AssertEx.EqualTolerance(1, quantity01.Megavolts, MegavoltsTolerance);
             Assert.Equal(ElectricPotentialUnit.Megavolt, quantity01.Unit);
 
-            var quantity02 = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt);
+            var quantity02 = ElectricPotential<double>.From(1, ElectricPotentialUnit.Microvolt);
             AssertEx.EqualTolerance(1, quantity02.Microvolts, MicrovoltsTolerance);
             Assert.Equal(ElectricPotentialUnit.Microvolt, quantity02.Unit);
 
-            var quantity03 = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt);
+            var quantity03 = ElectricPotential<double>.From(1, ElectricPotentialUnit.Millivolt);
             AssertEx.EqualTolerance(1, quantity03.Millivolts, MillivoltsTolerance);
             Assert.Equal(ElectricPotentialUnit.Millivolt, quantity03.Unit);
 
-            var quantity04 = ElectricPotential.From(1, ElectricPotentialUnit.Volt);
+            var quantity04 = ElectricPotential<double>.From(1, ElectricPotentialUnit.Volt);
             AssertEx.EqualTolerance(1, quantity04.Volts, VoltsTolerance);
             Assert.Equal(ElectricPotentialUnit.Volt, quantity04.Unit);
 
@@ -158,20 +158,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVolts_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotential.FromVolts(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricPotential.FromVolts(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotential<double>.FromVolts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricPotential<double>.FromVolts(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVolts_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricPotential.FromVolts(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricPotential<double>.FromVolts(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var volt = ElectricPotential.FromVolts(1);
+            var volt = ElectricPotential<double>.FromVolts(1);
             AssertEx.EqualTolerance(KilovoltsInOneVolt, volt.As(ElectricPotentialUnit.Kilovolt), KilovoltsTolerance);
             AssertEx.EqualTolerance(MegavoltsInOneVolt, volt.As(ElectricPotentialUnit.Megavolt), MegavoltsTolerance);
             AssertEx.EqualTolerance(MicrovoltsInOneVolt, volt.As(ElectricPotentialUnit.Microvolt), MicrovoltsTolerance);
@@ -199,7 +199,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var volt = ElectricPotential.FromVolts(1);
+            var volt = ElectricPotential<double>.FromVolts(1);
 
             var kilovoltQuantity = volt.ToUnit(ElectricPotentialUnit.Kilovolt);
             AssertEx.EqualTolerance(KilovoltsInOneVolt, (double)kilovoltQuantity.Value, KilovoltsTolerance);
@@ -232,32 +232,32 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromKilovolts(volt.Kilovolts).Volts, KilovoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromMegavolts(volt.Megavolts).Volts, MegavoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromMicrovolts(volt.Microvolts).Volts, MicrovoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromMillivolts(volt.Millivolts).Volts, MillivoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromVolts(volt.Volts).Volts, VoltsTolerance);
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromKilovolts(volt.Kilovolts).Volts, KilovoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromMegavolts(volt.Megavolts).Volts, MegavoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromMicrovolts(volt.Microvolts).Volts, MicrovoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromMillivolts(volt.Millivolts).Volts, MillivoltsTolerance);
+            AssertEx.EqualTolerance(1, ElectricPotential<double>.FromVolts(volt.Volts).Volts, VoltsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricPotential v = ElectricPotential.FromVolts(1);
+            ElectricPotential<double> v = ElectricPotential<double>.FromVolts(1);
             AssertEx.EqualTolerance(-1, -v.Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotential.FromVolts(3)-v).Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotential<double>.FromVolts(3)-v).Volts, VoltsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Volts, VoltsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Volts, VoltsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotential.FromVolts(10)/5).Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(2, ElectricPotential.FromVolts(10)/ElectricPotential.FromVolts(5), VoltsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricPotential<double>.FromVolts(10)/5).Volts, VoltsTolerance);
+            AssertEx.EqualTolerance(2, ElectricPotential<double>.FromVolts(10)/ElectricPotential<double>.FromVolts(5), VoltsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricPotential oneVolt = ElectricPotential.FromVolts(1);
-            ElectricPotential twoVolts = ElectricPotential.FromVolts(2);
+            ElectricPotential<double> oneVolt = ElectricPotential<double>.FromVolts(1);
+            ElectricPotential<double> twoVolts = ElectricPotential<double>.FromVolts(2);
 
             Assert.True(oneVolt < twoVolts);
             Assert.True(oneVolt <= twoVolts);
@@ -273,31 +273,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
             Assert.Equal(0, volt.CompareTo(volt));
-            Assert.True(volt.CompareTo(ElectricPotential.Zero) > 0);
-            Assert.True(ElectricPotential.Zero.CompareTo(volt) < 0);
+            Assert.True(volt.CompareTo(ElectricPotential<double>.Zero) > 0);
+            Assert.True(ElectricPotential<double>.Zero.CompareTo(volt) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
             Assert.Throws<ArgumentException>(() => volt.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
             Assert.Throws<ArgumentNullException>(() => volt.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricPotential.FromVolts(1);
-            var b = ElectricPotential.FromVolts(2);
+            var a = ElectricPotential<double>.FromVolts(1);
+            var b = ElectricPotential<double>.FromVolts(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -316,8 +316,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricPotential.FromVolts(1);
-            var b = ElectricPotential.FromVolts(2);
+            var a = ElectricPotential<double>.FromVolts(1);
+            var b = ElectricPotential<double>.FromVolts(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -337,9 +337,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricPotential.FromVolts(1);
-            Assert.True(v.Equals(ElectricPotential.FromVolts(1), VoltsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricPotential.Zero, VoltsTolerance, ComparisonType.Relative));
+            var v = ElectricPotential<double>.FromVolts(1);
+            Assert.True(v.Equals(ElectricPotential<double>.FromVolts(1), VoltsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricPotential<double>.Zero, VoltsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -352,21 +352,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
             Assert.False(volt.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
+            ElectricPotential<double> volt = ElectricPotential<double>.FromVolts(1);
             Assert.False(volt.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricPotentialUnit.Undefined, ElectricPotential.Units);
+            Assert.DoesNotContain(ElectricPotentialUnit.Undefined, ElectricPotential<double>.Units);
         }
 
         [Fact]
@@ -385,7 +385,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricPotential.BaseDimensions is null);
+            Assert.False(ElectricPotential<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs
index 7d47b2dd4d..9438ac3ad8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs
@@ -56,7 +56,7 @@ public abstract partial class ElectricResistanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricResistance((double)0.0, ElectricResistanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>((double)0.0, ElectricResistanceUnit.Undefined));
         }
 
         [Fact]
@@ -71,14 +71,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricResistance(double.PositiveInfinity, ElectricResistanceUnit.Ohm));
-            Assert.Throws<ArgumentException>(() => new ElectricResistance(double.NegativeInfinity, ElectricResistanceUnit.Ohm));
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>(double.PositiveInfinity, ElectricResistanceUnit.Ohm));
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>(double.NegativeInfinity, ElectricResistanceUnit.Ohm));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricResistance(double.NaN, ElectricResistanceUnit.Ohm));
+            Assert.Throws<ArgumentException>(() => new ElectricResistance<double>(double.NaN, ElectricResistanceUnit.Ohm));
         }
 
         [Fact]
@@ -124,7 +124,7 @@ public void ElectricResistance_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
         [Fact]
         public void OhmToElectricResistanceUnits()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
             AssertEx.EqualTolerance(GigaohmsInOneOhm, ohm.Gigaohms, GigaohmsTolerance);
             AssertEx.EqualTolerance(KiloohmsInOneOhm, ohm.Kiloohms, KiloohmsTolerance);
             AssertEx.EqualTolerance(MegaohmsInOneOhm, ohm.Megaohms, MegaohmsTolerance);
@@ -136,27 +136,27 @@ public void OhmToElectricResistanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricResistance.From(1, ElectricResistanceUnit.Gigaohm);
+            var quantity00 = ElectricResistance<double>.From(1, ElectricResistanceUnit.Gigaohm);
             AssertEx.EqualTolerance(1, quantity00.Gigaohms, GigaohmsTolerance);
             Assert.Equal(ElectricResistanceUnit.Gigaohm, quantity00.Unit);
 
-            var quantity01 = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm);
+            var quantity01 = ElectricResistance<double>.From(1, ElectricResistanceUnit.Kiloohm);
             AssertEx.EqualTolerance(1, quantity01.Kiloohms, KiloohmsTolerance);
             Assert.Equal(ElectricResistanceUnit.Kiloohm, quantity01.Unit);
 
-            var quantity02 = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm);
+            var quantity02 = ElectricResistance<double>.From(1, ElectricResistanceUnit.Megaohm);
             AssertEx.EqualTolerance(1, quantity02.Megaohms, MegaohmsTolerance);
             Assert.Equal(ElectricResistanceUnit.Megaohm, quantity02.Unit);
 
-            var quantity03 = ElectricResistance.From(1, ElectricResistanceUnit.Microohm);
+            var quantity03 = ElectricResistance<double>.From(1, ElectricResistanceUnit.Microohm);
             AssertEx.EqualTolerance(1, quantity03.Microohms, MicroohmsTolerance);
             Assert.Equal(ElectricResistanceUnit.Microohm, quantity03.Unit);
 
-            var quantity04 = ElectricResistance.From(1, ElectricResistanceUnit.Milliohm);
+            var quantity04 = ElectricResistance<double>.From(1, ElectricResistanceUnit.Milliohm);
             AssertEx.EqualTolerance(1, quantity04.Milliohms, MilliohmsTolerance);
             Assert.Equal(ElectricResistanceUnit.Milliohm, quantity04.Unit);
 
-            var quantity05 = ElectricResistance.From(1, ElectricResistanceUnit.Ohm);
+            var quantity05 = ElectricResistance<double>.From(1, ElectricResistanceUnit.Ohm);
             AssertEx.EqualTolerance(1, quantity05.Ohms, OhmsTolerance);
             Assert.Equal(ElectricResistanceUnit.Ohm, quantity05.Unit);
 
@@ -165,20 +165,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromOhms_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricResistance.FromOhms(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricResistance.FromOhms(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricResistance<double>.FromOhms(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricResistance<double>.FromOhms(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromOhms_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricResistance.FromOhms(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricResistance<double>.FromOhms(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var ohm = ElectricResistance.FromOhms(1);
+            var ohm = ElectricResistance<double>.FromOhms(1);
             AssertEx.EqualTolerance(GigaohmsInOneOhm, ohm.As(ElectricResistanceUnit.Gigaohm), GigaohmsTolerance);
             AssertEx.EqualTolerance(KiloohmsInOneOhm, ohm.As(ElectricResistanceUnit.Kiloohm), KiloohmsTolerance);
             AssertEx.EqualTolerance(MegaohmsInOneOhm, ohm.As(ElectricResistanceUnit.Megaohm), MegaohmsTolerance);
@@ -207,7 +207,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var ohm = ElectricResistance.FromOhms(1);
+            var ohm = ElectricResistance<double>.FromOhms(1);
 
             var gigaohmQuantity = ohm.ToUnit(ElectricResistanceUnit.Gigaohm);
             AssertEx.EqualTolerance(GigaohmsInOneOhm, (double)gigaohmQuantity.Value, GigaohmsTolerance);
@@ -244,33 +244,33 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromGigaohms(ohm.Gigaohms).Ohms, GigaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromKiloohms(ohm.Kiloohms).Ohms, KiloohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromMegaohms(ohm.Megaohms).Ohms, MegaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromMicroohms(ohm.Microohms).Ohms, MicroohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromMilliohms(ohm.Milliohms).Ohms, MilliohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromOhms(ohm.Ohms).Ohms, OhmsTolerance);
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromGigaohms(ohm.Gigaohms).Ohms, GigaohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromKiloohms(ohm.Kiloohms).Ohms, KiloohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromMegaohms(ohm.Megaohms).Ohms, MegaohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromMicroohms(ohm.Microohms).Ohms, MicroohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromMilliohms(ohm.Milliohms).Ohms, MilliohmsTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistance<double>.FromOhms(ohm.Ohms).Ohms, OhmsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricResistance v = ElectricResistance.FromOhms(1);
+            ElectricResistance<double> v = ElectricResistance<double>.FromOhms(1);
             AssertEx.EqualTolerance(-1, -v.Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistance.FromOhms(3)-v).Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricResistance<double>.FromOhms(3)-v).Ohms, OhmsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Ohms, OhmsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Ohms, OhmsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistance.FromOhms(10)/5).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, ElectricResistance.FromOhms(10)/ElectricResistance.FromOhms(5), OhmsTolerance);
+            AssertEx.EqualTolerance(2, (ElectricResistance<double>.FromOhms(10)/5).Ohms, OhmsTolerance);
+            AssertEx.EqualTolerance(2, ElectricResistance<double>.FromOhms(10)/ElectricResistance<double>.FromOhms(5), OhmsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricResistance oneOhm = ElectricResistance.FromOhms(1);
-            ElectricResistance twoOhms = ElectricResistance.FromOhms(2);
+            ElectricResistance<double> oneOhm = ElectricResistance<double>.FromOhms(1);
+            ElectricResistance<double> twoOhms = ElectricResistance<double>.FromOhms(2);
 
             Assert.True(oneOhm < twoOhms);
             Assert.True(oneOhm <= twoOhms);
@@ -286,31 +286,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
             Assert.Equal(0, ohm.CompareTo(ohm));
-            Assert.True(ohm.CompareTo(ElectricResistance.Zero) > 0);
-            Assert.True(ElectricResistance.Zero.CompareTo(ohm) < 0);
+            Assert.True(ohm.CompareTo(ElectricResistance<double>.Zero) > 0);
+            Assert.True(ElectricResistance<double>.Zero.CompareTo(ohm) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
             Assert.Throws<ArgumentException>(() => ohm.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
             Assert.Throws<ArgumentNullException>(() => ohm.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricResistance.FromOhms(1);
-            var b = ElectricResistance.FromOhms(2);
+            var a = ElectricResistance<double>.FromOhms(1);
+            var b = ElectricResistance<double>.FromOhms(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -329,8 +329,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricResistance.FromOhms(1);
-            var b = ElectricResistance.FromOhms(2);
+            var a = ElectricResistance<double>.FromOhms(1);
+            var b = ElectricResistance<double>.FromOhms(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -350,9 +350,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricResistance.FromOhms(1);
-            Assert.True(v.Equals(ElectricResistance.FromOhms(1), OhmsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricResistance.Zero, OhmsTolerance, ComparisonType.Relative));
+            var v = ElectricResistance<double>.FromOhms(1);
+            Assert.True(v.Equals(ElectricResistance<double>.FromOhms(1), OhmsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricResistance<double>.Zero, OhmsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -365,21 +365,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
             Assert.False(ohm.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
+            ElectricResistance<double> ohm = ElectricResistance<double>.FromOhms(1);
             Assert.False(ohm.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricResistanceUnit.Undefined, ElectricResistance.Units);
+            Assert.DoesNotContain(ElectricResistanceUnit.Undefined, ElectricResistance<double>.Units);
         }
 
         [Fact]
@@ -398,7 +398,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricResistance.BaseDimensions is null);
+            Assert.False(ElectricResistance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs
index 0d5cb21376..718e1dde2a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs
@@ -72,7 +72,7 @@ public abstract partial class ElectricResistivityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricResistivity((double)0.0, ElectricResistivityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricResistivity<double>((double)0.0, ElectricResistivityUnit.Undefined));
         }
 
         [Fact]
@@ -87,14 +87,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricResistivity(double.PositiveInfinity, ElectricResistivityUnit.OhmMeter));
-            Assert.Throws<ArgumentException>(() => new ElectricResistivity(double.NegativeInfinity, ElectricResistivityUnit.OhmMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricResistivity<double>(double.PositiveInfinity, ElectricResistivityUnit.OhmMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricResistivity<double>(double.NegativeInfinity, ElectricResistivityUnit.OhmMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricResistivity(double.NaN, ElectricResistivityUnit.OhmMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricResistivity<double>(double.NaN, ElectricResistivityUnit.OhmMeter));
         }
 
         [Fact]
@@ -140,7 +140,7 @@ public void ElectricResistivity_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void OhmMeterToElectricResistivityUnits()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            ElectricResistivity<double> ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
             AssertEx.EqualTolerance(KiloohmsCentimeterInOneOhmMeter, ohmmeter.KiloohmsCentimeter, KiloohmsCentimeterTolerance);
             AssertEx.EqualTolerance(KiloohmMetersInOneOhmMeter, ohmmeter.KiloohmMeters, KiloohmMetersTolerance);
             AssertEx.EqualTolerance(MegaohmsCentimeterInOneOhmMeter, ohmmeter.MegaohmsCentimeter, MegaohmsCentimeterTolerance);
@@ -160,59 +160,59 @@ public void OhmMeterToElectricResistivityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricResistivity.From(1, ElectricResistivityUnit.KiloohmCentimeter);
+            var quantity00 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.KiloohmCentimeter);
             AssertEx.EqualTolerance(1, quantity00.KiloohmsCentimeter, KiloohmsCentimeterTolerance);
             Assert.Equal(ElectricResistivityUnit.KiloohmCentimeter, quantity00.Unit);
 
-            var quantity01 = ElectricResistivity.From(1, ElectricResistivityUnit.KiloohmMeter);
+            var quantity01 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.KiloohmMeter);
             AssertEx.EqualTolerance(1, quantity01.KiloohmMeters, KiloohmMetersTolerance);
             Assert.Equal(ElectricResistivityUnit.KiloohmMeter, quantity01.Unit);
 
-            var quantity02 = ElectricResistivity.From(1, ElectricResistivityUnit.MegaohmCentimeter);
+            var quantity02 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.MegaohmCentimeter);
             AssertEx.EqualTolerance(1, quantity02.MegaohmsCentimeter, MegaohmsCentimeterTolerance);
             Assert.Equal(ElectricResistivityUnit.MegaohmCentimeter, quantity02.Unit);
 
-            var quantity03 = ElectricResistivity.From(1, ElectricResistivityUnit.MegaohmMeter);
+            var quantity03 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.MegaohmMeter);
             AssertEx.EqualTolerance(1, quantity03.MegaohmMeters, MegaohmMetersTolerance);
             Assert.Equal(ElectricResistivityUnit.MegaohmMeter, quantity03.Unit);
 
-            var quantity04 = ElectricResistivity.From(1, ElectricResistivityUnit.MicroohmCentimeter);
+            var quantity04 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.MicroohmCentimeter);
             AssertEx.EqualTolerance(1, quantity04.MicroohmsCentimeter, MicroohmsCentimeterTolerance);
             Assert.Equal(ElectricResistivityUnit.MicroohmCentimeter, quantity04.Unit);
 
-            var quantity05 = ElectricResistivity.From(1, ElectricResistivityUnit.MicroohmMeter);
+            var quantity05 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.MicroohmMeter);
             AssertEx.EqualTolerance(1, quantity05.MicroohmMeters, MicroohmMetersTolerance);
             Assert.Equal(ElectricResistivityUnit.MicroohmMeter, quantity05.Unit);
 
-            var quantity06 = ElectricResistivity.From(1, ElectricResistivityUnit.MilliohmCentimeter);
+            var quantity06 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.MilliohmCentimeter);
             AssertEx.EqualTolerance(1, quantity06.MilliohmsCentimeter, MilliohmsCentimeterTolerance);
             Assert.Equal(ElectricResistivityUnit.MilliohmCentimeter, quantity06.Unit);
 
-            var quantity07 = ElectricResistivity.From(1, ElectricResistivityUnit.MilliohmMeter);
+            var quantity07 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.MilliohmMeter);
             AssertEx.EqualTolerance(1, quantity07.MilliohmMeters, MilliohmMetersTolerance);
             Assert.Equal(ElectricResistivityUnit.MilliohmMeter, quantity07.Unit);
 
-            var quantity08 = ElectricResistivity.From(1, ElectricResistivityUnit.NanoohmCentimeter);
+            var quantity08 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.NanoohmCentimeter);
             AssertEx.EqualTolerance(1, quantity08.NanoohmsCentimeter, NanoohmsCentimeterTolerance);
             Assert.Equal(ElectricResistivityUnit.NanoohmCentimeter, quantity08.Unit);
 
-            var quantity09 = ElectricResistivity.From(1, ElectricResistivityUnit.NanoohmMeter);
+            var quantity09 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.NanoohmMeter);
             AssertEx.EqualTolerance(1, quantity09.NanoohmMeters, NanoohmMetersTolerance);
             Assert.Equal(ElectricResistivityUnit.NanoohmMeter, quantity09.Unit);
 
-            var quantity10 = ElectricResistivity.From(1, ElectricResistivityUnit.OhmCentimeter);
+            var quantity10 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.OhmCentimeter);
             AssertEx.EqualTolerance(1, quantity10.OhmsCentimeter, OhmsCentimeterTolerance);
             Assert.Equal(ElectricResistivityUnit.OhmCentimeter, quantity10.Unit);
 
-            var quantity11 = ElectricResistivity.From(1, ElectricResistivityUnit.OhmMeter);
+            var quantity11 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.OhmMeter);
             AssertEx.EqualTolerance(1, quantity11.OhmMeters, OhmMetersTolerance);
             Assert.Equal(ElectricResistivityUnit.OhmMeter, quantity11.Unit);
 
-            var quantity12 = ElectricResistivity.From(1, ElectricResistivityUnit.PicoohmCentimeter);
+            var quantity12 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.PicoohmCentimeter);
             AssertEx.EqualTolerance(1, quantity12.PicoohmsCentimeter, PicoohmsCentimeterTolerance);
             Assert.Equal(ElectricResistivityUnit.PicoohmCentimeter, quantity12.Unit);
 
-            var quantity13 = ElectricResistivity.From(1, ElectricResistivityUnit.PicoohmMeter);
+            var quantity13 = ElectricResistivity<double>.From(1, ElectricResistivityUnit.PicoohmMeter);
             AssertEx.EqualTolerance(1, quantity13.PicoohmMeters, PicoohmMetersTolerance);
             Assert.Equal(ElectricResistivityUnit.PicoohmMeter, quantity13.Unit);
 
@@ -221,20 +221,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromOhmMeters_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricResistivity.FromOhmMeters(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricResistivity.FromOhmMeters(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricResistivity<double>.FromOhmMeters(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricResistivity<double>.FromOhmMeters(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromOhmMeters_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricResistivity.FromOhmMeters(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricResistivity<double>.FromOhmMeters(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            var ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
             AssertEx.EqualTolerance(KiloohmsCentimeterInOneOhmMeter, ohmmeter.As(ElectricResistivityUnit.KiloohmCentimeter), KiloohmsCentimeterTolerance);
             AssertEx.EqualTolerance(KiloohmMetersInOneOhmMeter, ohmmeter.As(ElectricResistivityUnit.KiloohmMeter), KiloohmMetersTolerance);
             AssertEx.EqualTolerance(MegaohmsCentimeterInOneOhmMeter, ohmmeter.As(ElectricResistivityUnit.MegaohmCentimeter), MegaohmsCentimeterTolerance);
@@ -271,7 +271,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            var ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
 
             var kiloohmcentimeterQuantity = ohmmeter.ToUnit(ElectricResistivityUnit.KiloohmCentimeter);
             AssertEx.EqualTolerance(KiloohmsCentimeterInOneOhmMeter, (double)kiloohmcentimeterQuantity.Value, KiloohmsCentimeterTolerance);
@@ -340,41 +340,41 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromKiloohmsCentimeter(ohmmeter.KiloohmsCentimeter).OhmMeters, KiloohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromKiloohmMeters(ohmmeter.KiloohmMeters).OhmMeters, KiloohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMegaohmsCentimeter(ohmmeter.MegaohmsCentimeter).OhmMeters, MegaohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMegaohmMeters(ohmmeter.MegaohmMeters).OhmMeters, MegaohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMicroohmsCentimeter(ohmmeter.MicroohmsCentimeter).OhmMeters, MicroohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMicroohmMeters(ohmmeter.MicroohmMeters).OhmMeters, MicroohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMilliohmsCentimeter(ohmmeter.MilliohmsCentimeter).OhmMeters, MilliohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMilliohmMeters(ohmmeter.MilliohmMeters).OhmMeters, MilliohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromNanoohmsCentimeter(ohmmeter.NanoohmsCentimeter).OhmMeters, NanoohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromNanoohmMeters(ohmmeter.NanoohmMeters).OhmMeters, NanoohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromOhmsCentimeter(ohmmeter.OhmsCentimeter).OhmMeters, OhmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromOhmMeters(ohmmeter.OhmMeters).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromPicoohmsCentimeter(ohmmeter.PicoohmsCentimeter).OhmMeters, PicoohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromPicoohmMeters(ohmmeter.PicoohmMeters).OhmMeters, PicoohmMetersTolerance);
+            ElectricResistivity<double> ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromKiloohmsCentimeter(ohmmeter.KiloohmsCentimeter).OhmMeters, KiloohmsCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromKiloohmMeters(ohmmeter.KiloohmMeters).OhmMeters, KiloohmMetersTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromMegaohmsCentimeter(ohmmeter.MegaohmsCentimeter).OhmMeters, MegaohmsCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromMegaohmMeters(ohmmeter.MegaohmMeters).OhmMeters, MegaohmMetersTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromMicroohmsCentimeter(ohmmeter.MicroohmsCentimeter).OhmMeters, MicroohmsCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromMicroohmMeters(ohmmeter.MicroohmMeters).OhmMeters, MicroohmMetersTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromMilliohmsCentimeter(ohmmeter.MilliohmsCentimeter).OhmMeters, MilliohmsCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromMilliohmMeters(ohmmeter.MilliohmMeters).OhmMeters, MilliohmMetersTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromNanoohmsCentimeter(ohmmeter.NanoohmsCentimeter).OhmMeters, NanoohmsCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromNanoohmMeters(ohmmeter.NanoohmMeters).OhmMeters, NanoohmMetersTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromOhmsCentimeter(ohmmeter.OhmsCentimeter).OhmMeters, OhmsCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromOhmMeters(ohmmeter.OhmMeters).OhmMeters, OhmMetersTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromPicoohmsCentimeter(ohmmeter.PicoohmsCentimeter).OhmMeters, PicoohmsCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricResistivity<double>.FromPicoohmMeters(ohmmeter.PicoohmMeters).OhmMeters, PicoohmMetersTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricResistivity v = ElectricResistivity.FromOhmMeters(1);
+            ElectricResistivity<double> v = ElectricResistivity<double>.FromOhmMeters(1);
             AssertEx.EqualTolerance(-1, -v.OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistivity.FromOhmMeters(3)-v).OhmMeters, OhmMetersTolerance);
+            AssertEx.EqualTolerance(2, (ElectricResistivity<double>.FromOhmMeters(3)-v).OhmMeters, OhmMetersTolerance);
             AssertEx.EqualTolerance(2, (v + v).OhmMeters, OhmMetersTolerance);
             AssertEx.EqualTolerance(10, (v*10).OhmMeters, OhmMetersTolerance);
             AssertEx.EqualTolerance(10, (10*v).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistivity.FromOhmMeters(10)/5).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(2, ElectricResistivity.FromOhmMeters(10)/ElectricResistivity.FromOhmMeters(5), OhmMetersTolerance);
+            AssertEx.EqualTolerance(2, (ElectricResistivity<double>.FromOhmMeters(10)/5).OhmMeters, OhmMetersTolerance);
+            AssertEx.EqualTolerance(2, ElectricResistivity<double>.FromOhmMeters(10)/ElectricResistivity<double>.FromOhmMeters(5), OhmMetersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricResistivity oneOhmMeter = ElectricResistivity.FromOhmMeters(1);
-            ElectricResistivity twoOhmMeters = ElectricResistivity.FromOhmMeters(2);
+            ElectricResistivity<double> oneOhmMeter = ElectricResistivity<double>.FromOhmMeters(1);
+            ElectricResistivity<double> twoOhmMeters = ElectricResistivity<double>.FromOhmMeters(2);
 
             Assert.True(oneOhmMeter < twoOhmMeters);
             Assert.True(oneOhmMeter <= twoOhmMeters);
@@ -390,31 +390,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            ElectricResistivity<double> ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
             Assert.Equal(0, ohmmeter.CompareTo(ohmmeter));
-            Assert.True(ohmmeter.CompareTo(ElectricResistivity.Zero) > 0);
-            Assert.True(ElectricResistivity.Zero.CompareTo(ohmmeter) < 0);
+            Assert.True(ohmmeter.CompareTo(ElectricResistivity<double>.Zero) > 0);
+            Assert.True(ElectricResistivity<double>.Zero.CompareTo(ohmmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            ElectricResistivity<double> ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
             Assert.Throws<ArgumentException>(() => ohmmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            ElectricResistivity<double> ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
             Assert.Throws<ArgumentNullException>(() => ohmmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricResistivity.FromOhmMeters(1);
-            var b = ElectricResistivity.FromOhmMeters(2);
+            var a = ElectricResistivity<double>.FromOhmMeters(1);
+            var b = ElectricResistivity<double>.FromOhmMeters(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -433,8 +433,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricResistivity.FromOhmMeters(1);
-            var b = ElectricResistivity.FromOhmMeters(2);
+            var a = ElectricResistivity<double>.FromOhmMeters(1);
+            var b = ElectricResistivity<double>.FromOhmMeters(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -454,9 +454,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricResistivity.FromOhmMeters(1);
-            Assert.True(v.Equals(ElectricResistivity.FromOhmMeters(1), OhmMetersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricResistivity.Zero, OhmMetersTolerance, ComparisonType.Relative));
+            var v = ElectricResistivity<double>.FromOhmMeters(1);
+            Assert.True(v.Equals(ElectricResistivity<double>.FromOhmMeters(1), OhmMetersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricResistivity<double>.Zero, OhmMetersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -469,21 +469,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            ElectricResistivity<double> ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
             Assert.False(ohmmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
+            ElectricResistivity<double> ohmmeter = ElectricResistivity<double>.FromOhmMeters(1);
             Assert.False(ohmmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricResistivityUnit.Undefined, ElectricResistivity.Units);
+            Assert.DoesNotContain(ElectricResistivityUnit.Undefined, ElectricResistivity<double>.Units);
         }
 
         [Fact]
@@ -502,7 +502,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricResistivity.BaseDimensions is null);
+            Assert.False(ElectricResistivity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs
index 3ac08a0753..62566e29ab 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class ElectricSurfaceChargeDensityTestsBase : QuantityTe
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity((double)0.0, ElectricSurfaceChargeDensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>((double)0.0, ElectricSurfaceChargeDensityUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity(double.PositiveInfinity, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
-            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity(double.NegativeInfinity, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>(double.PositiveInfinity, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>(double.NegativeInfinity, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity(double.NaN, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new ElectricSurfaceChargeDensity<double>(double.NaN, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void ElectricSurfaceChargeDensity_QuantityInfo_ReturnsQuantityInfoDescrib
         [Fact]
         public void CoulombPerSquareMeterToElectricSurfaceChargeDensityUnits()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             AssertEx.EqualTolerance(CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter, coulombpersquaremeter.CoulombsPerSquareCentimeter, CoulombsPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(CoulombsPerSquareInchInOneCoulombPerSquareMeter, coulombpersquaremeter.CoulombsPerSquareInch, CoulombsPerSquareInchTolerance);
             AssertEx.EqualTolerance(CoulombsPerSquareMeterInOneCoulombPerSquareMeter, coulombpersquaremeter.CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
@@ -127,15 +127,15 @@ public void CoulombPerSquareMeterToElectricSurfaceChargeDensityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ElectricSurfaceChargeDensity.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
+            var quantity00 = ElectricSurfaceChargeDensity<double>.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity00.CoulombsPerSquareCentimeter, CoulombsPerSquareCentimeterTolerance);
             Assert.Equal(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, quantity00.Unit);
 
-            var quantity01 = ElectricSurfaceChargeDensity.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
+            var quantity01 = ElectricSurfaceChargeDensity<double>.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
             AssertEx.EqualTolerance(1, quantity01.CoulombsPerSquareInch, CoulombsPerSquareInchTolerance);
             Assert.Equal(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, quantity01.Unit);
 
-            var quantity02 = ElectricSurfaceChargeDensity.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
+            var quantity02 = ElectricSurfaceChargeDensity<double>.From(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity02.CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
             Assert.Equal(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCoulombsPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCoulombsPerSquareMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            var coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             AssertEx.EqualTolerance(CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter, coulombpersquaremeter.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter), CoulombsPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(CoulombsPerSquareInchInOneCoulombPerSquareMeter, coulombpersquaremeter.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch), CoulombsPerSquareInchTolerance);
             AssertEx.EqualTolerance(CoulombsPerSquareMeterInOneCoulombPerSquareMeter, coulombpersquaremeter.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter), CoulombsPerSquareMeterTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            var coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
 
             var coulombpersquarecentimeterQuantity = coulombpersquaremeter.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
             AssertEx.EqualTolerance(CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter, (double)coulombpersquarecentimeterQuantity.Value, CoulombsPerSquareCentimeterTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(coulombpersquaremeter.CoulombsPerSquareCentimeter).CoulombsPerSquareMeter, CoulombsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(coulombpersquaremeter.CoulombsPerSquareInch).CoulombsPerSquareMeter, CoulombsPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(coulombpersquaremeter.CoulombsPerSquareMeter).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareCentimeter(coulombpersquaremeter.CoulombsPerSquareCentimeter).CoulombsPerSquareMeter, CoulombsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareInch(coulombpersquaremeter.CoulombsPerSquareInch).CoulombsPerSquareMeter, CoulombsPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(coulombpersquaremeter.CoulombsPerSquareMeter).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ElectricSurfaceChargeDensity v = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> v = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             AssertEx.EqualTolerance(-1, -v.CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(3)-v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(3)-v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(10)/5).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(10)/ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(5), CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(10)/5).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(10)/ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(5), CoulombsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ElectricSurfaceChargeDensity oneCoulombPerSquareMeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
-            ElectricSurfaceChargeDensity twoCoulombsPerSquareMeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(2);
+            ElectricSurfaceChargeDensity<double> oneCoulombPerSquareMeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> twoCoulombsPerSquareMeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(2);
 
             Assert.True(oneCoulombPerSquareMeter < twoCoulombsPerSquareMeter);
             Assert.True(oneCoulombPerSquareMeter <= twoCoulombsPerSquareMeter);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             Assert.Equal(0, coulombpersquaremeter.CompareTo(coulombpersquaremeter));
-            Assert.True(coulombpersquaremeter.CompareTo(ElectricSurfaceChargeDensity.Zero) > 0);
-            Assert.True(ElectricSurfaceChargeDensity.Zero.CompareTo(coulombpersquaremeter) < 0);
+            Assert.True(coulombpersquaremeter.CompareTo(ElectricSurfaceChargeDensity<double>.Zero) > 0);
+            Assert.True(ElectricSurfaceChargeDensity<double>.Zero.CompareTo(coulombpersquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             Assert.Throws<ArgumentException>(() => coulombpersquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             Assert.Throws<ArgumentNullException>(() => coulombpersquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
-            var b = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(2);
+            var a = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            var b = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
-            var b = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(2);
+            var a = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            var b = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
-            Assert.True(v.Equals(ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1), CoulombsPerSquareMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ElectricSurfaceChargeDensity.Zero, CoulombsPerSquareMeterTolerance, ComparisonType.Relative));
+            var v = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
+            Assert.True(v.Equals(ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1), CoulombsPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ElectricSurfaceChargeDensity<double>.Zero, CoulombsPerSquareMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             Assert.False(coulombpersquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
+            ElectricSurfaceChargeDensity<double> coulombpersquaremeter = ElectricSurfaceChargeDensity<double>.FromCoulombsPerSquareMeter(1);
             Assert.False(coulombpersquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ElectricSurfaceChargeDensityUnit.Undefined, ElectricSurfaceChargeDensity.Units);
+            Assert.DoesNotContain(ElectricSurfaceChargeDensityUnit.Undefined, ElectricSurfaceChargeDensity<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ElectricSurfaceChargeDensity.BaseDimensions is null);
+            Assert.False(ElectricSurfaceChargeDensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs
index bd2b2db264..fda40d7bf1 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs
@@ -116,7 +116,7 @@ public abstract partial class EnergyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Energy((double)0.0, EnergyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Energy<double>((double)0.0, EnergyUnit.Undefined));
         }
 
         [Fact]
@@ -131,14 +131,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Energy(double.PositiveInfinity, EnergyUnit.Joule));
-            Assert.Throws<ArgumentException>(() => new Energy(double.NegativeInfinity, EnergyUnit.Joule));
+            Assert.Throws<ArgumentException>(() => new Energy<double>(double.PositiveInfinity, EnergyUnit.Joule));
+            Assert.Throws<ArgumentException>(() => new Energy<double>(double.NegativeInfinity, EnergyUnit.Joule));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Energy(double.NaN, EnergyUnit.Joule));
+            Assert.Throws<ArgumentException>(() => new Energy<double>(double.NaN, EnergyUnit.Joule));
         }
 
         [Fact]
@@ -184,7 +184,7 @@ public void Energy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void JouleToEnergyUnits()
         {
-            Energy joule = Energy.FromJoules(1);
+            Energy<double> joule = Energy<double>.FromJoules(1);
             AssertEx.EqualTolerance(BritishThermalUnitsInOneJoule, joule.BritishThermalUnits, BritishThermalUnitsTolerance);
             AssertEx.EqualTolerance(CaloriesInOneJoule, joule.Calories, CaloriesTolerance);
             AssertEx.EqualTolerance(DecathermsEcInOneJoule, joule.DecathermsEc, DecathermsEcTolerance);
@@ -226,147 +226,147 @@ public void JouleToEnergyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Energy.From(1, EnergyUnit.BritishThermalUnit);
+            var quantity00 = Energy<double>.From(1, EnergyUnit.BritishThermalUnit);
             AssertEx.EqualTolerance(1, quantity00.BritishThermalUnits, BritishThermalUnitsTolerance);
             Assert.Equal(EnergyUnit.BritishThermalUnit, quantity00.Unit);
 
-            var quantity01 = Energy.From(1, EnergyUnit.Calorie);
+            var quantity01 = Energy<double>.From(1, EnergyUnit.Calorie);
             AssertEx.EqualTolerance(1, quantity01.Calories, CaloriesTolerance);
             Assert.Equal(EnergyUnit.Calorie, quantity01.Unit);
 
-            var quantity02 = Energy.From(1, EnergyUnit.DecathermEc);
+            var quantity02 = Energy<double>.From(1, EnergyUnit.DecathermEc);
             AssertEx.EqualTolerance(1, quantity02.DecathermsEc, DecathermsEcTolerance);
             Assert.Equal(EnergyUnit.DecathermEc, quantity02.Unit);
 
-            var quantity03 = Energy.From(1, EnergyUnit.DecathermImperial);
+            var quantity03 = Energy<double>.From(1, EnergyUnit.DecathermImperial);
             AssertEx.EqualTolerance(1, quantity03.DecathermsImperial, DecathermsImperialTolerance);
             Assert.Equal(EnergyUnit.DecathermImperial, quantity03.Unit);
 
-            var quantity04 = Energy.From(1, EnergyUnit.DecathermUs);
+            var quantity04 = Energy<double>.From(1, EnergyUnit.DecathermUs);
             AssertEx.EqualTolerance(1, quantity04.DecathermsUs, DecathermsUsTolerance);
             Assert.Equal(EnergyUnit.DecathermUs, quantity04.Unit);
 
-            var quantity05 = Energy.From(1, EnergyUnit.ElectronVolt);
+            var quantity05 = Energy<double>.From(1, EnergyUnit.ElectronVolt);
             AssertEx.EqualTolerance(1, quantity05.ElectronVolts, ElectronVoltsTolerance);
             Assert.Equal(EnergyUnit.ElectronVolt, quantity05.Unit);
 
-            var quantity06 = Energy.From(1, EnergyUnit.Erg);
+            var quantity06 = Energy<double>.From(1, EnergyUnit.Erg);
             AssertEx.EqualTolerance(1, quantity06.Ergs, ErgsTolerance);
             Assert.Equal(EnergyUnit.Erg, quantity06.Unit);
 
-            var quantity07 = Energy.From(1, EnergyUnit.FootPound);
+            var quantity07 = Energy<double>.From(1, EnergyUnit.FootPound);
             AssertEx.EqualTolerance(1, quantity07.FootPounds, FootPoundsTolerance);
             Assert.Equal(EnergyUnit.FootPound, quantity07.Unit);
 
-            var quantity08 = Energy.From(1, EnergyUnit.GigabritishThermalUnit);
+            var quantity08 = Energy<double>.From(1, EnergyUnit.GigabritishThermalUnit);
             AssertEx.EqualTolerance(1, quantity08.GigabritishThermalUnits, GigabritishThermalUnitsTolerance);
             Assert.Equal(EnergyUnit.GigabritishThermalUnit, quantity08.Unit);
 
-            var quantity09 = Energy.From(1, EnergyUnit.GigaelectronVolt);
+            var quantity09 = Energy<double>.From(1, EnergyUnit.GigaelectronVolt);
             AssertEx.EqualTolerance(1, quantity09.GigaelectronVolts, GigaelectronVoltsTolerance);
             Assert.Equal(EnergyUnit.GigaelectronVolt, quantity09.Unit);
 
-            var quantity10 = Energy.From(1, EnergyUnit.Gigajoule);
+            var quantity10 = Energy<double>.From(1, EnergyUnit.Gigajoule);
             AssertEx.EqualTolerance(1, quantity10.Gigajoules, GigajoulesTolerance);
             Assert.Equal(EnergyUnit.Gigajoule, quantity10.Unit);
 
-            var quantity11 = Energy.From(1, EnergyUnit.GigawattDay);
+            var quantity11 = Energy<double>.From(1, EnergyUnit.GigawattDay);
             AssertEx.EqualTolerance(1, quantity11.GigawattDays, GigawattDaysTolerance);
             Assert.Equal(EnergyUnit.GigawattDay, quantity11.Unit);
 
-            var quantity12 = Energy.From(1, EnergyUnit.GigawattHour);
+            var quantity12 = Energy<double>.From(1, EnergyUnit.GigawattHour);
             AssertEx.EqualTolerance(1, quantity12.GigawattHours, GigawattHoursTolerance);
             Assert.Equal(EnergyUnit.GigawattHour, quantity12.Unit);
 
-            var quantity13 = Energy.From(1, EnergyUnit.HorsepowerHour);
+            var quantity13 = Energy<double>.From(1, EnergyUnit.HorsepowerHour);
             AssertEx.EqualTolerance(1, quantity13.HorsepowerHours, HorsepowerHoursTolerance);
             Assert.Equal(EnergyUnit.HorsepowerHour, quantity13.Unit);
 
-            var quantity14 = Energy.From(1, EnergyUnit.Joule);
+            var quantity14 = Energy<double>.From(1, EnergyUnit.Joule);
             AssertEx.EqualTolerance(1, quantity14.Joules, JoulesTolerance);
             Assert.Equal(EnergyUnit.Joule, quantity14.Unit);
 
-            var quantity15 = Energy.From(1, EnergyUnit.KilobritishThermalUnit);
+            var quantity15 = Energy<double>.From(1, EnergyUnit.KilobritishThermalUnit);
             AssertEx.EqualTolerance(1, quantity15.KilobritishThermalUnits, KilobritishThermalUnitsTolerance);
             Assert.Equal(EnergyUnit.KilobritishThermalUnit, quantity15.Unit);
 
-            var quantity16 = Energy.From(1, EnergyUnit.Kilocalorie);
+            var quantity16 = Energy<double>.From(1, EnergyUnit.Kilocalorie);
             AssertEx.EqualTolerance(1, quantity16.Kilocalories, KilocaloriesTolerance);
             Assert.Equal(EnergyUnit.Kilocalorie, quantity16.Unit);
 
-            var quantity17 = Energy.From(1, EnergyUnit.KiloelectronVolt);
+            var quantity17 = Energy<double>.From(1, EnergyUnit.KiloelectronVolt);
             AssertEx.EqualTolerance(1, quantity17.KiloelectronVolts, KiloelectronVoltsTolerance);
             Assert.Equal(EnergyUnit.KiloelectronVolt, quantity17.Unit);
 
-            var quantity18 = Energy.From(1, EnergyUnit.Kilojoule);
+            var quantity18 = Energy<double>.From(1, EnergyUnit.Kilojoule);
             AssertEx.EqualTolerance(1, quantity18.Kilojoules, KilojoulesTolerance);
             Assert.Equal(EnergyUnit.Kilojoule, quantity18.Unit);
 
-            var quantity19 = Energy.From(1, EnergyUnit.KilowattDay);
+            var quantity19 = Energy<double>.From(1, EnergyUnit.KilowattDay);
             AssertEx.EqualTolerance(1, quantity19.KilowattDays, KilowattDaysTolerance);
             Assert.Equal(EnergyUnit.KilowattDay, quantity19.Unit);
 
-            var quantity20 = Energy.From(1, EnergyUnit.KilowattHour);
+            var quantity20 = Energy<double>.From(1, EnergyUnit.KilowattHour);
             AssertEx.EqualTolerance(1, quantity20.KilowattHours, KilowattHoursTolerance);
             Assert.Equal(EnergyUnit.KilowattHour, quantity20.Unit);
 
-            var quantity21 = Energy.From(1, EnergyUnit.MegabritishThermalUnit);
+            var quantity21 = Energy<double>.From(1, EnergyUnit.MegabritishThermalUnit);
             AssertEx.EqualTolerance(1, quantity21.MegabritishThermalUnits, MegabritishThermalUnitsTolerance);
             Assert.Equal(EnergyUnit.MegabritishThermalUnit, quantity21.Unit);
 
-            var quantity22 = Energy.From(1, EnergyUnit.Megacalorie);
+            var quantity22 = Energy<double>.From(1, EnergyUnit.Megacalorie);
             AssertEx.EqualTolerance(1, quantity22.Megacalories, MegacaloriesTolerance);
             Assert.Equal(EnergyUnit.Megacalorie, quantity22.Unit);
 
-            var quantity23 = Energy.From(1, EnergyUnit.MegaelectronVolt);
+            var quantity23 = Energy<double>.From(1, EnergyUnit.MegaelectronVolt);
             AssertEx.EqualTolerance(1, quantity23.MegaelectronVolts, MegaelectronVoltsTolerance);
             Assert.Equal(EnergyUnit.MegaelectronVolt, quantity23.Unit);
 
-            var quantity24 = Energy.From(1, EnergyUnit.Megajoule);
+            var quantity24 = Energy<double>.From(1, EnergyUnit.Megajoule);
             AssertEx.EqualTolerance(1, quantity24.Megajoules, MegajoulesTolerance);
             Assert.Equal(EnergyUnit.Megajoule, quantity24.Unit);
 
-            var quantity25 = Energy.From(1, EnergyUnit.MegawattDay);
+            var quantity25 = Energy<double>.From(1, EnergyUnit.MegawattDay);
             AssertEx.EqualTolerance(1, quantity25.MegawattDays, MegawattDaysTolerance);
             Assert.Equal(EnergyUnit.MegawattDay, quantity25.Unit);
 
-            var quantity26 = Energy.From(1, EnergyUnit.MegawattHour);
+            var quantity26 = Energy<double>.From(1, EnergyUnit.MegawattHour);
             AssertEx.EqualTolerance(1, quantity26.MegawattHours, MegawattHoursTolerance);
             Assert.Equal(EnergyUnit.MegawattHour, quantity26.Unit);
 
-            var quantity27 = Energy.From(1, EnergyUnit.Millijoule);
+            var quantity27 = Energy<double>.From(1, EnergyUnit.Millijoule);
             AssertEx.EqualTolerance(1, quantity27.Millijoules, MillijoulesTolerance);
             Assert.Equal(EnergyUnit.Millijoule, quantity27.Unit);
 
-            var quantity28 = Energy.From(1, EnergyUnit.TeraelectronVolt);
+            var quantity28 = Energy<double>.From(1, EnergyUnit.TeraelectronVolt);
             AssertEx.EqualTolerance(1, quantity28.TeraelectronVolts, TeraelectronVoltsTolerance);
             Assert.Equal(EnergyUnit.TeraelectronVolt, quantity28.Unit);
 
-            var quantity29 = Energy.From(1, EnergyUnit.TerawattDay);
+            var quantity29 = Energy<double>.From(1, EnergyUnit.TerawattDay);
             AssertEx.EqualTolerance(1, quantity29.TerawattDays, TerawattDaysTolerance);
             Assert.Equal(EnergyUnit.TerawattDay, quantity29.Unit);
 
-            var quantity30 = Energy.From(1, EnergyUnit.TerawattHour);
+            var quantity30 = Energy<double>.From(1, EnergyUnit.TerawattHour);
             AssertEx.EqualTolerance(1, quantity30.TerawattHours, TerawattHoursTolerance);
             Assert.Equal(EnergyUnit.TerawattHour, quantity30.Unit);
 
-            var quantity31 = Energy.From(1, EnergyUnit.ThermEc);
+            var quantity31 = Energy<double>.From(1, EnergyUnit.ThermEc);
             AssertEx.EqualTolerance(1, quantity31.ThermsEc, ThermsEcTolerance);
             Assert.Equal(EnergyUnit.ThermEc, quantity31.Unit);
 
-            var quantity32 = Energy.From(1, EnergyUnit.ThermImperial);
+            var quantity32 = Energy<double>.From(1, EnergyUnit.ThermImperial);
             AssertEx.EqualTolerance(1, quantity32.ThermsImperial, ThermsImperialTolerance);
             Assert.Equal(EnergyUnit.ThermImperial, quantity32.Unit);
 
-            var quantity33 = Energy.From(1, EnergyUnit.ThermUs);
+            var quantity33 = Energy<double>.From(1, EnergyUnit.ThermUs);
             AssertEx.EqualTolerance(1, quantity33.ThermsUs, ThermsUsTolerance);
             Assert.Equal(EnergyUnit.ThermUs, quantity33.Unit);
 
-            var quantity34 = Energy.From(1, EnergyUnit.WattDay);
+            var quantity34 = Energy<double>.From(1, EnergyUnit.WattDay);
             AssertEx.EqualTolerance(1, quantity34.WattDays, WattDaysTolerance);
             Assert.Equal(EnergyUnit.WattDay, quantity34.Unit);
 
-            var quantity35 = Energy.From(1, EnergyUnit.WattHour);
+            var quantity35 = Energy<double>.From(1, EnergyUnit.WattHour);
             AssertEx.EqualTolerance(1, quantity35.WattHours, WattHoursTolerance);
             Assert.Equal(EnergyUnit.WattHour, quantity35.Unit);
 
@@ -375,20 +375,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromJoules_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Energy.FromJoules(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Energy.FromJoules(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Energy<double>.FromJoules(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Energy<double>.FromJoules(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromJoules_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Energy.FromJoules(double.NaN));
+            Assert.Throws<ArgumentException>(() => Energy<double>.FromJoules(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var joule = Energy.FromJoules(1);
+            var joule = Energy<double>.FromJoules(1);
             AssertEx.EqualTolerance(BritishThermalUnitsInOneJoule, joule.As(EnergyUnit.BritishThermalUnit), BritishThermalUnitsTolerance);
             AssertEx.EqualTolerance(CaloriesInOneJoule, joule.As(EnergyUnit.Calorie), CaloriesTolerance);
             AssertEx.EqualTolerance(DecathermsEcInOneJoule, joule.As(EnergyUnit.DecathermEc), DecathermsEcTolerance);
@@ -447,7 +447,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var joule = Energy.FromJoules(1);
+            var joule = Energy<double>.FromJoules(1);
 
             var britishthermalunitQuantity = joule.ToUnit(EnergyUnit.BritishThermalUnit);
             AssertEx.EqualTolerance(BritishThermalUnitsInOneJoule, (double)britishthermalunitQuantity.Value, BritishThermalUnitsTolerance);
@@ -604,63 +604,63 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Energy joule = Energy.FromJoules(1);
-            AssertEx.EqualTolerance(1, Energy.FromBritishThermalUnits(joule.BritishThermalUnits).Joules, BritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromCalories(joule.Calories).Joules, CaloriesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromDecathermsEc(joule.DecathermsEc).Joules, DecathermsEcTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromDecathermsImperial(joule.DecathermsImperial).Joules, DecathermsImperialTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromDecathermsUs(joule.DecathermsUs).Joules, DecathermsUsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromElectronVolts(joule.ElectronVolts).Joules, ElectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromErgs(joule.Ergs).Joules, ErgsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromFootPounds(joule.FootPounds).Joules, FootPoundsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigabritishThermalUnits(joule.GigabritishThermalUnits).Joules, GigabritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigaelectronVolts(joule.GigaelectronVolts).Joules, GigaelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigajoules(joule.Gigajoules).Joules, GigajoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigawattDays(joule.GigawattDays).Joules, GigawattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigawattHours(joule.GigawattHours).Joules, GigawattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromHorsepowerHours(joule.HorsepowerHours).Joules, HorsepowerHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromJoules(joule.Joules).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilobritishThermalUnits(joule.KilobritishThermalUnits).Joules, KilobritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilocalories(joule.Kilocalories).Joules, KilocaloriesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKiloelectronVolts(joule.KiloelectronVolts).Joules, KiloelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilojoules(joule.Kilojoules).Joules, KilojoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilowattDays(joule.KilowattDays).Joules, KilowattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilowattHours(joule.KilowattHours).Joules, KilowattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegabritishThermalUnits(joule.MegabritishThermalUnits).Joules, MegabritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegacalories(joule.Megacalories).Joules, MegacaloriesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegaelectronVolts(joule.MegaelectronVolts).Joules, MegaelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegajoules(joule.Megajoules).Joules, MegajoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegawattDays(joule.MegawattDays).Joules, MegawattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegawattHours(joule.MegawattHours).Joules, MegawattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMillijoules(joule.Millijoules).Joules, MillijoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromTeraelectronVolts(joule.TeraelectronVolts).Joules, TeraelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromTerawattDays(joule.TerawattDays).Joules, TerawattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromTerawattHours(joule.TerawattHours).Joules, TerawattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromThermsEc(joule.ThermsEc).Joules, ThermsEcTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromThermsImperial(joule.ThermsImperial).Joules, ThermsImperialTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromThermsUs(joule.ThermsUs).Joules, ThermsUsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromWattDays(joule.WattDays).Joules, WattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromWattHours(joule.WattHours).Joules, WattHoursTolerance);
+            Energy<double> joule = Energy<double>.FromJoules(1);
+            AssertEx.EqualTolerance(1, Energy<double>.FromBritishThermalUnits(joule.BritishThermalUnits).Joules, BritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromCalories(joule.Calories).Joules, CaloriesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromDecathermsEc(joule.DecathermsEc).Joules, DecathermsEcTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromDecathermsImperial(joule.DecathermsImperial).Joules, DecathermsImperialTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromDecathermsUs(joule.DecathermsUs).Joules, DecathermsUsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromElectronVolts(joule.ElectronVolts).Joules, ElectronVoltsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromErgs(joule.Ergs).Joules, ErgsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromFootPounds(joule.FootPounds).Joules, FootPoundsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromGigabritishThermalUnits(joule.GigabritishThermalUnits).Joules, GigabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromGigaelectronVolts(joule.GigaelectronVolts).Joules, GigaelectronVoltsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromGigajoules(joule.Gigajoules).Joules, GigajoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromGigawattDays(joule.GigawattDays).Joules, GigawattDaysTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromGigawattHours(joule.GigawattHours).Joules, GigawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromHorsepowerHours(joule.HorsepowerHours).Joules, HorsepowerHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromJoules(joule.Joules).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilobritishThermalUnits(joule.KilobritishThermalUnits).Joules, KilobritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilocalories(joule.Kilocalories).Joules, KilocaloriesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKiloelectronVolts(joule.KiloelectronVolts).Joules, KiloelectronVoltsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilojoules(joule.Kilojoules).Joules, KilojoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilowattDays(joule.KilowattDays).Joules, KilowattDaysTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromKilowattHours(joule.KilowattHours).Joules, KilowattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegabritishThermalUnits(joule.MegabritishThermalUnits).Joules, MegabritishThermalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegacalories(joule.Megacalories).Joules, MegacaloriesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegaelectronVolts(joule.MegaelectronVolts).Joules, MegaelectronVoltsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegajoules(joule.Megajoules).Joules, MegajoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegawattDays(joule.MegawattDays).Joules, MegawattDaysTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMegawattHours(joule.MegawattHours).Joules, MegawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromMillijoules(joule.Millijoules).Joules, MillijoulesTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromTeraelectronVolts(joule.TeraelectronVolts).Joules, TeraelectronVoltsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromTerawattDays(joule.TerawattDays).Joules, TerawattDaysTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromTerawattHours(joule.TerawattHours).Joules, TerawattHoursTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromThermsEc(joule.ThermsEc).Joules, ThermsEcTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromThermsImperial(joule.ThermsImperial).Joules, ThermsImperialTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromThermsUs(joule.ThermsUs).Joules, ThermsUsTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromWattDays(joule.WattDays).Joules, WattDaysTolerance);
+            AssertEx.EqualTolerance(1, Energy<double>.FromWattHours(joule.WattHours).Joules, WattHoursTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Energy v = Energy.FromJoules(1);
+            Energy<double> v = Energy<double>.FromJoules(1);
             AssertEx.EqualTolerance(-1, -v.Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(2, (Energy.FromJoules(3)-v).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(2, (Energy<double>.FromJoules(3)-v).Joules, JoulesTolerance);
             AssertEx.EqualTolerance(2, (v + v).Joules, JoulesTolerance);
             AssertEx.EqualTolerance(10, (v*10).Joules, JoulesTolerance);
             AssertEx.EqualTolerance(10, (10*v).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(2, (Energy.FromJoules(10)/5).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(2, Energy.FromJoules(10)/Energy.FromJoules(5), JoulesTolerance);
+            AssertEx.EqualTolerance(2, (Energy<double>.FromJoules(10)/5).Joules, JoulesTolerance);
+            AssertEx.EqualTolerance(2, Energy<double>.FromJoules(10)/Energy<double>.FromJoules(5), JoulesTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Energy oneJoule = Energy.FromJoules(1);
-            Energy twoJoules = Energy.FromJoules(2);
+            Energy<double> oneJoule = Energy<double>.FromJoules(1);
+            Energy<double> twoJoules = Energy<double>.FromJoules(2);
 
             Assert.True(oneJoule < twoJoules);
             Assert.True(oneJoule <= twoJoules);
@@ -676,31 +676,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Energy joule = Energy.FromJoules(1);
+            Energy<double> joule = Energy<double>.FromJoules(1);
             Assert.Equal(0, joule.CompareTo(joule));
-            Assert.True(joule.CompareTo(Energy.Zero) > 0);
-            Assert.True(Energy.Zero.CompareTo(joule) < 0);
+            Assert.True(joule.CompareTo(Energy<double>.Zero) > 0);
+            Assert.True(Energy<double>.Zero.CompareTo(joule) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Energy joule = Energy.FromJoules(1);
+            Energy<double> joule = Energy<double>.FromJoules(1);
             Assert.Throws<ArgumentException>(() => joule.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Energy joule = Energy.FromJoules(1);
+            Energy<double> joule = Energy<double>.FromJoules(1);
             Assert.Throws<ArgumentNullException>(() => joule.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Energy.FromJoules(1);
-            var b = Energy.FromJoules(2);
+            var a = Energy<double>.FromJoules(1);
+            var b = Energy<double>.FromJoules(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -719,8 +719,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Energy.FromJoules(1);
-            var b = Energy.FromJoules(2);
+            var a = Energy<double>.FromJoules(1);
+            var b = Energy<double>.FromJoules(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -740,9 +740,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Energy.FromJoules(1);
-            Assert.True(v.Equals(Energy.FromJoules(1), JoulesTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Energy.Zero, JoulesTolerance, ComparisonType.Relative));
+            var v = Energy<double>.FromJoules(1);
+            Assert.True(v.Equals(Energy<double>.FromJoules(1), JoulesTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Energy<double>.Zero, JoulesTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -755,21 +755,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Energy joule = Energy.FromJoules(1);
+            Energy<double> joule = Energy<double>.FromJoules(1);
             Assert.False(joule.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Energy joule = Energy.FromJoules(1);
+            Energy<double> joule = Energy<double>.FromJoules(1);
             Assert.False(joule.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(EnergyUnit.Undefined, Energy.Units);
+            Assert.DoesNotContain(EnergyUnit.Undefined, Energy<double>.Units);
         }
 
         [Fact]
@@ -788,7 +788,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Energy.BaseDimensions is null);
+            Assert.False(Energy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs
index 26b92ed9b4..0704e2bacb 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs
@@ -58,7 +58,7 @@ public abstract partial class EntropyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Entropy((double)0.0, EntropyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Entropy<double>((double)0.0, EntropyUnit.Undefined));
         }
 
         [Fact]
@@ -73,14 +73,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Entropy(double.PositiveInfinity, EntropyUnit.JoulePerKelvin));
-            Assert.Throws<ArgumentException>(() => new Entropy(double.NegativeInfinity, EntropyUnit.JoulePerKelvin));
+            Assert.Throws<ArgumentException>(() => new Entropy<double>(double.PositiveInfinity, EntropyUnit.JoulePerKelvin));
+            Assert.Throws<ArgumentException>(() => new Entropy<double>(double.NegativeInfinity, EntropyUnit.JoulePerKelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Entropy(double.NaN, EntropyUnit.JoulePerKelvin));
+            Assert.Throws<ArgumentException>(() => new Entropy<double>(double.NaN, EntropyUnit.JoulePerKelvin));
         }
 
         [Fact]
@@ -126,7 +126,7 @@ public void Entropy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void JoulePerKelvinToEntropyUnits()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
             AssertEx.EqualTolerance(CaloriesPerKelvinInOneJoulePerKelvin, jouleperkelvin.CaloriesPerKelvin, CaloriesPerKelvinTolerance);
             AssertEx.EqualTolerance(JoulesPerDegreeCelsiusInOneJoulePerKelvin, jouleperkelvin.JoulesPerDegreeCelsius, JoulesPerDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(JoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.JoulesPerKelvin, JoulesPerKelvinTolerance);
@@ -139,31 +139,31 @@ public void JoulePerKelvinToEntropyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Entropy.From(1, EntropyUnit.CaloriePerKelvin);
+            var quantity00 = Entropy<double>.From(1, EntropyUnit.CaloriePerKelvin);
             AssertEx.EqualTolerance(1, quantity00.CaloriesPerKelvin, CaloriesPerKelvinTolerance);
             Assert.Equal(EntropyUnit.CaloriePerKelvin, quantity00.Unit);
 
-            var quantity01 = Entropy.From(1, EntropyUnit.JoulePerDegreeCelsius);
+            var quantity01 = Entropy<double>.From(1, EntropyUnit.JoulePerDegreeCelsius);
             AssertEx.EqualTolerance(1, quantity01.JoulesPerDegreeCelsius, JoulesPerDegreeCelsiusTolerance);
             Assert.Equal(EntropyUnit.JoulePerDegreeCelsius, quantity01.Unit);
 
-            var quantity02 = Entropy.From(1, EntropyUnit.JoulePerKelvin);
+            var quantity02 = Entropy<double>.From(1, EntropyUnit.JoulePerKelvin);
             AssertEx.EqualTolerance(1, quantity02.JoulesPerKelvin, JoulesPerKelvinTolerance);
             Assert.Equal(EntropyUnit.JoulePerKelvin, quantity02.Unit);
 
-            var quantity03 = Entropy.From(1, EntropyUnit.KilocaloriePerKelvin);
+            var quantity03 = Entropy<double>.From(1, EntropyUnit.KilocaloriePerKelvin);
             AssertEx.EqualTolerance(1, quantity03.KilocaloriesPerKelvin, KilocaloriesPerKelvinTolerance);
             Assert.Equal(EntropyUnit.KilocaloriePerKelvin, quantity03.Unit);
 
-            var quantity04 = Entropy.From(1, EntropyUnit.KilojoulePerDegreeCelsius);
+            var quantity04 = Entropy<double>.From(1, EntropyUnit.KilojoulePerDegreeCelsius);
             AssertEx.EqualTolerance(1, quantity04.KilojoulesPerDegreeCelsius, KilojoulesPerDegreeCelsiusTolerance);
             Assert.Equal(EntropyUnit.KilojoulePerDegreeCelsius, quantity04.Unit);
 
-            var quantity05 = Entropy.From(1, EntropyUnit.KilojoulePerKelvin);
+            var quantity05 = Entropy<double>.From(1, EntropyUnit.KilojoulePerKelvin);
             AssertEx.EqualTolerance(1, quantity05.KilojoulesPerKelvin, KilojoulesPerKelvinTolerance);
             Assert.Equal(EntropyUnit.KilojoulePerKelvin, quantity05.Unit);
 
-            var quantity06 = Entropy.From(1, EntropyUnit.MegajoulePerKelvin);
+            var quantity06 = Entropy<double>.From(1, EntropyUnit.MegajoulePerKelvin);
             AssertEx.EqualTolerance(1, quantity06.MegajoulesPerKelvin, MegajoulesPerKelvinTolerance);
             Assert.Equal(EntropyUnit.MegajoulePerKelvin, quantity06.Unit);
 
@@ -172,20 +172,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromJoulesPerKelvin_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Entropy.FromJoulesPerKelvin(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Entropy.FromJoulesPerKelvin(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Entropy<double>.FromJoulesPerKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Entropy<double>.FromJoulesPerKelvin(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromJoulesPerKelvin_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Entropy.FromJoulesPerKelvin(double.NaN));
+            Assert.Throws<ArgumentException>(() => Entropy<double>.FromJoulesPerKelvin(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            var jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
             AssertEx.EqualTolerance(CaloriesPerKelvinInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.CaloriePerKelvin), CaloriesPerKelvinTolerance);
             AssertEx.EqualTolerance(JoulesPerDegreeCelsiusInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.JoulePerDegreeCelsius), JoulesPerDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(JoulesPerKelvinInOneJoulePerKelvin, jouleperkelvin.As(EntropyUnit.JoulePerKelvin), JoulesPerKelvinTolerance);
@@ -215,7 +215,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            var jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
 
             var calorieperkelvinQuantity = jouleperkelvin.ToUnit(EntropyUnit.CaloriePerKelvin);
             AssertEx.EqualTolerance(CaloriesPerKelvinInOneJoulePerKelvin, (double)calorieperkelvinQuantity.Value, CaloriesPerKelvinTolerance);
@@ -256,34 +256,34 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
-            AssertEx.EqualTolerance(1, Entropy.FromCaloriesPerKelvin(jouleperkelvin.CaloriesPerKelvin).JoulesPerKelvin, CaloriesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromJoulesPerDegreeCelsius(jouleperkelvin.JoulesPerDegreeCelsius).JoulesPerKelvin, JoulesPerDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromJoulesPerKelvin(jouleperkelvin.JoulesPerKelvin).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromKilocaloriesPerKelvin(jouleperkelvin.KilocaloriesPerKelvin).JoulesPerKelvin, KilocaloriesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromKilojoulesPerDegreeCelsius(jouleperkelvin.KilojoulesPerDegreeCelsius).JoulesPerKelvin, KilojoulesPerDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromKilojoulesPerKelvin(jouleperkelvin.KilojoulesPerKelvin).JoulesPerKelvin, KilojoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromMegajoulesPerKelvin(jouleperkelvin.MegajoulesPerKelvin).JoulesPerKelvin, MegajoulesPerKelvinTolerance);
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromCaloriesPerKelvin(jouleperkelvin.CaloriesPerKelvin).JoulesPerKelvin, CaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromJoulesPerDegreeCelsius(jouleperkelvin.JoulesPerDegreeCelsius).JoulesPerKelvin, JoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromJoulesPerKelvin(jouleperkelvin.JoulesPerKelvin).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromKilocaloriesPerKelvin(jouleperkelvin.KilocaloriesPerKelvin).JoulesPerKelvin, KilocaloriesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromKilojoulesPerDegreeCelsius(jouleperkelvin.KilojoulesPerDegreeCelsius).JoulesPerKelvin, KilojoulesPerDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromKilojoulesPerKelvin(jouleperkelvin.KilojoulesPerKelvin).JoulesPerKelvin, KilojoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(1, Entropy<double>.FromMegajoulesPerKelvin(jouleperkelvin.MegajoulesPerKelvin).JoulesPerKelvin, MegajoulesPerKelvinTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Entropy v = Entropy.FromJoulesPerKelvin(1);
+            Entropy<double> v = Entropy<double>.FromJoulesPerKelvin(1);
             AssertEx.EqualTolerance(-1, -v.JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (Entropy.FromJoulesPerKelvin(3)-v).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(2, (Entropy<double>.FromJoulesPerKelvin(3)-v).JoulesPerKelvin, JoulesPerKelvinTolerance);
             AssertEx.EqualTolerance(2, (v + v).JoulesPerKelvin, JoulesPerKelvinTolerance);
             AssertEx.EqualTolerance(10, (v*10).JoulesPerKelvin, JoulesPerKelvinTolerance);
             AssertEx.EqualTolerance(10, (10*v).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (Entropy.FromJoulesPerKelvin(10)/5).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(2, Entropy.FromJoulesPerKelvin(10)/Entropy.FromJoulesPerKelvin(5), JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(2, (Entropy<double>.FromJoulesPerKelvin(10)/5).JoulesPerKelvin, JoulesPerKelvinTolerance);
+            AssertEx.EqualTolerance(2, Entropy<double>.FromJoulesPerKelvin(10)/Entropy<double>.FromJoulesPerKelvin(5), JoulesPerKelvinTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Entropy oneJoulePerKelvin = Entropy.FromJoulesPerKelvin(1);
-            Entropy twoJoulesPerKelvin = Entropy.FromJoulesPerKelvin(2);
+            Entropy<double> oneJoulePerKelvin = Entropy<double>.FromJoulesPerKelvin(1);
+            Entropy<double> twoJoulesPerKelvin = Entropy<double>.FromJoulesPerKelvin(2);
 
             Assert.True(oneJoulePerKelvin < twoJoulesPerKelvin);
             Assert.True(oneJoulePerKelvin <= twoJoulesPerKelvin);
@@ -299,31 +299,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
             Assert.Equal(0, jouleperkelvin.CompareTo(jouleperkelvin));
-            Assert.True(jouleperkelvin.CompareTo(Entropy.Zero) > 0);
-            Assert.True(Entropy.Zero.CompareTo(jouleperkelvin) < 0);
+            Assert.True(jouleperkelvin.CompareTo(Entropy<double>.Zero) > 0);
+            Assert.True(Entropy<double>.Zero.CompareTo(jouleperkelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
             Assert.Throws<ArgumentException>(() => jouleperkelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
             Assert.Throws<ArgumentNullException>(() => jouleperkelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Entropy.FromJoulesPerKelvin(1);
-            var b = Entropy.FromJoulesPerKelvin(2);
+            var a = Entropy<double>.FromJoulesPerKelvin(1);
+            var b = Entropy<double>.FromJoulesPerKelvin(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -342,8 +342,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Entropy.FromJoulesPerKelvin(1);
-            var b = Entropy.FromJoulesPerKelvin(2);
+            var a = Entropy<double>.FromJoulesPerKelvin(1);
+            var b = Entropy<double>.FromJoulesPerKelvin(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -363,9 +363,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Entropy.FromJoulesPerKelvin(1);
-            Assert.True(v.Equals(Entropy.FromJoulesPerKelvin(1), JoulesPerKelvinTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Entropy.Zero, JoulesPerKelvinTolerance, ComparisonType.Relative));
+            var v = Entropy<double>.FromJoulesPerKelvin(1);
+            Assert.True(v.Equals(Entropy<double>.FromJoulesPerKelvin(1), JoulesPerKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Entropy<double>.Zero, JoulesPerKelvinTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -378,21 +378,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
             Assert.False(jouleperkelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
+            Entropy<double> jouleperkelvin = Entropy<double>.FromJoulesPerKelvin(1);
             Assert.False(jouleperkelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(EntropyUnit.Undefined, Entropy.Units);
+            Assert.DoesNotContain(EntropyUnit.Undefined, Entropy<double>.Units);
         }
 
         [Fact]
@@ -411,7 +411,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Entropy.BaseDimensions is null);
+            Assert.False(Entropy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs
index f411068d8a..591722f184 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs
@@ -66,7 +66,7 @@ public abstract partial class ForceChangeRateTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ForceChangeRate((double)0.0, ForceChangeRateUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ForceChangeRate<double>((double)0.0, ForceChangeRateUnit.Undefined));
         }
 
         [Fact]
@@ -81,14 +81,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ForceChangeRate(double.PositiveInfinity, ForceChangeRateUnit.NewtonPerSecond));
-            Assert.Throws<ArgumentException>(() => new ForceChangeRate(double.NegativeInfinity, ForceChangeRateUnit.NewtonPerSecond));
+            Assert.Throws<ArgumentException>(() => new ForceChangeRate<double>(double.PositiveInfinity, ForceChangeRateUnit.NewtonPerSecond));
+            Assert.Throws<ArgumentException>(() => new ForceChangeRate<double>(double.NegativeInfinity, ForceChangeRateUnit.NewtonPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ForceChangeRate(double.NaN, ForceChangeRateUnit.NewtonPerSecond));
+            Assert.Throws<ArgumentException>(() => new ForceChangeRate<double>(double.NaN, ForceChangeRateUnit.NewtonPerSecond));
         }
 
         [Fact]
@@ -134,7 +134,7 @@ public void ForceChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void NewtonPerSecondToForceChangeRateUnits()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             AssertEx.EqualTolerance(CentinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.CentinewtonsPerSecond, CentinewtonsPerSecondTolerance);
             AssertEx.EqualTolerance(DecanewtonsPerMinuteInOneNewtonPerSecond, newtonpersecond.DecanewtonsPerMinute, DecanewtonsPerMinuteTolerance);
             AssertEx.EqualTolerance(DecanewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.DecanewtonsPerSecond, DecanewtonsPerSecondTolerance);
@@ -151,47 +151,47 @@ public void NewtonPerSecondToForceChangeRateUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ForceChangeRate.From(1, ForceChangeRateUnit.CentinewtonPerSecond);
+            var quantity00 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.CentinewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity00.CentinewtonsPerSecond, CentinewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.CentinewtonPerSecond, quantity00.Unit);
 
-            var quantity01 = ForceChangeRate.From(1, ForceChangeRateUnit.DecanewtonPerMinute);
+            var quantity01 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.DecanewtonPerMinute);
             AssertEx.EqualTolerance(1, quantity01.DecanewtonsPerMinute, DecanewtonsPerMinuteTolerance);
             Assert.Equal(ForceChangeRateUnit.DecanewtonPerMinute, quantity01.Unit);
 
-            var quantity02 = ForceChangeRate.From(1, ForceChangeRateUnit.DecanewtonPerSecond);
+            var quantity02 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.DecanewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity02.DecanewtonsPerSecond, DecanewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.DecanewtonPerSecond, quantity02.Unit);
 
-            var quantity03 = ForceChangeRate.From(1, ForceChangeRateUnit.DecinewtonPerSecond);
+            var quantity03 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.DecinewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity03.DecinewtonsPerSecond, DecinewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.DecinewtonPerSecond, quantity03.Unit);
 
-            var quantity04 = ForceChangeRate.From(1, ForceChangeRateUnit.KilonewtonPerMinute);
+            var quantity04 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.KilonewtonPerMinute);
             AssertEx.EqualTolerance(1, quantity04.KilonewtonsPerMinute, KilonewtonsPerMinuteTolerance);
             Assert.Equal(ForceChangeRateUnit.KilonewtonPerMinute, quantity04.Unit);
 
-            var quantity05 = ForceChangeRate.From(1, ForceChangeRateUnit.KilonewtonPerSecond);
+            var quantity05 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.KilonewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity05.KilonewtonsPerSecond, KilonewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.KilonewtonPerSecond, quantity05.Unit);
 
-            var quantity06 = ForceChangeRate.From(1, ForceChangeRateUnit.MicronewtonPerSecond);
+            var quantity06 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.MicronewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity06.MicronewtonsPerSecond, MicronewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.MicronewtonPerSecond, quantity06.Unit);
 
-            var quantity07 = ForceChangeRate.From(1, ForceChangeRateUnit.MillinewtonPerSecond);
+            var quantity07 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.MillinewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity07.MillinewtonsPerSecond, MillinewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.MillinewtonPerSecond, quantity07.Unit);
 
-            var quantity08 = ForceChangeRate.From(1, ForceChangeRateUnit.NanonewtonPerSecond);
+            var quantity08 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.NanonewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity08.NanonewtonsPerSecond, NanonewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.NanonewtonPerSecond, quantity08.Unit);
 
-            var quantity09 = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerMinute);
+            var quantity09 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.NewtonPerMinute);
             AssertEx.EqualTolerance(1, quantity09.NewtonsPerMinute, NewtonsPerMinuteTolerance);
             Assert.Equal(ForceChangeRateUnit.NewtonPerMinute, quantity09.Unit);
 
-            var quantity10 = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond);
+            var quantity10 = ForceChangeRate<double>.From(1, ForceChangeRateUnit.NewtonPerSecond);
             AssertEx.EqualTolerance(1, quantity10.NewtonsPerSecond, NewtonsPerSecondTolerance);
             Assert.Equal(ForceChangeRateUnit.NewtonPerSecond, quantity10.Unit);
 
@@ -200,20 +200,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonsPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ForceChangeRate.FromNewtonsPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ForceChangeRate.FromNewtonsPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ForceChangeRate<double>.FromNewtonsPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ForceChangeRate<double>.FromNewtonsPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonsPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ForceChangeRate.FromNewtonsPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => ForceChangeRate<double>.FromNewtonsPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            var newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             AssertEx.EqualTolerance(CentinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.CentinewtonPerSecond), CentinewtonsPerSecondTolerance);
             AssertEx.EqualTolerance(DecanewtonsPerMinuteInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.DecanewtonPerMinute), DecanewtonsPerMinuteTolerance);
             AssertEx.EqualTolerance(DecanewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.DecanewtonPerSecond), DecanewtonsPerSecondTolerance);
@@ -247,7 +247,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            var newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
 
             var centinewtonpersecondQuantity = newtonpersecond.ToUnit(ForceChangeRateUnit.CentinewtonPerSecond);
             AssertEx.EqualTolerance(CentinewtonsPerSecondInOneNewtonPerSecond, (double)centinewtonpersecondQuantity.Value, CentinewtonsPerSecondTolerance);
@@ -304,38 +304,38 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromCentinewtonsPerSecond(newtonpersecond.CentinewtonsPerSecond).NewtonsPerSecond, CentinewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromDecanewtonsPerMinute(newtonpersecond.DecanewtonsPerMinute).NewtonsPerSecond, DecanewtonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromDecanewtonsPerSecond(newtonpersecond.DecanewtonsPerSecond).NewtonsPerSecond, DecanewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromDecinewtonsPerSecond(newtonpersecond.DecinewtonsPerSecond).NewtonsPerSecond, DecinewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromKilonewtonsPerMinute(newtonpersecond.KilonewtonsPerMinute).NewtonsPerSecond, KilonewtonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromKilonewtonsPerSecond(newtonpersecond.KilonewtonsPerSecond).NewtonsPerSecond, KilonewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromMicronewtonsPerSecond(newtonpersecond.MicronewtonsPerSecond).NewtonsPerSecond, MicronewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromMillinewtonsPerSecond(newtonpersecond.MillinewtonsPerSecond).NewtonsPerSecond, MillinewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromNanonewtonsPerSecond(newtonpersecond.NanonewtonsPerSecond).NewtonsPerSecond, NanonewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromNewtonsPerMinute(newtonpersecond.NewtonsPerMinute).NewtonsPerSecond, NewtonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromNewtonsPerSecond(newtonpersecond.NewtonsPerSecond).NewtonsPerSecond, NewtonsPerSecondTolerance);
+            ForceChangeRate<double> newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromCentinewtonsPerSecond(newtonpersecond.CentinewtonsPerSecond).NewtonsPerSecond, CentinewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromDecanewtonsPerMinute(newtonpersecond.DecanewtonsPerMinute).NewtonsPerSecond, DecanewtonsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromDecanewtonsPerSecond(newtonpersecond.DecanewtonsPerSecond).NewtonsPerSecond, DecanewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromDecinewtonsPerSecond(newtonpersecond.DecinewtonsPerSecond).NewtonsPerSecond, DecinewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromKilonewtonsPerMinute(newtonpersecond.KilonewtonsPerMinute).NewtonsPerSecond, KilonewtonsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromKilonewtonsPerSecond(newtonpersecond.KilonewtonsPerSecond).NewtonsPerSecond, KilonewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromMicronewtonsPerSecond(newtonpersecond.MicronewtonsPerSecond).NewtonsPerSecond, MicronewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromMillinewtonsPerSecond(newtonpersecond.MillinewtonsPerSecond).NewtonsPerSecond, MillinewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromNanonewtonsPerSecond(newtonpersecond.NanonewtonsPerSecond).NewtonsPerSecond, NanonewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromNewtonsPerMinute(newtonpersecond.NewtonsPerMinute).NewtonsPerSecond, NewtonsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, ForceChangeRate<double>.FromNewtonsPerSecond(newtonpersecond.NewtonsPerSecond).NewtonsPerSecond, NewtonsPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ForceChangeRate v = ForceChangeRate.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> v = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ForceChangeRate.FromNewtonsPerSecond(3)-v).NewtonsPerSecond, NewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (ForceChangeRate<double>.FromNewtonsPerSecond(3)-v).NewtonsPerSecond, NewtonsPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonsPerSecond, NewtonsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonsPerSecond, NewtonsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ForceChangeRate.FromNewtonsPerSecond(10)/5).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, ForceChangeRate.FromNewtonsPerSecond(10)/ForceChangeRate.FromNewtonsPerSecond(5), NewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (ForceChangeRate<double>.FromNewtonsPerSecond(10)/5).NewtonsPerSecond, NewtonsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, ForceChangeRate<double>.FromNewtonsPerSecond(10)/ForceChangeRate<double>.FromNewtonsPerSecond(5), NewtonsPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ForceChangeRate oneNewtonPerSecond = ForceChangeRate.FromNewtonsPerSecond(1);
-            ForceChangeRate twoNewtonsPerSecond = ForceChangeRate.FromNewtonsPerSecond(2);
+            ForceChangeRate<double> oneNewtonPerSecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> twoNewtonsPerSecond = ForceChangeRate<double>.FromNewtonsPerSecond(2);
 
             Assert.True(oneNewtonPerSecond < twoNewtonsPerSecond);
             Assert.True(oneNewtonPerSecond <= twoNewtonsPerSecond);
@@ -351,31 +351,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             Assert.Equal(0, newtonpersecond.CompareTo(newtonpersecond));
-            Assert.True(newtonpersecond.CompareTo(ForceChangeRate.Zero) > 0);
-            Assert.True(ForceChangeRate.Zero.CompareTo(newtonpersecond) < 0);
+            Assert.True(newtonpersecond.CompareTo(ForceChangeRate<double>.Zero) > 0);
+            Assert.True(ForceChangeRate<double>.Zero.CompareTo(newtonpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             Assert.Throws<ArgumentException>(() => newtonpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => newtonpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ForceChangeRate.FromNewtonsPerSecond(1);
-            var b = ForceChangeRate.FromNewtonsPerSecond(2);
+            var a = ForceChangeRate<double>.FromNewtonsPerSecond(1);
+            var b = ForceChangeRate<double>.FromNewtonsPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -394,8 +394,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ForceChangeRate.FromNewtonsPerSecond(1);
-            var b = ForceChangeRate.FromNewtonsPerSecond(2);
+            var a = ForceChangeRate<double>.FromNewtonsPerSecond(1);
+            var b = ForceChangeRate<double>.FromNewtonsPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -415,9 +415,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ForceChangeRate.FromNewtonsPerSecond(1);
-            Assert.True(v.Equals(ForceChangeRate.FromNewtonsPerSecond(1), NewtonsPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ForceChangeRate.Zero, NewtonsPerSecondTolerance, ComparisonType.Relative));
+            var v = ForceChangeRate<double>.FromNewtonsPerSecond(1);
+            Assert.True(v.Equals(ForceChangeRate<double>.FromNewtonsPerSecond(1), NewtonsPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ForceChangeRate<double>.Zero, NewtonsPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -430,21 +430,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             Assert.False(newtonpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
+            ForceChangeRate<double> newtonpersecond = ForceChangeRate<double>.FromNewtonsPerSecond(1);
             Assert.False(newtonpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ForceChangeRateUnit.Undefined, ForceChangeRate.Units);
+            Assert.DoesNotContain(ForceChangeRateUnit.Undefined, ForceChangeRate<double>.Units);
         }
 
         [Fact]
@@ -463,7 +463,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ForceChangeRate.BaseDimensions is null);
+            Assert.False(ForceChangeRate<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs
index bfd3fb4d3c..ccb920f6d4 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs
@@ -120,7 +120,7 @@ public abstract partial class ForcePerLengthTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ForcePerLength((double)0.0, ForcePerLengthUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>((double)0.0, ForcePerLengthUnit.Undefined));
         }
 
         [Fact]
@@ -135,14 +135,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ForcePerLength(double.PositiveInfinity, ForcePerLengthUnit.NewtonPerMeter));
-            Assert.Throws<ArgumentException>(() => new ForcePerLength(double.NegativeInfinity, ForcePerLengthUnit.NewtonPerMeter));
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>(double.PositiveInfinity, ForcePerLengthUnit.NewtonPerMeter));
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>(double.NegativeInfinity, ForcePerLengthUnit.NewtonPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ForcePerLength(double.NaN, ForcePerLengthUnit.NewtonPerMeter));
+            Assert.Throws<ArgumentException>(() => new ForcePerLength<double>(double.NaN, ForcePerLengthUnit.NewtonPerMeter));
         }
 
         [Fact]
@@ -188,7 +188,7 @@ public void ForcePerLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void NewtonPerMeterToForcePerLengthUnits()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
             AssertEx.EqualTolerance(CentinewtonsPerCentimeterInOneNewtonPerMeter, newtonpermeter.CentinewtonsPerCentimeter, CentinewtonsPerCentimeterTolerance);
             AssertEx.EqualTolerance(CentinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.CentinewtonsPerMeter, CentinewtonsPerMeterTolerance);
             AssertEx.EqualTolerance(CentinewtonsPerMillimeterInOneNewtonPerMeter, newtonpermeter.CentinewtonsPerMillimeter, CentinewtonsPerMillimeterTolerance);
@@ -232,155 +232,155 @@ public void NewtonPerMeterToForcePerLengthUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ForcePerLength.From(1, ForcePerLengthUnit.CentinewtonPerCentimeter);
+            var quantity00 = ForcePerLength<double>.From(1, ForcePerLengthUnit.CentinewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity00.CentinewtonsPerCentimeter, CentinewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.CentinewtonPerCentimeter, quantity00.Unit);
 
-            var quantity01 = ForcePerLength.From(1, ForcePerLengthUnit.CentinewtonPerMeter);
+            var quantity01 = ForcePerLength<double>.From(1, ForcePerLengthUnit.CentinewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity01.CentinewtonsPerMeter, CentinewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.CentinewtonPerMeter, quantity01.Unit);
 
-            var quantity02 = ForcePerLength.From(1, ForcePerLengthUnit.CentinewtonPerMillimeter);
+            var quantity02 = ForcePerLength<double>.From(1, ForcePerLengthUnit.CentinewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity02.CentinewtonsPerMillimeter, CentinewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.CentinewtonPerMillimeter, quantity02.Unit);
 
-            var quantity03 = ForcePerLength.From(1, ForcePerLengthUnit.DecanewtonPerCentimeter);
+            var quantity03 = ForcePerLength<double>.From(1, ForcePerLengthUnit.DecanewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity03.DecanewtonsPerCentimeter, DecanewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.DecanewtonPerCentimeter, quantity03.Unit);
 
-            var quantity04 = ForcePerLength.From(1, ForcePerLengthUnit.DecanewtonPerMeter);
+            var quantity04 = ForcePerLength<double>.From(1, ForcePerLengthUnit.DecanewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity04.DecanewtonsPerMeter, DecanewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.DecanewtonPerMeter, quantity04.Unit);
 
-            var quantity05 = ForcePerLength.From(1, ForcePerLengthUnit.DecanewtonPerMillimeter);
+            var quantity05 = ForcePerLength<double>.From(1, ForcePerLengthUnit.DecanewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity05.DecanewtonsPerMillimeter, DecanewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.DecanewtonPerMillimeter, quantity05.Unit);
 
-            var quantity06 = ForcePerLength.From(1, ForcePerLengthUnit.DecinewtonPerCentimeter);
+            var quantity06 = ForcePerLength<double>.From(1, ForcePerLengthUnit.DecinewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity06.DecinewtonsPerCentimeter, DecinewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.DecinewtonPerCentimeter, quantity06.Unit);
 
-            var quantity07 = ForcePerLength.From(1, ForcePerLengthUnit.DecinewtonPerMeter);
+            var quantity07 = ForcePerLength<double>.From(1, ForcePerLengthUnit.DecinewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity07.DecinewtonsPerMeter, DecinewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.DecinewtonPerMeter, quantity07.Unit);
 
-            var quantity08 = ForcePerLength.From(1, ForcePerLengthUnit.DecinewtonPerMillimeter);
+            var quantity08 = ForcePerLength<double>.From(1, ForcePerLengthUnit.DecinewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity08.DecinewtonsPerMillimeter, DecinewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.DecinewtonPerMillimeter, quantity08.Unit);
 
-            var quantity09 = ForcePerLength.From(1, ForcePerLengthUnit.KilogramForcePerCentimeter);
+            var quantity09 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilogramForcePerCentimeter);
             AssertEx.EqualTolerance(1, quantity09.KilogramsForcePerCentimeter, KilogramsForcePerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.KilogramForcePerCentimeter, quantity09.Unit);
 
-            var quantity10 = ForcePerLength.From(1, ForcePerLengthUnit.KilogramForcePerMeter);
+            var quantity10 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilogramForcePerMeter);
             AssertEx.EqualTolerance(1, quantity10.KilogramsForcePerMeter, KilogramsForcePerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.KilogramForcePerMeter, quantity10.Unit);
 
-            var quantity11 = ForcePerLength.From(1, ForcePerLengthUnit.KilogramForcePerMillimeter);
+            var quantity11 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilogramForcePerMillimeter);
             AssertEx.EqualTolerance(1, quantity11.KilogramsForcePerMillimeter, KilogramsForcePerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.KilogramForcePerMillimeter, quantity11.Unit);
 
-            var quantity12 = ForcePerLength.From(1, ForcePerLengthUnit.KilonewtonPerCentimeter);
+            var quantity12 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilonewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity12.KilonewtonsPerCentimeter, KilonewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.KilonewtonPerCentimeter, quantity12.Unit);
 
-            var quantity13 = ForcePerLength.From(1, ForcePerLengthUnit.KilonewtonPerMeter);
+            var quantity13 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilonewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity13.KilonewtonsPerMeter, KilonewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.KilonewtonPerMeter, quantity13.Unit);
 
-            var quantity14 = ForcePerLength.From(1, ForcePerLengthUnit.KilonewtonPerMillimeter);
+            var quantity14 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilonewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity14.KilonewtonsPerMillimeter, KilonewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.KilonewtonPerMillimeter, quantity14.Unit);
 
-            var quantity15 = ForcePerLength.From(1, ForcePerLengthUnit.KilopoundForcePerFoot);
+            var quantity15 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilopoundForcePerFoot);
             AssertEx.EqualTolerance(1, quantity15.KilopoundsForcePerFoot, KilopoundsForcePerFootTolerance);
             Assert.Equal(ForcePerLengthUnit.KilopoundForcePerFoot, quantity15.Unit);
 
-            var quantity16 = ForcePerLength.From(1, ForcePerLengthUnit.KilopoundForcePerInch);
+            var quantity16 = ForcePerLength<double>.From(1, ForcePerLengthUnit.KilopoundForcePerInch);
             AssertEx.EqualTolerance(1, quantity16.KilopoundsForcePerInch, KilopoundsForcePerInchTolerance);
             Assert.Equal(ForcePerLengthUnit.KilopoundForcePerInch, quantity16.Unit);
 
-            var quantity17 = ForcePerLength.From(1, ForcePerLengthUnit.MeganewtonPerCentimeter);
+            var quantity17 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MeganewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity17.MeganewtonsPerCentimeter, MeganewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MeganewtonPerCentimeter, quantity17.Unit);
 
-            var quantity18 = ForcePerLength.From(1, ForcePerLengthUnit.MeganewtonPerMeter);
+            var quantity18 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MeganewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity18.MeganewtonsPerMeter, MeganewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MeganewtonPerMeter, quantity18.Unit);
 
-            var quantity19 = ForcePerLength.From(1, ForcePerLengthUnit.MeganewtonPerMillimeter);
+            var quantity19 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MeganewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity19.MeganewtonsPerMillimeter, MeganewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MeganewtonPerMillimeter, quantity19.Unit);
 
-            var quantity20 = ForcePerLength.From(1, ForcePerLengthUnit.MicronewtonPerCentimeter);
+            var quantity20 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MicronewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity20.MicronewtonsPerCentimeter, MicronewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MicronewtonPerCentimeter, quantity20.Unit);
 
-            var quantity21 = ForcePerLength.From(1, ForcePerLengthUnit.MicronewtonPerMeter);
+            var quantity21 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MicronewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity21.MicronewtonsPerMeter, MicronewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MicronewtonPerMeter, quantity21.Unit);
 
-            var quantity22 = ForcePerLength.From(1, ForcePerLengthUnit.MicronewtonPerMillimeter);
+            var quantity22 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MicronewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity22.MicronewtonsPerMillimeter, MicronewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MicronewtonPerMillimeter, quantity22.Unit);
 
-            var quantity23 = ForcePerLength.From(1, ForcePerLengthUnit.MillinewtonPerCentimeter);
+            var quantity23 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MillinewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity23.MillinewtonsPerCentimeter, MillinewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MillinewtonPerCentimeter, quantity23.Unit);
 
-            var quantity24 = ForcePerLength.From(1, ForcePerLengthUnit.MillinewtonPerMeter);
+            var quantity24 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MillinewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity24.MillinewtonsPerMeter, MillinewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MillinewtonPerMeter, quantity24.Unit);
 
-            var quantity25 = ForcePerLength.From(1, ForcePerLengthUnit.MillinewtonPerMillimeter);
+            var quantity25 = ForcePerLength<double>.From(1, ForcePerLengthUnit.MillinewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity25.MillinewtonsPerMillimeter, MillinewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.MillinewtonPerMillimeter, quantity25.Unit);
 
-            var quantity26 = ForcePerLength.From(1, ForcePerLengthUnit.NanonewtonPerCentimeter);
+            var quantity26 = ForcePerLength<double>.From(1, ForcePerLengthUnit.NanonewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity26.NanonewtonsPerCentimeter, NanonewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.NanonewtonPerCentimeter, quantity26.Unit);
 
-            var quantity27 = ForcePerLength.From(1, ForcePerLengthUnit.NanonewtonPerMeter);
+            var quantity27 = ForcePerLength<double>.From(1, ForcePerLengthUnit.NanonewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity27.NanonewtonsPerMeter, NanonewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.NanonewtonPerMeter, quantity27.Unit);
 
-            var quantity28 = ForcePerLength.From(1, ForcePerLengthUnit.NanonewtonPerMillimeter);
+            var quantity28 = ForcePerLength<double>.From(1, ForcePerLengthUnit.NanonewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity28.NanonewtonsPerMillimeter, NanonewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.NanonewtonPerMillimeter, quantity28.Unit);
 
-            var quantity29 = ForcePerLength.From(1, ForcePerLengthUnit.NewtonPerCentimeter);
+            var quantity29 = ForcePerLength<double>.From(1, ForcePerLengthUnit.NewtonPerCentimeter);
             AssertEx.EqualTolerance(1, quantity29.NewtonsPerCentimeter, NewtonsPerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.NewtonPerCentimeter, quantity29.Unit);
 
-            var quantity30 = ForcePerLength.From(1, ForcePerLengthUnit.NewtonPerMeter);
+            var quantity30 = ForcePerLength<double>.From(1, ForcePerLengthUnit.NewtonPerMeter);
             AssertEx.EqualTolerance(1, quantity30.NewtonsPerMeter, NewtonsPerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.NewtonPerMeter, quantity30.Unit);
 
-            var quantity31 = ForcePerLength.From(1, ForcePerLengthUnit.NewtonPerMillimeter);
+            var quantity31 = ForcePerLength<double>.From(1, ForcePerLengthUnit.NewtonPerMillimeter);
             AssertEx.EqualTolerance(1, quantity31.NewtonsPerMillimeter, NewtonsPerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.NewtonPerMillimeter, quantity31.Unit);
 
-            var quantity32 = ForcePerLength.From(1, ForcePerLengthUnit.PoundForcePerFoot);
+            var quantity32 = ForcePerLength<double>.From(1, ForcePerLengthUnit.PoundForcePerFoot);
             AssertEx.EqualTolerance(1, quantity32.PoundsForcePerFoot, PoundsForcePerFootTolerance);
             Assert.Equal(ForcePerLengthUnit.PoundForcePerFoot, quantity32.Unit);
 
-            var quantity33 = ForcePerLength.From(1, ForcePerLengthUnit.PoundForcePerInch);
+            var quantity33 = ForcePerLength<double>.From(1, ForcePerLengthUnit.PoundForcePerInch);
             AssertEx.EqualTolerance(1, quantity33.PoundsForcePerInch, PoundsForcePerInchTolerance);
             Assert.Equal(ForcePerLengthUnit.PoundForcePerInch, quantity33.Unit);
 
-            var quantity34 = ForcePerLength.From(1, ForcePerLengthUnit.PoundForcePerYard);
+            var quantity34 = ForcePerLength<double>.From(1, ForcePerLengthUnit.PoundForcePerYard);
             AssertEx.EqualTolerance(1, quantity34.PoundsForcePerYard, PoundsForcePerYardTolerance);
             Assert.Equal(ForcePerLengthUnit.PoundForcePerYard, quantity34.Unit);
 
-            var quantity35 = ForcePerLength.From(1, ForcePerLengthUnit.TonneForcePerCentimeter);
+            var quantity35 = ForcePerLength<double>.From(1, ForcePerLengthUnit.TonneForcePerCentimeter);
             AssertEx.EqualTolerance(1, quantity35.TonnesForcePerCentimeter, TonnesForcePerCentimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.TonneForcePerCentimeter, quantity35.Unit);
 
-            var quantity36 = ForcePerLength.From(1, ForcePerLengthUnit.TonneForcePerMeter);
+            var quantity36 = ForcePerLength<double>.From(1, ForcePerLengthUnit.TonneForcePerMeter);
             AssertEx.EqualTolerance(1, quantity36.TonnesForcePerMeter, TonnesForcePerMeterTolerance);
             Assert.Equal(ForcePerLengthUnit.TonneForcePerMeter, quantity36.Unit);
 
-            var quantity37 = ForcePerLength.From(1, ForcePerLengthUnit.TonneForcePerMillimeter);
+            var quantity37 = ForcePerLength<double>.From(1, ForcePerLengthUnit.TonneForcePerMillimeter);
             AssertEx.EqualTolerance(1, quantity37.TonnesForcePerMillimeter, TonnesForcePerMillimeterTolerance);
             Assert.Equal(ForcePerLengthUnit.TonneForcePerMillimeter, quantity37.Unit);
 
@@ -389,20 +389,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonsPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ForcePerLength.FromNewtonsPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ForcePerLength.FromNewtonsPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ForcePerLength<double>.FromNewtonsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ForcePerLength<double>.FromNewtonsPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonsPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ForcePerLength.FromNewtonsPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => ForcePerLength<double>.FromNewtonsPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            var newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
             AssertEx.EqualTolerance(CentinewtonsPerCentimeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.CentinewtonPerCentimeter), CentinewtonsPerCentimeterTolerance);
             AssertEx.EqualTolerance(CentinewtonsPerMeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.CentinewtonPerMeter), CentinewtonsPerMeterTolerance);
             AssertEx.EqualTolerance(CentinewtonsPerMillimeterInOneNewtonPerMeter, newtonpermeter.As(ForcePerLengthUnit.CentinewtonPerMillimeter), CentinewtonsPerMillimeterTolerance);
@@ -463,7 +463,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            var newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
 
             var centinewtonpercentimeterQuantity = newtonpermeter.ToUnit(ForcePerLengthUnit.CentinewtonPerCentimeter);
             AssertEx.EqualTolerance(CentinewtonsPerCentimeterInOneNewtonPerMeter, (double)centinewtonpercentimeterQuantity.Value, CentinewtonsPerCentimeterTolerance);
@@ -628,65 +628,65 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromCentinewtonsPerCentimeter(newtonpermeter.CentinewtonsPerCentimeter).NewtonsPerMeter, CentinewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromCentinewtonsPerMeter(newtonpermeter.CentinewtonsPerMeter).NewtonsPerMeter, CentinewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromCentinewtonsPerMillimeter(newtonpermeter.CentinewtonsPerMillimeter).NewtonsPerMeter, CentinewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecanewtonsPerCentimeter(newtonpermeter.DecanewtonsPerCentimeter).NewtonsPerMeter, DecanewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecanewtonsPerMeter(newtonpermeter.DecanewtonsPerMeter).NewtonsPerMeter, DecanewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecanewtonsPerMillimeter(newtonpermeter.DecanewtonsPerMillimeter).NewtonsPerMeter, DecanewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecinewtonsPerCentimeter(newtonpermeter.DecinewtonsPerCentimeter).NewtonsPerMeter, DecinewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecinewtonsPerMeter(newtonpermeter.DecinewtonsPerMeter).NewtonsPerMeter, DecinewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecinewtonsPerMillimeter(newtonpermeter.DecinewtonsPerMillimeter).NewtonsPerMeter, DecinewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilogramsForcePerCentimeter(newtonpermeter.KilogramsForcePerCentimeter).NewtonsPerMeter, KilogramsForcePerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilogramsForcePerMeter(newtonpermeter.KilogramsForcePerMeter).NewtonsPerMeter, KilogramsForcePerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilogramsForcePerMillimeter(newtonpermeter.KilogramsForcePerMillimeter).NewtonsPerMeter, KilogramsForcePerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilonewtonsPerCentimeter(newtonpermeter.KilonewtonsPerCentimeter).NewtonsPerMeter, KilonewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilonewtonsPerMeter(newtonpermeter.KilonewtonsPerMeter).NewtonsPerMeter, KilonewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilonewtonsPerMillimeter(newtonpermeter.KilonewtonsPerMillimeter).NewtonsPerMeter, KilonewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilopoundsForcePerFoot(newtonpermeter.KilopoundsForcePerFoot).NewtonsPerMeter, KilopoundsForcePerFootTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilopoundsForcePerInch(newtonpermeter.KilopoundsForcePerInch).NewtonsPerMeter, KilopoundsForcePerInchTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMeganewtonsPerCentimeter(newtonpermeter.MeganewtonsPerCentimeter).NewtonsPerMeter, MeganewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMeganewtonsPerMeter(newtonpermeter.MeganewtonsPerMeter).NewtonsPerMeter, MeganewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMeganewtonsPerMillimeter(newtonpermeter.MeganewtonsPerMillimeter).NewtonsPerMeter, MeganewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMicronewtonsPerCentimeter(newtonpermeter.MicronewtonsPerCentimeter).NewtonsPerMeter, MicronewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMicronewtonsPerMeter(newtonpermeter.MicronewtonsPerMeter).NewtonsPerMeter, MicronewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMicronewtonsPerMillimeter(newtonpermeter.MicronewtonsPerMillimeter).NewtonsPerMeter, MicronewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMillinewtonsPerCentimeter(newtonpermeter.MillinewtonsPerCentimeter).NewtonsPerMeter, MillinewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMillinewtonsPerMeter(newtonpermeter.MillinewtonsPerMeter).NewtonsPerMeter, MillinewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMillinewtonsPerMillimeter(newtonpermeter.MillinewtonsPerMillimeter).NewtonsPerMeter, MillinewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNanonewtonsPerCentimeter(newtonpermeter.NanonewtonsPerCentimeter).NewtonsPerMeter, NanonewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNanonewtonsPerMeter(newtonpermeter.NanonewtonsPerMeter).NewtonsPerMeter, NanonewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNanonewtonsPerMillimeter(newtonpermeter.NanonewtonsPerMillimeter).NewtonsPerMeter, NanonewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNewtonsPerCentimeter(newtonpermeter.NewtonsPerCentimeter).NewtonsPerMeter, NewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNewtonsPerMeter(newtonpermeter.NewtonsPerMeter).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNewtonsPerMillimeter(newtonpermeter.NewtonsPerMillimeter).NewtonsPerMeter, NewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromPoundsForcePerFoot(newtonpermeter.PoundsForcePerFoot).NewtonsPerMeter, PoundsForcePerFootTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromPoundsForcePerInch(newtonpermeter.PoundsForcePerInch).NewtonsPerMeter, PoundsForcePerInchTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromPoundsForcePerYard(newtonpermeter.PoundsForcePerYard).NewtonsPerMeter, PoundsForcePerYardTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromTonnesForcePerCentimeter(newtonpermeter.TonnesForcePerCentimeter).NewtonsPerMeter, TonnesForcePerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromTonnesForcePerMeter(newtonpermeter.TonnesForcePerMeter).NewtonsPerMeter, TonnesForcePerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromTonnesForcePerMillimeter(newtonpermeter.TonnesForcePerMillimeter).NewtonsPerMeter, TonnesForcePerMillimeterTolerance);
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromCentinewtonsPerCentimeter(newtonpermeter.CentinewtonsPerCentimeter).NewtonsPerMeter, CentinewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromCentinewtonsPerMeter(newtonpermeter.CentinewtonsPerMeter).NewtonsPerMeter, CentinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromCentinewtonsPerMillimeter(newtonpermeter.CentinewtonsPerMillimeter).NewtonsPerMeter, CentinewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromDecanewtonsPerCentimeter(newtonpermeter.DecanewtonsPerCentimeter).NewtonsPerMeter, DecanewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromDecanewtonsPerMeter(newtonpermeter.DecanewtonsPerMeter).NewtonsPerMeter, DecanewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromDecanewtonsPerMillimeter(newtonpermeter.DecanewtonsPerMillimeter).NewtonsPerMeter, DecanewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromDecinewtonsPerCentimeter(newtonpermeter.DecinewtonsPerCentimeter).NewtonsPerMeter, DecinewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromDecinewtonsPerMeter(newtonpermeter.DecinewtonsPerMeter).NewtonsPerMeter, DecinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromDecinewtonsPerMillimeter(newtonpermeter.DecinewtonsPerMillimeter).NewtonsPerMeter, DecinewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilogramsForcePerCentimeter(newtonpermeter.KilogramsForcePerCentimeter).NewtonsPerMeter, KilogramsForcePerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilogramsForcePerMeter(newtonpermeter.KilogramsForcePerMeter).NewtonsPerMeter, KilogramsForcePerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilogramsForcePerMillimeter(newtonpermeter.KilogramsForcePerMillimeter).NewtonsPerMeter, KilogramsForcePerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilonewtonsPerCentimeter(newtonpermeter.KilonewtonsPerCentimeter).NewtonsPerMeter, KilonewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilonewtonsPerMeter(newtonpermeter.KilonewtonsPerMeter).NewtonsPerMeter, KilonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilonewtonsPerMillimeter(newtonpermeter.KilonewtonsPerMillimeter).NewtonsPerMeter, KilonewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilopoundsForcePerFoot(newtonpermeter.KilopoundsForcePerFoot).NewtonsPerMeter, KilopoundsForcePerFootTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromKilopoundsForcePerInch(newtonpermeter.KilopoundsForcePerInch).NewtonsPerMeter, KilopoundsForcePerInchTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMeganewtonsPerCentimeter(newtonpermeter.MeganewtonsPerCentimeter).NewtonsPerMeter, MeganewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMeganewtonsPerMeter(newtonpermeter.MeganewtonsPerMeter).NewtonsPerMeter, MeganewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMeganewtonsPerMillimeter(newtonpermeter.MeganewtonsPerMillimeter).NewtonsPerMeter, MeganewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMicronewtonsPerCentimeter(newtonpermeter.MicronewtonsPerCentimeter).NewtonsPerMeter, MicronewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMicronewtonsPerMeter(newtonpermeter.MicronewtonsPerMeter).NewtonsPerMeter, MicronewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMicronewtonsPerMillimeter(newtonpermeter.MicronewtonsPerMillimeter).NewtonsPerMeter, MicronewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMillinewtonsPerCentimeter(newtonpermeter.MillinewtonsPerCentimeter).NewtonsPerMeter, MillinewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMillinewtonsPerMeter(newtonpermeter.MillinewtonsPerMeter).NewtonsPerMeter, MillinewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromMillinewtonsPerMillimeter(newtonpermeter.MillinewtonsPerMillimeter).NewtonsPerMeter, MillinewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNanonewtonsPerCentimeter(newtonpermeter.NanonewtonsPerCentimeter).NewtonsPerMeter, NanonewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNanonewtonsPerMeter(newtonpermeter.NanonewtonsPerMeter).NewtonsPerMeter, NanonewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNanonewtonsPerMillimeter(newtonpermeter.NanonewtonsPerMillimeter).NewtonsPerMeter, NanonewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNewtonsPerCentimeter(newtonpermeter.NewtonsPerCentimeter).NewtonsPerMeter, NewtonsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNewtonsPerMeter(newtonpermeter.NewtonsPerMeter).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromNewtonsPerMillimeter(newtonpermeter.NewtonsPerMillimeter).NewtonsPerMeter, NewtonsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromPoundsForcePerFoot(newtonpermeter.PoundsForcePerFoot).NewtonsPerMeter, PoundsForcePerFootTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromPoundsForcePerInch(newtonpermeter.PoundsForcePerInch).NewtonsPerMeter, PoundsForcePerInchTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromPoundsForcePerYard(newtonpermeter.PoundsForcePerYard).NewtonsPerMeter, PoundsForcePerYardTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromTonnesForcePerCentimeter(newtonpermeter.TonnesForcePerCentimeter).NewtonsPerMeter, TonnesForcePerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromTonnesForcePerMeter(newtonpermeter.TonnesForcePerMeter).NewtonsPerMeter, TonnesForcePerMeterTolerance);
+            AssertEx.EqualTolerance(1, ForcePerLength<double>.FromTonnesForcePerMillimeter(newtonpermeter.TonnesForcePerMillimeter).NewtonsPerMeter, TonnesForcePerMillimeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ForcePerLength v = ForcePerLength.FromNewtonsPerMeter(1);
+            ForcePerLength<double> v = ForcePerLength<double>.FromNewtonsPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ForcePerLength.FromNewtonsPerMeter(3)-v).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ForcePerLength<double>.FromNewtonsPerMeter(3)-v).NewtonsPerMeter, NewtonsPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonsPerMeter, NewtonsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonsPerMeter, NewtonsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ForcePerLength.FromNewtonsPerMeter(10)/5).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, ForcePerLength.FromNewtonsPerMeter(10)/ForcePerLength.FromNewtonsPerMeter(5), NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (ForcePerLength<double>.FromNewtonsPerMeter(10)/5).NewtonsPerMeter, NewtonsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, ForcePerLength<double>.FromNewtonsPerMeter(10)/ForcePerLength<double>.FromNewtonsPerMeter(5), NewtonsPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ForcePerLength oneNewtonPerMeter = ForcePerLength.FromNewtonsPerMeter(1);
-            ForcePerLength twoNewtonsPerMeter = ForcePerLength.FromNewtonsPerMeter(2);
+            ForcePerLength<double> oneNewtonPerMeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            ForcePerLength<double> twoNewtonsPerMeter = ForcePerLength<double>.FromNewtonsPerMeter(2);
 
             Assert.True(oneNewtonPerMeter < twoNewtonsPerMeter);
             Assert.True(oneNewtonPerMeter <= twoNewtonsPerMeter);
@@ -702,31 +702,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
             Assert.Equal(0, newtonpermeter.CompareTo(newtonpermeter));
-            Assert.True(newtonpermeter.CompareTo(ForcePerLength.Zero) > 0);
-            Assert.True(ForcePerLength.Zero.CompareTo(newtonpermeter) < 0);
+            Assert.True(newtonpermeter.CompareTo(ForcePerLength<double>.Zero) > 0);
+            Assert.True(ForcePerLength<double>.Zero.CompareTo(newtonpermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
             Assert.Throws<ArgumentException>(() => newtonpermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => newtonpermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ForcePerLength.FromNewtonsPerMeter(1);
-            var b = ForcePerLength.FromNewtonsPerMeter(2);
+            var a = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            var b = ForcePerLength<double>.FromNewtonsPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -745,8 +745,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ForcePerLength.FromNewtonsPerMeter(1);
-            var b = ForcePerLength.FromNewtonsPerMeter(2);
+            var a = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            var b = ForcePerLength<double>.FromNewtonsPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -766,9 +766,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ForcePerLength.FromNewtonsPerMeter(1);
-            Assert.True(v.Equals(ForcePerLength.FromNewtonsPerMeter(1), NewtonsPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ForcePerLength.Zero, NewtonsPerMeterTolerance, ComparisonType.Relative));
+            var v = ForcePerLength<double>.FromNewtonsPerMeter(1);
+            Assert.True(v.Equals(ForcePerLength<double>.FromNewtonsPerMeter(1), NewtonsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ForcePerLength<double>.Zero, NewtonsPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -781,21 +781,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
             Assert.False(newtonpermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
+            ForcePerLength<double> newtonpermeter = ForcePerLength<double>.FromNewtonsPerMeter(1);
             Assert.False(newtonpermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ForcePerLengthUnit.Undefined, ForcePerLength.Units);
+            Assert.DoesNotContain(ForcePerLengthUnit.Undefined, ForcePerLength<double>.Units);
         }
 
         [Fact]
@@ -814,7 +814,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ForcePerLength.BaseDimensions is null);
+            Assert.False(ForcePerLength<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
index d31960ad7e..82c3f6e29f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
@@ -74,7 +74,7 @@ public abstract partial class ForceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Force((double)0.0, ForceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Force<double>((double)0.0, ForceUnit.Undefined));
         }
 
         [Fact]
@@ -89,14 +89,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Force(double.PositiveInfinity, ForceUnit.Newton));
-            Assert.Throws<ArgumentException>(() => new Force(double.NegativeInfinity, ForceUnit.Newton));
+            Assert.Throws<ArgumentException>(() => new Force<double>(double.PositiveInfinity, ForceUnit.Newton));
+            Assert.Throws<ArgumentException>(() => new Force<double>(double.NegativeInfinity, ForceUnit.Newton));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Force(double.NaN, ForceUnit.Newton));
+            Assert.Throws<ArgumentException>(() => new Force<double>(double.NaN, ForceUnit.Newton));
         }
 
         [Fact]
@@ -142,7 +142,7 @@ public void Force_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void NewtonToForceUnits()
         {
-            Force newton = Force.FromNewtons(1);
+            Force<double> newton = Force<double>.FromNewtons(1);
             AssertEx.EqualTolerance(DecanewtonsInOneNewton, newton.Decanewtons, DecanewtonsTolerance);
             AssertEx.EqualTolerance(DyneInOneNewton, newton.Dyne, DyneTolerance);
             AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.KilogramsForce, KilogramsForceTolerance);
@@ -163,63 +163,63 @@ public void NewtonToForceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Force.From(1, ForceUnit.Decanewton);
+            var quantity00 = Force<double>.From(1, ForceUnit.Decanewton);
             AssertEx.EqualTolerance(1, quantity00.Decanewtons, DecanewtonsTolerance);
             Assert.Equal(ForceUnit.Decanewton, quantity00.Unit);
 
-            var quantity01 = Force.From(1, ForceUnit.Dyn);
+            var quantity01 = Force<double>.From(1, ForceUnit.Dyn);
             AssertEx.EqualTolerance(1, quantity01.Dyne, DyneTolerance);
             Assert.Equal(ForceUnit.Dyn, quantity01.Unit);
 
-            var quantity02 = Force.From(1, ForceUnit.KilogramForce);
+            var quantity02 = Force<double>.From(1, ForceUnit.KilogramForce);
             AssertEx.EqualTolerance(1, quantity02.KilogramsForce, KilogramsForceTolerance);
             Assert.Equal(ForceUnit.KilogramForce, quantity02.Unit);
 
-            var quantity03 = Force.From(1, ForceUnit.Kilonewton);
+            var quantity03 = Force<double>.From(1, ForceUnit.Kilonewton);
             AssertEx.EqualTolerance(1, quantity03.Kilonewtons, KilonewtonsTolerance);
             Assert.Equal(ForceUnit.Kilonewton, quantity03.Unit);
 
-            var quantity04 = Force.From(1, ForceUnit.KiloPond);
+            var quantity04 = Force<double>.From(1, ForceUnit.KiloPond);
             AssertEx.EqualTolerance(1, quantity04.KiloPonds, KiloPondsTolerance);
             Assert.Equal(ForceUnit.KiloPond, quantity04.Unit);
 
-            var quantity05 = Force.From(1, ForceUnit.KilopoundForce);
+            var quantity05 = Force<double>.From(1, ForceUnit.KilopoundForce);
             AssertEx.EqualTolerance(1, quantity05.KilopoundsForce, KilopoundsForceTolerance);
             Assert.Equal(ForceUnit.KilopoundForce, quantity05.Unit);
 
-            var quantity06 = Force.From(1, ForceUnit.Meganewton);
+            var quantity06 = Force<double>.From(1, ForceUnit.Meganewton);
             AssertEx.EqualTolerance(1, quantity06.Meganewtons, MeganewtonsTolerance);
             Assert.Equal(ForceUnit.Meganewton, quantity06.Unit);
 
-            var quantity07 = Force.From(1, ForceUnit.Micronewton);
+            var quantity07 = Force<double>.From(1, ForceUnit.Micronewton);
             AssertEx.EqualTolerance(1, quantity07.Micronewtons, MicronewtonsTolerance);
             Assert.Equal(ForceUnit.Micronewton, quantity07.Unit);
 
-            var quantity08 = Force.From(1, ForceUnit.Millinewton);
+            var quantity08 = Force<double>.From(1, ForceUnit.Millinewton);
             AssertEx.EqualTolerance(1, quantity08.Millinewtons, MillinewtonsTolerance);
             Assert.Equal(ForceUnit.Millinewton, quantity08.Unit);
 
-            var quantity09 = Force.From(1, ForceUnit.Newton);
+            var quantity09 = Force<double>.From(1, ForceUnit.Newton);
             AssertEx.EqualTolerance(1, quantity09.Newtons, NewtonsTolerance);
             Assert.Equal(ForceUnit.Newton, quantity09.Unit);
 
-            var quantity10 = Force.From(1, ForceUnit.OunceForce);
+            var quantity10 = Force<double>.From(1, ForceUnit.OunceForce);
             AssertEx.EqualTolerance(1, quantity10.OunceForce, OunceForceTolerance);
             Assert.Equal(ForceUnit.OunceForce, quantity10.Unit);
 
-            var quantity11 = Force.From(1, ForceUnit.Poundal);
+            var quantity11 = Force<double>.From(1, ForceUnit.Poundal);
             AssertEx.EqualTolerance(1, quantity11.Poundals, PoundalsTolerance);
             Assert.Equal(ForceUnit.Poundal, quantity11.Unit);
 
-            var quantity12 = Force.From(1, ForceUnit.PoundForce);
+            var quantity12 = Force<double>.From(1, ForceUnit.PoundForce);
             AssertEx.EqualTolerance(1, quantity12.PoundsForce, PoundsForceTolerance);
             Assert.Equal(ForceUnit.PoundForce, quantity12.Unit);
 
-            var quantity13 = Force.From(1, ForceUnit.ShortTonForce);
+            var quantity13 = Force<double>.From(1, ForceUnit.ShortTonForce);
             AssertEx.EqualTolerance(1, quantity13.ShortTonsForce, ShortTonsForceTolerance);
             Assert.Equal(ForceUnit.ShortTonForce, quantity13.Unit);
 
-            var quantity14 = Force.From(1, ForceUnit.TonneForce);
+            var quantity14 = Force<double>.From(1, ForceUnit.TonneForce);
             AssertEx.EqualTolerance(1, quantity14.TonnesForce, TonnesForceTolerance);
             Assert.Equal(ForceUnit.TonneForce, quantity14.Unit);
 
@@ -228,20 +228,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtons_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Force.FromNewtons(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Force.FromNewtons(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Force<double>.FromNewtons(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Force<double>.FromNewtons(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtons_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Force.FromNewtons(double.NaN));
+            Assert.Throws<ArgumentException>(() => Force<double>.FromNewtons(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newton = Force.FromNewtons(1);
+            var newton = Force<double>.FromNewtons(1);
             AssertEx.EqualTolerance(DecanewtonsInOneNewton, newton.As(ForceUnit.Decanewton), DecanewtonsTolerance);
             AssertEx.EqualTolerance(DyneInOneNewton, newton.As(ForceUnit.Dyn), DyneTolerance);
             AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.As(ForceUnit.KilogramForce), KilogramsForceTolerance);
@@ -279,7 +279,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newton = Force.FromNewtons(1);
+            var newton = Force<double>.FromNewtons(1);
 
             var decanewtonQuantity = newton.ToUnit(ForceUnit.Decanewton);
             AssertEx.EqualTolerance(DecanewtonsInOneNewton, (double)decanewtonQuantity.Value, DecanewtonsTolerance);
@@ -352,42 +352,42 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Force newton = Force.FromNewtons(1);
-            AssertEx.EqualTolerance(1, Force.FromDecanewtons(newton.Decanewtons).Newtons, DecanewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromDyne(newton.Dyne).Newtons, DyneTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKilogramsForce(newton.KilogramsForce).Newtons, KilogramsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKilonewtons(newton.Kilonewtons).Newtons, KilonewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKiloPonds(newton.KiloPonds).Newtons, KiloPondsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKilopoundsForce(newton.KilopoundsForce).Newtons, KilopoundsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromMeganewtons(newton.Meganewtons).Newtons, MeganewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromMicronewtons(newton.Micronewtons).Newtons, MicronewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromMillinewtons(newton.Millinewtons).Newtons, MillinewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromNewtons(newton.Newtons).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromOunceForce(newton.OunceForce).Newtons, OunceForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromPoundals(newton.Poundals).Newtons, PoundalsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromPoundsForce(newton.PoundsForce).Newtons, PoundsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromShortTonsForce(newton.ShortTonsForce).Newtons, ShortTonsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromTonnesForce(newton.TonnesForce).Newtons, TonnesForceTolerance);
+            Force<double> newton = Force<double>.FromNewtons(1);
+            AssertEx.EqualTolerance(1, Force<double>.FromDecanewtons(newton.Decanewtons).Newtons, DecanewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromDyne(newton.Dyne).Newtons, DyneTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromKilogramsForce(newton.KilogramsForce).Newtons, KilogramsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromKilonewtons(newton.Kilonewtons).Newtons, KilonewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromKiloPonds(newton.KiloPonds).Newtons, KiloPondsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromKilopoundsForce(newton.KilopoundsForce).Newtons, KilopoundsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromMeganewtons(newton.Meganewtons).Newtons, MeganewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromMicronewtons(newton.Micronewtons).Newtons, MicronewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromMillinewtons(newton.Millinewtons).Newtons, MillinewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromNewtons(newton.Newtons).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromOunceForce(newton.OunceForce).Newtons, OunceForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromPoundals(newton.Poundals).Newtons, PoundalsTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromPoundsForce(newton.PoundsForce).Newtons, PoundsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromShortTonsForce(newton.ShortTonsForce).Newtons, ShortTonsForceTolerance);
+            AssertEx.EqualTolerance(1, Force<double>.FromTonnesForce(newton.TonnesForce).Newtons, TonnesForceTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Force v = Force.FromNewtons(1);
+            Force<double> v = Force<double>.FromNewtons(1);
             AssertEx.EqualTolerance(-1, -v.Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(2, (Force.FromNewtons(3)-v).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(2, (Force<double>.FromNewtons(3)-v).Newtons, NewtonsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Newtons, NewtonsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Newtons, NewtonsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(2, (Force.FromNewtons(10)/5).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(2, Force.FromNewtons(10)/Force.FromNewtons(5), NewtonsTolerance);
+            AssertEx.EqualTolerance(2, (Force<double>.FromNewtons(10)/5).Newtons, NewtonsTolerance);
+            AssertEx.EqualTolerance(2, Force<double>.FromNewtons(10)/Force<double>.FromNewtons(5), NewtonsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Force oneNewton = Force.FromNewtons(1);
-            Force twoNewtons = Force.FromNewtons(2);
+            Force<double> oneNewton = Force<double>.FromNewtons(1);
+            Force<double> twoNewtons = Force<double>.FromNewtons(2);
 
             Assert.True(oneNewton < twoNewtons);
             Assert.True(oneNewton <= twoNewtons);
@@ -403,31 +403,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Force newton = Force.FromNewtons(1);
+            Force<double> newton = Force<double>.FromNewtons(1);
             Assert.Equal(0, newton.CompareTo(newton));
-            Assert.True(newton.CompareTo(Force.Zero) > 0);
-            Assert.True(Force.Zero.CompareTo(newton) < 0);
+            Assert.True(newton.CompareTo(Force<double>.Zero) > 0);
+            Assert.True(Force<double>.Zero.CompareTo(newton) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Force newton = Force.FromNewtons(1);
+            Force<double> newton = Force<double>.FromNewtons(1);
             Assert.Throws<ArgumentException>(() => newton.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Force newton = Force.FromNewtons(1);
+            Force<double> newton = Force<double>.FromNewtons(1);
             Assert.Throws<ArgumentNullException>(() => newton.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Force.FromNewtons(1);
-            var b = Force.FromNewtons(2);
+            var a = Force<double>.FromNewtons(1);
+            var b = Force<double>.FromNewtons(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -446,8 +446,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Force.FromNewtons(1);
-            var b = Force.FromNewtons(2);
+            var a = Force<double>.FromNewtons(1);
+            var b = Force<double>.FromNewtons(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -467,9 +467,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Force.FromNewtons(1);
-            Assert.True(v.Equals(Force.FromNewtons(1), NewtonsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Force.Zero, NewtonsTolerance, ComparisonType.Relative));
+            var v = Force<double>.FromNewtons(1);
+            Assert.True(v.Equals(Force<double>.FromNewtons(1), NewtonsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Force<double>.Zero, NewtonsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -482,21 +482,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Force newton = Force.FromNewtons(1);
+            Force<double> newton = Force<double>.FromNewtons(1);
             Assert.False(newton.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Force newton = Force.FromNewtons(1);
+            Force<double> newton = Force<double>.FromNewtons(1);
             Assert.False(newton.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ForceUnit.Undefined, Force.Units);
+            Assert.DoesNotContain(ForceUnit.Undefined, Force<double>.Units);
         }
 
         [Fact]
@@ -515,7 +515,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Force.BaseDimensions is null);
+            Assert.False(Force<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs
index f0b085c479..cdfec3769b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs
@@ -64,7 +64,7 @@ public abstract partial class FrequencyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Frequency((double)0.0, FrequencyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Frequency<double>((double)0.0, FrequencyUnit.Undefined));
         }
 
         [Fact]
@@ -79,14 +79,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Frequency(double.PositiveInfinity, FrequencyUnit.Hertz));
-            Assert.Throws<ArgumentException>(() => new Frequency(double.NegativeInfinity, FrequencyUnit.Hertz));
+            Assert.Throws<ArgumentException>(() => new Frequency<double>(double.PositiveInfinity, FrequencyUnit.Hertz));
+            Assert.Throws<ArgumentException>(() => new Frequency<double>(double.NegativeInfinity, FrequencyUnit.Hertz));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Frequency(double.NaN, FrequencyUnit.Hertz));
+            Assert.Throws<ArgumentException>(() => new Frequency<double>(double.NaN, FrequencyUnit.Hertz));
         }
 
         [Fact]
@@ -132,7 +132,7 @@ public void Frequency_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void HertzToFrequencyUnits()
         {
-            Frequency hertz = Frequency.FromHertz(1);
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
             AssertEx.EqualTolerance(BeatsPerMinuteInOneHertz, hertz.BeatsPerMinute, BeatsPerMinuteTolerance);
             AssertEx.EqualTolerance(CyclesPerHourInOneHertz, hertz.CyclesPerHour, CyclesPerHourTolerance);
             AssertEx.EqualTolerance(CyclesPerMinuteInOneHertz, hertz.CyclesPerMinute, CyclesPerMinuteTolerance);
@@ -148,43 +148,43 @@ public void HertzToFrequencyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Frequency.From(1, FrequencyUnit.BeatPerMinute);
+            var quantity00 = Frequency<double>.From(1, FrequencyUnit.BeatPerMinute);
             AssertEx.EqualTolerance(1, quantity00.BeatsPerMinute, BeatsPerMinuteTolerance);
             Assert.Equal(FrequencyUnit.BeatPerMinute, quantity00.Unit);
 
-            var quantity01 = Frequency.From(1, FrequencyUnit.CyclePerHour);
+            var quantity01 = Frequency<double>.From(1, FrequencyUnit.CyclePerHour);
             AssertEx.EqualTolerance(1, quantity01.CyclesPerHour, CyclesPerHourTolerance);
             Assert.Equal(FrequencyUnit.CyclePerHour, quantity01.Unit);
 
-            var quantity02 = Frequency.From(1, FrequencyUnit.CyclePerMinute);
+            var quantity02 = Frequency<double>.From(1, FrequencyUnit.CyclePerMinute);
             AssertEx.EqualTolerance(1, quantity02.CyclesPerMinute, CyclesPerMinuteTolerance);
             Assert.Equal(FrequencyUnit.CyclePerMinute, quantity02.Unit);
 
-            var quantity03 = Frequency.From(1, FrequencyUnit.Gigahertz);
+            var quantity03 = Frequency<double>.From(1, FrequencyUnit.Gigahertz);
             AssertEx.EqualTolerance(1, quantity03.Gigahertz, GigahertzTolerance);
             Assert.Equal(FrequencyUnit.Gigahertz, quantity03.Unit);
 
-            var quantity04 = Frequency.From(1, FrequencyUnit.Hertz);
+            var quantity04 = Frequency<double>.From(1, FrequencyUnit.Hertz);
             AssertEx.EqualTolerance(1, quantity04.Hertz, HertzTolerance);
             Assert.Equal(FrequencyUnit.Hertz, quantity04.Unit);
 
-            var quantity05 = Frequency.From(1, FrequencyUnit.Kilohertz);
+            var quantity05 = Frequency<double>.From(1, FrequencyUnit.Kilohertz);
             AssertEx.EqualTolerance(1, quantity05.Kilohertz, KilohertzTolerance);
             Assert.Equal(FrequencyUnit.Kilohertz, quantity05.Unit);
 
-            var quantity06 = Frequency.From(1, FrequencyUnit.Megahertz);
+            var quantity06 = Frequency<double>.From(1, FrequencyUnit.Megahertz);
             AssertEx.EqualTolerance(1, quantity06.Megahertz, MegahertzTolerance);
             Assert.Equal(FrequencyUnit.Megahertz, quantity06.Unit);
 
-            var quantity07 = Frequency.From(1, FrequencyUnit.PerSecond);
+            var quantity07 = Frequency<double>.From(1, FrequencyUnit.PerSecond);
             AssertEx.EqualTolerance(1, quantity07.PerSecond, PerSecondTolerance);
             Assert.Equal(FrequencyUnit.PerSecond, quantity07.Unit);
 
-            var quantity08 = Frequency.From(1, FrequencyUnit.RadianPerSecond);
+            var quantity08 = Frequency<double>.From(1, FrequencyUnit.RadianPerSecond);
             AssertEx.EqualTolerance(1, quantity08.RadiansPerSecond, RadiansPerSecondTolerance);
             Assert.Equal(FrequencyUnit.RadianPerSecond, quantity08.Unit);
 
-            var quantity09 = Frequency.From(1, FrequencyUnit.Terahertz);
+            var quantity09 = Frequency<double>.From(1, FrequencyUnit.Terahertz);
             AssertEx.EqualTolerance(1, quantity09.Terahertz, TerahertzTolerance);
             Assert.Equal(FrequencyUnit.Terahertz, quantity09.Unit);
 
@@ -193,20 +193,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromHertz_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Frequency.FromHertz(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Frequency.FromHertz(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Frequency<double>.FromHertz(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Frequency<double>.FromHertz(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromHertz_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Frequency.FromHertz(double.NaN));
+            Assert.Throws<ArgumentException>(() => Frequency<double>.FromHertz(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var hertz = Frequency.FromHertz(1);
+            var hertz = Frequency<double>.FromHertz(1);
             AssertEx.EqualTolerance(BeatsPerMinuteInOneHertz, hertz.As(FrequencyUnit.BeatPerMinute), BeatsPerMinuteTolerance);
             AssertEx.EqualTolerance(CyclesPerHourInOneHertz, hertz.As(FrequencyUnit.CyclePerHour), CyclesPerHourTolerance);
             AssertEx.EqualTolerance(CyclesPerMinuteInOneHertz, hertz.As(FrequencyUnit.CyclePerMinute), CyclesPerMinuteTolerance);
@@ -239,7 +239,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var hertz = Frequency.FromHertz(1);
+            var hertz = Frequency<double>.FromHertz(1);
 
             var beatperminuteQuantity = hertz.ToUnit(FrequencyUnit.BeatPerMinute);
             AssertEx.EqualTolerance(BeatsPerMinuteInOneHertz, (double)beatperminuteQuantity.Value, BeatsPerMinuteTolerance);
@@ -292,37 +292,37 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Frequency hertz = Frequency.FromHertz(1);
-            AssertEx.EqualTolerance(1, Frequency.FromBeatsPerMinute(hertz.BeatsPerMinute).Hertz, BeatsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromCyclesPerHour(hertz.CyclesPerHour).Hertz, CyclesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromCyclesPerMinute(hertz.CyclesPerMinute).Hertz, CyclesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromGigahertz(hertz.Gigahertz).Hertz, GigahertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromHertz(hertz.Hertz).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromKilohertz(hertz.Kilohertz).Hertz, KilohertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromMegahertz(hertz.Megahertz).Hertz, MegahertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromPerSecond(hertz.PerSecond).Hertz, PerSecondTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromRadiansPerSecond(hertz.RadiansPerSecond).Hertz, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromTerahertz(hertz.Terahertz).Hertz, TerahertzTolerance);
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromBeatsPerMinute(hertz.BeatsPerMinute).Hertz, BeatsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromCyclesPerHour(hertz.CyclesPerHour).Hertz, CyclesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromCyclesPerMinute(hertz.CyclesPerMinute).Hertz, CyclesPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromGigahertz(hertz.Gigahertz).Hertz, GigahertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromHertz(hertz.Hertz).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromKilohertz(hertz.Kilohertz).Hertz, KilohertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromMegahertz(hertz.Megahertz).Hertz, MegahertzTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromPerSecond(hertz.PerSecond).Hertz, PerSecondTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromRadiansPerSecond(hertz.RadiansPerSecond).Hertz, RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Frequency<double>.FromTerahertz(hertz.Terahertz).Hertz, TerahertzTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Frequency v = Frequency.FromHertz(1);
+            Frequency<double> v = Frequency<double>.FromHertz(1);
             AssertEx.EqualTolerance(-1, -v.Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(2, (Frequency.FromHertz(3)-v).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(2, (Frequency<double>.FromHertz(3)-v).Hertz, HertzTolerance);
             AssertEx.EqualTolerance(2, (v + v).Hertz, HertzTolerance);
             AssertEx.EqualTolerance(10, (v*10).Hertz, HertzTolerance);
             AssertEx.EqualTolerance(10, (10*v).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(2, (Frequency.FromHertz(10)/5).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(2, Frequency.FromHertz(10)/Frequency.FromHertz(5), HertzTolerance);
+            AssertEx.EqualTolerance(2, (Frequency<double>.FromHertz(10)/5).Hertz, HertzTolerance);
+            AssertEx.EqualTolerance(2, Frequency<double>.FromHertz(10)/Frequency<double>.FromHertz(5), HertzTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Frequency oneHertz = Frequency.FromHertz(1);
-            Frequency twoHertz = Frequency.FromHertz(2);
+            Frequency<double> oneHertz = Frequency<double>.FromHertz(1);
+            Frequency<double> twoHertz = Frequency<double>.FromHertz(2);
 
             Assert.True(oneHertz < twoHertz);
             Assert.True(oneHertz <= twoHertz);
@@ -338,31 +338,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Frequency hertz = Frequency.FromHertz(1);
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
             Assert.Equal(0, hertz.CompareTo(hertz));
-            Assert.True(hertz.CompareTo(Frequency.Zero) > 0);
-            Assert.True(Frequency.Zero.CompareTo(hertz) < 0);
+            Assert.True(hertz.CompareTo(Frequency<double>.Zero) > 0);
+            Assert.True(Frequency<double>.Zero.CompareTo(hertz) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Frequency hertz = Frequency.FromHertz(1);
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
             Assert.Throws<ArgumentException>(() => hertz.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Frequency hertz = Frequency.FromHertz(1);
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
             Assert.Throws<ArgumentNullException>(() => hertz.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Frequency.FromHertz(1);
-            var b = Frequency.FromHertz(2);
+            var a = Frequency<double>.FromHertz(1);
+            var b = Frequency<double>.FromHertz(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -381,8 +381,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Frequency.FromHertz(1);
-            var b = Frequency.FromHertz(2);
+            var a = Frequency<double>.FromHertz(1);
+            var b = Frequency<double>.FromHertz(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -402,9 +402,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Frequency.FromHertz(1);
-            Assert.True(v.Equals(Frequency.FromHertz(1), HertzTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Frequency.Zero, HertzTolerance, ComparisonType.Relative));
+            var v = Frequency<double>.FromHertz(1);
+            Assert.True(v.Equals(Frequency<double>.FromHertz(1), HertzTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Frequency<double>.Zero, HertzTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -417,21 +417,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Frequency hertz = Frequency.FromHertz(1);
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
             Assert.False(hertz.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Frequency hertz = Frequency.FromHertz(1);
+            Frequency<double> hertz = Frequency<double>.FromHertz(1);
             Assert.False(hertz.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(FrequencyUnit.Undefined, Frequency.Units);
+            Assert.DoesNotContain(FrequencyUnit.Undefined, Frequency<double>.Units);
         }
 
         [Fact]
@@ -450,7 +450,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Frequency.BaseDimensions is null);
+            Assert.False(Frequency<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs
index ee4a4a5ac9..c190d22f14 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class FuelEfficiencyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new FuelEfficiency((double)0.0, FuelEfficiencyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>((double)0.0, FuelEfficiencyUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new FuelEfficiency(double.PositiveInfinity, FuelEfficiencyUnit.LiterPer100Kilometers));
-            Assert.Throws<ArgumentException>(() => new FuelEfficiency(double.NegativeInfinity, FuelEfficiencyUnit.LiterPer100Kilometers));
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>(double.PositiveInfinity, FuelEfficiencyUnit.LiterPer100Kilometers));
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>(double.NegativeInfinity, FuelEfficiencyUnit.LiterPer100Kilometers));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new FuelEfficiency(double.NaN, FuelEfficiencyUnit.LiterPer100Kilometers));
+            Assert.Throws<ArgumentException>(() => new FuelEfficiency<double>(double.NaN, FuelEfficiencyUnit.LiterPer100Kilometers));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void FuelEfficiency_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void LiterPer100KilometersToFuelEfficiencyUnits()
         {
-            FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, literper100kilometers.KilometersPerLiters, KilometersPerLitersTolerance);
             AssertEx.EqualTolerance(LitersPer100KilometersInOneLiterPer100Kilometers, literper100kilometers.LitersPer100Kilometers, LitersPer100KilometersTolerance);
             AssertEx.EqualTolerance(MilesPerUkGallonInOneLiterPer100Kilometers, literper100kilometers.MilesPerUkGallon, MilesPerUkGallonTolerance);
@@ -130,19 +130,19 @@ public void LiterPer100KilometersToFuelEfficiencyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = FuelEfficiency.From(1, FuelEfficiencyUnit.KilometerPerLiter);
+            var quantity00 = FuelEfficiency<double>.From(1, FuelEfficiencyUnit.KilometerPerLiter);
             AssertEx.EqualTolerance(1, quantity00.KilometersPerLiters, KilometersPerLitersTolerance);
             Assert.Equal(FuelEfficiencyUnit.KilometerPerLiter, quantity00.Unit);
 
-            var quantity01 = FuelEfficiency.From(1, FuelEfficiencyUnit.LiterPer100Kilometers);
+            var quantity01 = FuelEfficiency<double>.From(1, FuelEfficiencyUnit.LiterPer100Kilometers);
             AssertEx.EqualTolerance(1, quantity01.LitersPer100Kilometers, LitersPer100KilometersTolerance);
             Assert.Equal(FuelEfficiencyUnit.LiterPer100Kilometers, quantity01.Unit);
 
-            var quantity02 = FuelEfficiency.From(1, FuelEfficiencyUnit.MilePerUkGallon);
+            var quantity02 = FuelEfficiency<double>.From(1, FuelEfficiencyUnit.MilePerUkGallon);
             AssertEx.EqualTolerance(1, quantity02.MilesPerUkGallon, MilesPerUkGallonTolerance);
             Assert.Equal(FuelEfficiencyUnit.MilePerUkGallon, quantity02.Unit);
 
-            var quantity03 = FuelEfficiency.From(1, FuelEfficiencyUnit.MilePerUsGallon);
+            var quantity03 = FuelEfficiency<double>.From(1, FuelEfficiencyUnit.MilePerUsGallon);
             AssertEx.EqualTolerance(1, quantity03.MilesPerUsGallon, MilesPerUsGallonTolerance);
             Assert.Equal(FuelEfficiencyUnit.MilePerUsGallon, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromLitersPer100Kilometers_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => FuelEfficiency.FromLitersPer100Kilometers(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => FuelEfficiency.FromLitersPer100Kilometers(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => FuelEfficiency<double>.FromLitersPer100Kilometers(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => FuelEfficiency<double>.FromLitersPer100Kilometers(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromLitersPer100Kilometers_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => FuelEfficiency.FromLitersPer100Kilometers(double.NaN));
+            Assert.Throws<ArgumentException>(() => FuelEfficiency<double>.FromLitersPer100Kilometers(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            var literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.KilometerPerLiter), KilometersPerLitersTolerance);
             AssertEx.EqualTolerance(LitersPer100KilometersInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.LiterPer100Kilometers), LitersPer100KilometersTolerance);
             AssertEx.EqualTolerance(MilesPerUkGallonInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.MilePerUkGallon), MilesPerUkGallonTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            var literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
 
             var kilometerperliterQuantity = literper100kilometers.ToUnit(FuelEfficiencyUnit.KilometerPerLiter);
             AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, (double)kilometerperliterQuantity.Value, KilometersPerLitersTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromKilometersPerLiters(literper100kilometers.KilometersPerLiters).LitersPer100Kilometers, KilometersPerLitersTolerance);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromLitersPer100Kilometers(literper100kilometers.LitersPer100Kilometers).LitersPer100Kilometers, LitersPer100KilometersTolerance);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromMilesPerUkGallon(literper100kilometers.MilesPerUkGallon).LitersPer100Kilometers, MilesPerUkGallonTolerance);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromMilesPerUsGallon(literper100kilometers.MilesPerUsGallon).LitersPer100Kilometers, MilesPerUsGallonTolerance);
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromKilometersPerLiters(literper100kilometers.KilometersPerLiters).LitersPer100Kilometers, KilometersPerLitersTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromLitersPer100Kilometers(literper100kilometers.LitersPer100Kilometers).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromMilesPerUkGallon(literper100kilometers.MilesPerUkGallon).LitersPer100Kilometers, MilesPerUkGallonTolerance);
+            AssertEx.EqualTolerance(1, FuelEfficiency<double>.FromMilesPerUsGallon(literper100kilometers.MilesPerUsGallon).LitersPer100Kilometers, MilesPerUsGallonTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            FuelEfficiency v = FuelEfficiency.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> v = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             AssertEx.EqualTolerance(-1, -v.LitersPer100Kilometers, LitersPer100KilometersTolerance);
-            AssertEx.EqualTolerance(2, (FuelEfficiency.FromLitersPer100Kilometers(3)-v).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(2, (FuelEfficiency<double>.FromLitersPer100Kilometers(3)-v).LitersPer100Kilometers, LitersPer100KilometersTolerance);
             AssertEx.EqualTolerance(2, (v + v).LitersPer100Kilometers, LitersPer100KilometersTolerance);
             AssertEx.EqualTolerance(10, (v*10).LitersPer100Kilometers, LitersPer100KilometersTolerance);
             AssertEx.EqualTolerance(10, (10*v).LitersPer100Kilometers, LitersPer100KilometersTolerance);
-            AssertEx.EqualTolerance(2, (FuelEfficiency.FromLitersPer100Kilometers(10)/5).LitersPer100Kilometers, LitersPer100KilometersTolerance);
-            AssertEx.EqualTolerance(2, FuelEfficiency.FromLitersPer100Kilometers(10)/FuelEfficiency.FromLitersPer100Kilometers(5), LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(2, (FuelEfficiency<double>.FromLitersPer100Kilometers(10)/5).LitersPer100Kilometers, LitersPer100KilometersTolerance);
+            AssertEx.EqualTolerance(2, FuelEfficiency<double>.FromLitersPer100Kilometers(10)/FuelEfficiency<double>.FromLitersPer100Kilometers(5), LitersPer100KilometersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            FuelEfficiency oneLiterPer100Kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
-            FuelEfficiency twoLitersPer100Kilometers = FuelEfficiency.FromLitersPer100Kilometers(2);
+            FuelEfficiency<double> oneLiterPer100Kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> twoLitersPer100Kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(2);
 
             Assert.True(oneLiterPer100Kilometers < twoLitersPer100Kilometers);
             Assert.True(oneLiterPer100Kilometers <= twoLitersPer100Kilometers);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             Assert.Equal(0, literper100kilometers.CompareTo(literper100kilometers));
-            Assert.True(literper100kilometers.CompareTo(FuelEfficiency.Zero) > 0);
-            Assert.True(FuelEfficiency.Zero.CompareTo(literper100kilometers) < 0);
+            Assert.True(literper100kilometers.CompareTo(FuelEfficiency<double>.Zero) > 0);
+            Assert.True(FuelEfficiency<double>.Zero.CompareTo(literper100kilometers) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             Assert.Throws<ArgumentException>(() => literper100kilometers.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             Assert.Throws<ArgumentNullException>(() => literper100kilometers.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = FuelEfficiency.FromLitersPer100Kilometers(1);
-            var b = FuelEfficiency.FromLitersPer100Kilometers(2);
+            var a = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            var b = FuelEfficiency<double>.FromLitersPer100Kilometers(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = FuelEfficiency.FromLitersPer100Kilometers(1);
-            var b = FuelEfficiency.FromLitersPer100Kilometers(2);
+            var a = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            var b = FuelEfficiency<double>.FromLitersPer100Kilometers(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = FuelEfficiency.FromLitersPer100Kilometers(1);
-            Assert.True(v.Equals(FuelEfficiency.FromLitersPer100Kilometers(1), LitersPer100KilometersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(FuelEfficiency.Zero, LitersPer100KilometersTolerance, ComparisonType.Relative));
+            var v = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
+            Assert.True(v.Equals(FuelEfficiency<double>.FromLitersPer100Kilometers(1), LitersPer100KilometersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(FuelEfficiency<double>.Zero, LitersPer100KilometersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             Assert.False(literper100kilometers.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1);
+            FuelEfficiency<double> literper100kilometers = FuelEfficiency<double>.FromLitersPer100Kilometers(1);
             Assert.False(literper100kilometers.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(FuelEfficiencyUnit.Undefined, FuelEfficiency.Units);
+            Assert.DoesNotContain(FuelEfficiencyUnit.Undefined, FuelEfficiency<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(FuelEfficiency.BaseDimensions is null);
+            Assert.False(FuelEfficiency<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs
index 4e74e0a109..09f089b2ee 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs
@@ -80,7 +80,7 @@ public abstract partial class HeatFluxTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new HeatFlux((double)0.0, HeatFluxUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new HeatFlux<double>((double)0.0, HeatFluxUnit.Undefined));
         }
 
         [Fact]
@@ -95,14 +95,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new HeatFlux(double.PositiveInfinity, HeatFluxUnit.WattPerSquareMeter));
-            Assert.Throws<ArgumentException>(() => new HeatFlux(double.NegativeInfinity, HeatFluxUnit.WattPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new HeatFlux<double>(double.PositiveInfinity, HeatFluxUnit.WattPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new HeatFlux<double>(double.NegativeInfinity, HeatFluxUnit.WattPerSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new HeatFlux(double.NaN, HeatFluxUnit.WattPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new HeatFlux<double>(double.NaN, HeatFluxUnit.WattPerSquareMeter));
         }
 
         [Fact]
@@ -148,7 +148,7 @@ public void HeatFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void WattPerSquareMeterToHeatFluxUnits()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            HeatFlux<double> wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
             AssertEx.EqualTolerance(BtusPerHourSquareFootInOneWattPerSquareMeter, wattpersquaremeter.BtusPerHourSquareFoot, BtusPerHourSquareFootTolerance);
             AssertEx.EqualTolerance(BtusPerMinuteSquareFootInOneWattPerSquareMeter, wattpersquaremeter.BtusPerMinuteSquareFoot, BtusPerMinuteSquareFootTolerance);
             AssertEx.EqualTolerance(BtusPerSecondSquareFootInOneWattPerSquareMeter, wattpersquaremeter.BtusPerSecondSquareFoot, BtusPerSecondSquareFootTolerance);
@@ -172,75 +172,75 @@ public void WattPerSquareMeterToHeatFluxUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = HeatFlux.From(1, HeatFluxUnit.BtuPerHourSquareFoot);
+            var quantity00 = HeatFlux<double>.From(1, HeatFluxUnit.BtuPerHourSquareFoot);
             AssertEx.EqualTolerance(1, quantity00.BtusPerHourSquareFoot, BtusPerHourSquareFootTolerance);
             Assert.Equal(HeatFluxUnit.BtuPerHourSquareFoot, quantity00.Unit);
 
-            var quantity01 = HeatFlux.From(1, HeatFluxUnit.BtuPerMinuteSquareFoot);
+            var quantity01 = HeatFlux<double>.From(1, HeatFluxUnit.BtuPerMinuteSquareFoot);
             AssertEx.EqualTolerance(1, quantity01.BtusPerMinuteSquareFoot, BtusPerMinuteSquareFootTolerance);
             Assert.Equal(HeatFluxUnit.BtuPerMinuteSquareFoot, quantity01.Unit);
 
-            var quantity02 = HeatFlux.From(1, HeatFluxUnit.BtuPerSecondSquareFoot);
+            var quantity02 = HeatFlux<double>.From(1, HeatFluxUnit.BtuPerSecondSquareFoot);
             AssertEx.EqualTolerance(1, quantity02.BtusPerSecondSquareFoot, BtusPerSecondSquareFootTolerance);
             Assert.Equal(HeatFluxUnit.BtuPerSecondSquareFoot, quantity02.Unit);
 
-            var quantity03 = HeatFlux.From(1, HeatFluxUnit.BtuPerSecondSquareInch);
+            var quantity03 = HeatFlux<double>.From(1, HeatFluxUnit.BtuPerSecondSquareInch);
             AssertEx.EqualTolerance(1, quantity03.BtusPerSecondSquareInch, BtusPerSecondSquareInchTolerance);
             Assert.Equal(HeatFluxUnit.BtuPerSecondSquareInch, quantity03.Unit);
 
-            var quantity04 = HeatFlux.From(1, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
+            var quantity04 = HeatFlux<double>.From(1, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity04.CaloriesPerSecondSquareCentimeter, CaloriesPerSecondSquareCentimeterTolerance);
             Assert.Equal(HeatFluxUnit.CaloriePerSecondSquareCentimeter, quantity04.Unit);
 
-            var quantity05 = HeatFlux.From(1, HeatFluxUnit.CentiwattPerSquareMeter);
+            var quantity05 = HeatFlux<double>.From(1, HeatFluxUnit.CentiwattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity05.CentiwattsPerSquareMeter, CentiwattsPerSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.CentiwattPerSquareMeter, quantity05.Unit);
 
-            var quantity06 = HeatFlux.From(1, HeatFluxUnit.DeciwattPerSquareMeter);
+            var quantity06 = HeatFlux<double>.From(1, HeatFluxUnit.DeciwattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity06.DeciwattsPerSquareMeter, DeciwattsPerSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.DeciwattPerSquareMeter, quantity06.Unit);
 
-            var quantity07 = HeatFlux.From(1, HeatFluxUnit.KilocaloriePerHourSquareMeter);
+            var quantity07 = HeatFlux<double>.From(1, HeatFluxUnit.KilocaloriePerHourSquareMeter);
             AssertEx.EqualTolerance(1, quantity07.KilocaloriesPerHourSquareMeter, KilocaloriesPerHourSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.KilocaloriePerHourSquareMeter, quantity07.Unit);
 
-            var quantity08 = HeatFlux.From(1, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
+            var quantity08 = HeatFlux<double>.From(1, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity08.KilocaloriesPerSecondSquareCentimeter, KilocaloriesPerSecondSquareCentimeterTolerance);
             Assert.Equal(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, quantity08.Unit);
 
-            var quantity09 = HeatFlux.From(1, HeatFluxUnit.KilowattPerSquareMeter);
+            var quantity09 = HeatFlux<double>.From(1, HeatFluxUnit.KilowattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity09.KilowattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.KilowattPerSquareMeter, quantity09.Unit);
 
-            var quantity10 = HeatFlux.From(1, HeatFluxUnit.MicrowattPerSquareMeter);
+            var quantity10 = HeatFlux<double>.From(1, HeatFluxUnit.MicrowattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity10.MicrowattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.MicrowattPerSquareMeter, quantity10.Unit);
 
-            var quantity11 = HeatFlux.From(1, HeatFluxUnit.MilliwattPerSquareMeter);
+            var quantity11 = HeatFlux<double>.From(1, HeatFluxUnit.MilliwattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity11.MilliwattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.MilliwattPerSquareMeter, quantity11.Unit);
 
-            var quantity12 = HeatFlux.From(1, HeatFluxUnit.NanowattPerSquareMeter);
+            var quantity12 = HeatFlux<double>.From(1, HeatFluxUnit.NanowattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity12.NanowattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.NanowattPerSquareMeter, quantity12.Unit);
 
-            var quantity13 = HeatFlux.From(1, HeatFluxUnit.PoundForcePerFootSecond);
+            var quantity13 = HeatFlux<double>.From(1, HeatFluxUnit.PoundForcePerFootSecond);
             AssertEx.EqualTolerance(1, quantity13.PoundsForcePerFootSecond, PoundsForcePerFootSecondTolerance);
             Assert.Equal(HeatFluxUnit.PoundForcePerFootSecond, quantity13.Unit);
 
-            var quantity14 = HeatFlux.From(1, HeatFluxUnit.PoundPerSecondCubed);
+            var quantity14 = HeatFlux<double>.From(1, HeatFluxUnit.PoundPerSecondCubed);
             AssertEx.EqualTolerance(1, quantity14.PoundsPerSecondCubed, PoundsPerSecondCubedTolerance);
             Assert.Equal(HeatFluxUnit.PoundPerSecondCubed, quantity14.Unit);
 
-            var quantity15 = HeatFlux.From(1, HeatFluxUnit.WattPerSquareFoot);
+            var quantity15 = HeatFlux<double>.From(1, HeatFluxUnit.WattPerSquareFoot);
             AssertEx.EqualTolerance(1, quantity15.WattsPerSquareFoot, WattsPerSquareFootTolerance);
             Assert.Equal(HeatFluxUnit.WattPerSquareFoot, quantity15.Unit);
 
-            var quantity16 = HeatFlux.From(1, HeatFluxUnit.WattPerSquareInch);
+            var quantity16 = HeatFlux<double>.From(1, HeatFluxUnit.WattPerSquareInch);
             AssertEx.EqualTolerance(1, quantity16.WattsPerSquareInch, WattsPerSquareInchTolerance);
             Assert.Equal(HeatFluxUnit.WattPerSquareInch, quantity16.Unit);
 
-            var quantity17 = HeatFlux.From(1, HeatFluxUnit.WattPerSquareMeter);
+            var quantity17 = HeatFlux<double>.From(1, HeatFluxUnit.WattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity17.WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             Assert.Equal(HeatFluxUnit.WattPerSquareMeter, quantity17.Unit);
 
@@ -249,20 +249,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWattsPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => HeatFlux.FromWattsPerSquareMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => HeatFlux.FromWattsPerSquareMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => HeatFlux<double>.FromWattsPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => HeatFlux<double>.FromWattsPerSquareMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWattsPerSquareMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => HeatFlux.FromWattsPerSquareMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => HeatFlux<double>.FromWattsPerSquareMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            var wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
             AssertEx.EqualTolerance(BtusPerHourSquareFootInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.BtuPerHourSquareFoot), BtusPerHourSquareFootTolerance);
             AssertEx.EqualTolerance(BtusPerMinuteSquareFootInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.BtuPerMinuteSquareFoot), BtusPerMinuteSquareFootTolerance);
             AssertEx.EqualTolerance(BtusPerSecondSquareFootInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.BtuPerSecondSquareFoot), BtusPerSecondSquareFootTolerance);
@@ -303,7 +303,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            var wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
 
             var btuperhoursquarefootQuantity = wattpersquaremeter.ToUnit(HeatFluxUnit.BtuPerHourSquareFoot);
             AssertEx.EqualTolerance(BtusPerHourSquareFootInOneWattPerSquareMeter, (double)btuperhoursquarefootQuantity.Value, BtusPerHourSquareFootTolerance);
@@ -388,45 +388,45 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerHourSquareFoot(wattpersquaremeter.BtusPerHourSquareFoot).WattsPerSquareMeter, BtusPerHourSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerMinuteSquareFoot(wattpersquaremeter.BtusPerMinuteSquareFoot).WattsPerSquareMeter, BtusPerMinuteSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerSecondSquareFoot(wattpersquaremeter.BtusPerSecondSquareFoot).WattsPerSquareMeter, BtusPerSecondSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerSecondSquareInch(wattpersquaremeter.BtusPerSecondSquareInch).WattsPerSquareMeter, BtusPerSecondSquareInchTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromCaloriesPerSecondSquareCentimeter(wattpersquaremeter.CaloriesPerSecondSquareCentimeter).WattsPerSquareMeter, CaloriesPerSecondSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromCentiwattsPerSquareMeter(wattpersquaremeter.CentiwattsPerSquareMeter).WattsPerSquareMeter, CentiwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromDeciwattsPerSquareMeter(wattpersquaremeter.DeciwattsPerSquareMeter).WattsPerSquareMeter, DeciwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromKilocaloriesPerHourSquareMeter(wattpersquaremeter.KilocaloriesPerHourSquareMeter).WattsPerSquareMeter, KilocaloriesPerHourSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(wattpersquaremeter.KilocaloriesPerSecondSquareCentimeter).WattsPerSquareMeter, KilocaloriesPerSecondSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromPoundsForcePerFootSecond(wattpersquaremeter.PoundsForcePerFootSecond).WattsPerSquareMeter, PoundsForcePerFootSecondTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromPoundsPerSecondCubed(wattpersquaremeter.PoundsPerSecondCubed).WattsPerSquareMeter, PoundsPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromWattsPerSquareFoot(wattpersquaremeter.WattsPerSquareFoot).WattsPerSquareMeter, WattsPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromWattsPerSquareInch(wattpersquaremeter.WattsPerSquareInch).WattsPerSquareMeter, WattsPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            HeatFlux<double> wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromBtusPerHourSquareFoot(wattpersquaremeter.BtusPerHourSquareFoot).WattsPerSquareMeter, BtusPerHourSquareFootTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromBtusPerMinuteSquareFoot(wattpersquaremeter.BtusPerMinuteSquareFoot).WattsPerSquareMeter, BtusPerMinuteSquareFootTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromBtusPerSecondSquareFoot(wattpersquaremeter.BtusPerSecondSquareFoot).WattsPerSquareMeter, BtusPerSecondSquareFootTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromBtusPerSecondSquareInch(wattpersquaremeter.BtusPerSecondSquareInch).WattsPerSquareMeter, BtusPerSecondSquareInchTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromCaloriesPerSecondSquareCentimeter(wattpersquaremeter.CaloriesPerSecondSquareCentimeter).WattsPerSquareMeter, CaloriesPerSecondSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromCentiwattsPerSquareMeter(wattpersquaremeter.CentiwattsPerSquareMeter).WattsPerSquareMeter, CentiwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromDeciwattsPerSquareMeter(wattpersquaremeter.DeciwattsPerSquareMeter).WattsPerSquareMeter, DeciwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromKilocaloriesPerHourSquareMeter(wattpersquaremeter.KilocaloriesPerHourSquareMeter).WattsPerSquareMeter, KilocaloriesPerHourSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromKilocaloriesPerSecondSquareCentimeter(wattpersquaremeter.KilocaloriesPerSecondSquareCentimeter).WattsPerSquareMeter, KilocaloriesPerSecondSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromPoundsForcePerFootSecond(wattpersquaremeter.PoundsForcePerFootSecond).WattsPerSquareMeter, PoundsForcePerFootSecondTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromPoundsPerSecondCubed(wattpersquaremeter.PoundsPerSecondCubed).WattsPerSquareMeter, PoundsPerSecondCubedTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromWattsPerSquareFoot(wattpersquaremeter.WattsPerSquareFoot).WattsPerSquareMeter, WattsPerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromWattsPerSquareInch(wattpersquaremeter.WattsPerSquareInch).WattsPerSquareMeter, WattsPerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, HeatFlux<double>.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            HeatFlux v = HeatFlux.FromWattsPerSquareMeter(1);
+            HeatFlux<double> v = HeatFlux<double>.FromWattsPerSquareMeter(1);
             AssertEx.EqualTolerance(-1, -v.WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (HeatFlux.FromWattsPerSquareMeter(3)-v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (HeatFlux<double>.FromWattsPerSquareMeter(3)-v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (HeatFlux.FromWattsPerSquareMeter(10)/5).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, HeatFlux.FromWattsPerSquareMeter(10)/HeatFlux.FromWattsPerSquareMeter(5), WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (HeatFlux<double>.FromWattsPerSquareMeter(10)/5).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, HeatFlux<double>.FromWattsPerSquareMeter(10)/HeatFlux<double>.FromWattsPerSquareMeter(5), WattsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            HeatFlux oneWattPerSquareMeter = HeatFlux.FromWattsPerSquareMeter(1);
-            HeatFlux twoWattsPerSquareMeter = HeatFlux.FromWattsPerSquareMeter(2);
+            HeatFlux<double> oneWattPerSquareMeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
+            HeatFlux<double> twoWattsPerSquareMeter = HeatFlux<double>.FromWattsPerSquareMeter(2);
 
             Assert.True(oneWattPerSquareMeter < twoWattsPerSquareMeter);
             Assert.True(oneWattPerSquareMeter <= twoWattsPerSquareMeter);
@@ -442,31 +442,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            HeatFlux<double> wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
             Assert.Equal(0, wattpersquaremeter.CompareTo(wattpersquaremeter));
-            Assert.True(wattpersquaremeter.CompareTo(HeatFlux.Zero) > 0);
-            Assert.True(HeatFlux.Zero.CompareTo(wattpersquaremeter) < 0);
+            Assert.True(wattpersquaremeter.CompareTo(HeatFlux<double>.Zero) > 0);
+            Assert.True(HeatFlux<double>.Zero.CompareTo(wattpersquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            HeatFlux<double> wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
             Assert.Throws<ArgumentException>(() => wattpersquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            HeatFlux<double> wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
             Assert.Throws<ArgumentNullException>(() => wattpersquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = HeatFlux.FromWattsPerSquareMeter(1);
-            var b = HeatFlux.FromWattsPerSquareMeter(2);
+            var a = HeatFlux<double>.FromWattsPerSquareMeter(1);
+            var b = HeatFlux<double>.FromWattsPerSquareMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -485,8 +485,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = HeatFlux.FromWattsPerSquareMeter(1);
-            var b = HeatFlux.FromWattsPerSquareMeter(2);
+            var a = HeatFlux<double>.FromWattsPerSquareMeter(1);
+            var b = HeatFlux<double>.FromWattsPerSquareMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -506,9 +506,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = HeatFlux.FromWattsPerSquareMeter(1);
-            Assert.True(v.Equals(HeatFlux.FromWattsPerSquareMeter(1), WattsPerSquareMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(HeatFlux.Zero, WattsPerSquareMeterTolerance, ComparisonType.Relative));
+            var v = HeatFlux<double>.FromWattsPerSquareMeter(1);
+            Assert.True(v.Equals(HeatFlux<double>.FromWattsPerSquareMeter(1), WattsPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(HeatFlux<double>.Zero, WattsPerSquareMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -521,21 +521,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            HeatFlux<double> wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
             Assert.False(wattpersquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
+            HeatFlux<double> wattpersquaremeter = HeatFlux<double>.FromWattsPerSquareMeter(1);
             Assert.False(wattpersquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(HeatFluxUnit.Undefined, HeatFlux.Units);
+            Assert.DoesNotContain(HeatFluxUnit.Undefined, HeatFlux<double>.Units);
         }
 
         [Fact]
@@ -554,7 +554,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(HeatFlux.BaseDimensions is null);
+            Assert.False(HeatFlux<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs
index b1f85918d7..35133b127d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class HeatTransferCoefficientTestsBase : QuantityTestsBa
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient((double)0.0, HeatTransferCoefficientUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>((double)0.0, HeatTransferCoefficientUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient(double.PositiveInfinity, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
-            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient(double.NegativeInfinity, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>(double.PositiveInfinity, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>(double.NegativeInfinity, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient(double.NaN, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new HeatTransferCoefficient<double>(double.NaN, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void HeatTransferCoefficient_QuantityInfo_ReturnsQuantityInfoDescribingQu
         [Fact]
         public void WattPerSquareMeterKelvinToHeatTransferCoefficientUnits()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.BtusPerSquareFootDegreeFahrenheit, BtusPerSquareFootDegreeFahrenheitTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.WattsPerSquareMeterCelsius, WattsPerSquareMeterCelsiusTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterKelvinInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
@@ -127,15 +127,15 @@ public void WattPerSquareMeterKelvinToHeatTransferCoefficientUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = HeatTransferCoefficient.From(1, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
+            var quantity00 = HeatTransferCoefficient<double>.From(1, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
             AssertEx.EqualTolerance(1, quantity00.BtusPerSquareFootDegreeFahrenheit, BtusPerSquareFootDegreeFahrenheitTolerance);
             Assert.Equal(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, quantity00.Unit);
 
-            var quantity01 = HeatTransferCoefficient.From(1, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
+            var quantity01 = HeatTransferCoefficient<double>.From(1, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
             AssertEx.EqualTolerance(1, quantity01.WattsPerSquareMeterCelsius, WattsPerSquareMeterCelsiusTolerance);
             Assert.Equal(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, quantity01.Unit);
 
-            var quantity02 = HeatTransferCoefficient.From(1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
+            var quantity02 = HeatTransferCoefficient<double>.From(1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
             AssertEx.EqualTolerance(1, quantity02.WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
             Assert.Equal(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWattsPerSquareMeterKelvin_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWattsPerSquareMeterKelvin_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double.NaN));
+            Assert.Throws<ArgumentException>(() => HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            var wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit), BtusPerSquareFootDegreeFahrenheitTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius), WattsPerSquareMeterCelsiusTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterKelvinInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin), WattsPerSquareMeterKelvinTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            var wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
 
             var btupersquarefootdegreefahrenheitQuantity = wattpersquaremeterkelvin.ToUnit(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
             AssertEx.EqualTolerance(BtusPerSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, (double)btupersquarefootdegreefahrenheitQuantity.Value, BtusPerSquareFootDegreeFahrenheitTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(wattpersquaremeterkelvin.BtusPerSquareFootDegreeFahrenheit).WattsPerSquareMeterKelvin, BtusPerSquareFootDegreeFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(wattpersquaremeterkelvin.WattsPerSquareMeterCelsius).WattsPerSquareMeterKelvin, WattsPerSquareMeterCelsiusTolerance);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(wattpersquaremeterkelvin.WattsPerSquareMeterKelvin).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.FromBtusPerSquareFootDegreeFahrenheit(wattpersquaremeterkelvin.BtusPerSquareFootDegreeFahrenheit).WattsPerSquareMeterKelvin, BtusPerSquareFootDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.FromWattsPerSquareMeterCelsius(wattpersquaremeterkelvin.WattsPerSquareMeterCelsius).WattsPerSquareMeterKelvin, WattsPerSquareMeterCelsiusTolerance);
+            AssertEx.EqualTolerance(1, HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(wattpersquaremeterkelvin.WattsPerSquareMeterKelvin).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            HeatTransferCoefficient v = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> v = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             AssertEx.EqualTolerance(-1, -v.WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(3)-v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(3)-v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
             AssertEx.EqualTolerance(2, (v + v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
             AssertEx.EqualTolerance(10, (v*10).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
             AssertEx.EqualTolerance(10, (10*v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(10)/5).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(10)/HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(5), WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(10)/5).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(10)/HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(5), WattsPerSquareMeterKelvinTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            HeatTransferCoefficient oneWattPerSquareMeterKelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
-            HeatTransferCoefficient twoWattsPerSquareMeterKelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(2);
+            HeatTransferCoefficient<double> oneWattPerSquareMeterKelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> twoWattsPerSquareMeterKelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(2);
 
             Assert.True(oneWattPerSquareMeterKelvin < twoWattsPerSquareMeterKelvin);
             Assert.True(oneWattPerSquareMeterKelvin <= twoWattsPerSquareMeterKelvin);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             Assert.Equal(0, wattpersquaremeterkelvin.CompareTo(wattpersquaremeterkelvin));
-            Assert.True(wattpersquaremeterkelvin.CompareTo(HeatTransferCoefficient.Zero) > 0);
-            Assert.True(HeatTransferCoefficient.Zero.CompareTo(wattpersquaremeterkelvin) < 0);
+            Assert.True(wattpersquaremeterkelvin.CompareTo(HeatTransferCoefficient<double>.Zero) > 0);
+            Assert.True(HeatTransferCoefficient<double>.Zero.CompareTo(wattpersquaremeterkelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             Assert.Throws<ArgumentException>(() => wattpersquaremeterkelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             Assert.Throws<ArgumentNullException>(() => wattpersquaremeterkelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
-            var b = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(2);
+            var a = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            var b = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
-            var b = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(2);
+            var a = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            var b = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
-            Assert.True(v.Equals(HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1), WattsPerSquareMeterKelvinTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(HeatTransferCoefficient.Zero, WattsPerSquareMeterKelvinTolerance, ComparisonType.Relative));
+            var v = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
+            Assert.True(v.Equals(HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1), WattsPerSquareMeterKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(HeatTransferCoefficient<double>.Zero, WattsPerSquareMeterKelvinTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             Assert.False(wattpersquaremeterkelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
+            HeatTransferCoefficient<double> wattpersquaremeterkelvin = HeatTransferCoefficient<double>.FromWattsPerSquareMeterKelvin(1);
             Assert.False(wattpersquaremeterkelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(HeatTransferCoefficientUnit.Undefined, HeatTransferCoefficient.Units);
+            Assert.DoesNotContain(HeatTransferCoefficientUnit.Undefined, HeatTransferCoefficient<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(HeatTransferCoefficient.BaseDimensions is null);
+            Assert.False(HeatTransferCoefficient<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs
index 46a4e9d9a0..befbdc36ac 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class IlluminanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Illuminance((double)0.0, IlluminanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>((double)0.0, IlluminanceUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Illuminance(double.PositiveInfinity, IlluminanceUnit.Lux));
-            Assert.Throws<ArgumentException>(() => new Illuminance(double.NegativeInfinity, IlluminanceUnit.Lux));
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>(double.PositiveInfinity, IlluminanceUnit.Lux));
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>(double.NegativeInfinity, IlluminanceUnit.Lux));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Illuminance(double.NaN, IlluminanceUnit.Lux));
+            Assert.Throws<ArgumentException>(() => new Illuminance<double>(double.NaN, IlluminanceUnit.Lux));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void Illuminance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void LuxToIlluminanceUnits()
         {
-            Illuminance lux = Illuminance.FromLux(1);
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
             AssertEx.EqualTolerance(KiloluxInOneLux, lux.Kilolux, KiloluxTolerance);
             AssertEx.EqualTolerance(LuxInOneLux, lux.Lux, LuxTolerance);
             AssertEx.EqualTolerance(MegaluxInOneLux, lux.Megalux, MegaluxTolerance);
@@ -130,19 +130,19 @@ public void LuxToIlluminanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Illuminance.From(1, IlluminanceUnit.Kilolux);
+            var quantity00 = Illuminance<double>.From(1, IlluminanceUnit.Kilolux);
             AssertEx.EqualTolerance(1, quantity00.Kilolux, KiloluxTolerance);
             Assert.Equal(IlluminanceUnit.Kilolux, quantity00.Unit);
 
-            var quantity01 = Illuminance.From(1, IlluminanceUnit.Lux);
+            var quantity01 = Illuminance<double>.From(1, IlluminanceUnit.Lux);
             AssertEx.EqualTolerance(1, quantity01.Lux, LuxTolerance);
             Assert.Equal(IlluminanceUnit.Lux, quantity01.Unit);
 
-            var quantity02 = Illuminance.From(1, IlluminanceUnit.Megalux);
+            var quantity02 = Illuminance<double>.From(1, IlluminanceUnit.Megalux);
             AssertEx.EqualTolerance(1, quantity02.Megalux, MegaluxTolerance);
             Assert.Equal(IlluminanceUnit.Megalux, quantity02.Unit);
 
-            var quantity03 = Illuminance.From(1, IlluminanceUnit.Millilux);
+            var quantity03 = Illuminance<double>.From(1, IlluminanceUnit.Millilux);
             AssertEx.EqualTolerance(1, quantity03.Millilux, MilliluxTolerance);
             Assert.Equal(IlluminanceUnit.Millilux, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromLux_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Illuminance.FromLux(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Illuminance.FromLux(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Illuminance<double>.FromLux(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Illuminance<double>.FromLux(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromLux_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Illuminance.FromLux(double.NaN));
+            Assert.Throws<ArgumentException>(() => Illuminance<double>.FromLux(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var lux = Illuminance.FromLux(1);
+            var lux = Illuminance<double>.FromLux(1);
             AssertEx.EqualTolerance(KiloluxInOneLux, lux.As(IlluminanceUnit.Kilolux), KiloluxTolerance);
             AssertEx.EqualTolerance(LuxInOneLux, lux.As(IlluminanceUnit.Lux), LuxTolerance);
             AssertEx.EqualTolerance(MegaluxInOneLux, lux.As(IlluminanceUnit.Megalux), MegaluxTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var lux = Illuminance.FromLux(1);
+            var lux = Illuminance<double>.FromLux(1);
 
             var kiloluxQuantity = lux.ToUnit(IlluminanceUnit.Kilolux);
             AssertEx.EqualTolerance(KiloluxInOneLux, (double)kiloluxQuantity.Value, KiloluxTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Illuminance lux = Illuminance.FromLux(1);
-            AssertEx.EqualTolerance(1, Illuminance.FromKilolux(lux.Kilolux).Lux, KiloluxTolerance);
-            AssertEx.EqualTolerance(1, Illuminance.FromLux(lux.Lux).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(1, Illuminance.FromMegalux(lux.Megalux).Lux, MegaluxTolerance);
-            AssertEx.EqualTolerance(1, Illuminance.FromMillilux(lux.Millilux).Lux, MilliluxTolerance);
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromKilolux(lux.Kilolux).Lux, KiloluxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromLux(lux.Lux).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromMegalux(lux.Megalux).Lux, MegaluxTolerance);
+            AssertEx.EqualTolerance(1, Illuminance<double>.FromMillilux(lux.Millilux).Lux, MilliluxTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Illuminance v = Illuminance.FromLux(1);
+            Illuminance<double> v = Illuminance<double>.FromLux(1);
             AssertEx.EqualTolerance(-1, -v.Lux, LuxTolerance);
-            AssertEx.EqualTolerance(2, (Illuminance.FromLux(3)-v).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(2, (Illuminance<double>.FromLux(3)-v).Lux, LuxTolerance);
             AssertEx.EqualTolerance(2, (v + v).Lux, LuxTolerance);
             AssertEx.EqualTolerance(10, (v*10).Lux, LuxTolerance);
             AssertEx.EqualTolerance(10, (10*v).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(2, (Illuminance.FromLux(10)/5).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(2, Illuminance.FromLux(10)/Illuminance.FromLux(5), LuxTolerance);
+            AssertEx.EqualTolerance(2, (Illuminance<double>.FromLux(10)/5).Lux, LuxTolerance);
+            AssertEx.EqualTolerance(2, Illuminance<double>.FromLux(10)/Illuminance<double>.FromLux(5), LuxTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Illuminance oneLux = Illuminance.FromLux(1);
-            Illuminance twoLux = Illuminance.FromLux(2);
+            Illuminance<double> oneLux = Illuminance<double>.FromLux(1);
+            Illuminance<double> twoLux = Illuminance<double>.FromLux(2);
 
             Assert.True(oneLux < twoLux);
             Assert.True(oneLux <= twoLux);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Illuminance lux = Illuminance.FromLux(1);
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
             Assert.Equal(0, lux.CompareTo(lux));
-            Assert.True(lux.CompareTo(Illuminance.Zero) > 0);
-            Assert.True(Illuminance.Zero.CompareTo(lux) < 0);
+            Assert.True(lux.CompareTo(Illuminance<double>.Zero) > 0);
+            Assert.True(Illuminance<double>.Zero.CompareTo(lux) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Illuminance lux = Illuminance.FromLux(1);
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
             Assert.Throws<ArgumentException>(() => lux.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Illuminance lux = Illuminance.FromLux(1);
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
             Assert.Throws<ArgumentNullException>(() => lux.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Illuminance.FromLux(1);
-            var b = Illuminance.FromLux(2);
+            var a = Illuminance<double>.FromLux(1);
+            var b = Illuminance<double>.FromLux(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Illuminance.FromLux(1);
-            var b = Illuminance.FromLux(2);
+            var a = Illuminance<double>.FromLux(1);
+            var b = Illuminance<double>.FromLux(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Illuminance.FromLux(1);
-            Assert.True(v.Equals(Illuminance.FromLux(1), LuxTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Illuminance.Zero, LuxTolerance, ComparisonType.Relative));
+            var v = Illuminance<double>.FromLux(1);
+            Assert.True(v.Equals(Illuminance<double>.FromLux(1), LuxTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Illuminance<double>.Zero, LuxTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Illuminance lux = Illuminance.FromLux(1);
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
             Assert.False(lux.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Illuminance lux = Illuminance.FromLux(1);
+            Illuminance<double> lux = Illuminance<double>.FromLux(1);
             Assert.False(lux.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(IlluminanceUnit.Undefined, Illuminance.Units);
+            Assert.DoesNotContain(IlluminanceUnit.Undefined, Illuminance<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Illuminance.BaseDimensions is null);
+            Assert.False(Illuminance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs
index 792be447fa..0df9e6432b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs
@@ -96,7 +96,7 @@ public abstract partial class InformationTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Information((decimal)0.0, InformationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Information<double>((decimal)0.0, InformationUnit.Undefined));
         }
 
         [Fact]
@@ -152,7 +152,7 @@ public void Information_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void BitToInformationUnits()
         {
-            Information bit = Information.FromBits(1);
+            Information<double> bit = Information<double>.FromBits(1);
             AssertEx.EqualTolerance(BitsInOneBit, bit.Bits, BitsTolerance);
             AssertEx.EqualTolerance(BytesInOneBit, bit.Bytes, BytesTolerance);
             AssertEx.EqualTolerance(ExabitsInOneBit, bit.Exabits, ExabitsTolerance);
@@ -184,107 +184,107 @@ public void BitToInformationUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Information.From(1, InformationUnit.Bit);
+            var quantity00 = Information<double>.From(1, InformationUnit.Bit);
             AssertEx.EqualTolerance(1, quantity00.Bits, BitsTolerance);
             Assert.Equal(InformationUnit.Bit, quantity00.Unit);
 
-            var quantity01 = Information.From(1, InformationUnit.Byte);
+            var quantity01 = Information<double>.From(1, InformationUnit.Byte);
             AssertEx.EqualTolerance(1, quantity01.Bytes, BytesTolerance);
             Assert.Equal(InformationUnit.Byte, quantity01.Unit);
 
-            var quantity02 = Information.From(1, InformationUnit.Exabit);
+            var quantity02 = Information<double>.From(1, InformationUnit.Exabit);
             AssertEx.EqualTolerance(1, quantity02.Exabits, ExabitsTolerance);
             Assert.Equal(InformationUnit.Exabit, quantity02.Unit);
 
-            var quantity03 = Information.From(1, InformationUnit.Exabyte);
+            var quantity03 = Information<double>.From(1, InformationUnit.Exabyte);
             AssertEx.EqualTolerance(1, quantity03.Exabytes, ExabytesTolerance);
             Assert.Equal(InformationUnit.Exabyte, quantity03.Unit);
 
-            var quantity04 = Information.From(1, InformationUnit.Exbibit);
+            var quantity04 = Information<double>.From(1, InformationUnit.Exbibit);
             AssertEx.EqualTolerance(1, quantity04.Exbibits, ExbibitsTolerance);
             Assert.Equal(InformationUnit.Exbibit, quantity04.Unit);
 
-            var quantity05 = Information.From(1, InformationUnit.Exbibyte);
+            var quantity05 = Information<double>.From(1, InformationUnit.Exbibyte);
             AssertEx.EqualTolerance(1, quantity05.Exbibytes, ExbibytesTolerance);
             Assert.Equal(InformationUnit.Exbibyte, quantity05.Unit);
 
-            var quantity06 = Information.From(1, InformationUnit.Gibibit);
+            var quantity06 = Information<double>.From(1, InformationUnit.Gibibit);
             AssertEx.EqualTolerance(1, quantity06.Gibibits, GibibitsTolerance);
             Assert.Equal(InformationUnit.Gibibit, quantity06.Unit);
 
-            var quantity07 = Information.From(1, InformationUnit.Gibibyte);
+            var quantity07 = Information<double>.From(1, InformationUnit.Gibibyte);
             AssertEx.EqualTolerance(1, quantity07.Gibibytes, GibibytesTolerance);
             Assert.Equal(InformationUnit.Gibibyte, quantity07.Unit);
 
-            var quantity08 = Information.From(1, InformationUnit.Gigabit);
+            var quantity08 = Information<double>.From(1, InformationUnit.Gigabit);
             AssertEx.EqualTolerance(1, quantity08.Gigabits, GigabitsTolerance);
             Assert.Equal(InformationUnit.Gigabit, quantity08.Unit);
 
-            var quantity09 = Information.From(1, InformationUnit.Gigabyte);
+            var quantity09 = Information<double>.From(1, InformationUnit.Gigabyte);
             AssertEx.EqualTolerance(1, quantity09.Gigabytes, GigabytesTolerance);
             Assert.Equal(InformationUnit.Gigabyte, quantity09.Unit);
 
-            var quantity10 = Information.From(1, InformationUnit.Kibibit);
+            var quantity10 = Information<double>.From(1, InformationUnit.Kibibit);
             AssertEx.EqualTolerance(1, quantity10.Kibibits, KibibitsTolerance);
             Assert.Equal(InformationUnit.Kibibit, quantity10.Unit);
 
-            var quantity11 = Information.From(1, InformationUnit.Kibibyte);
+            var quantity11 = Information<double>.From(1, InformationUnit.Kibibyte);
             AssertEx.EqualTolerance(1, quantity11.Kibibytes, KibibytesTolerance);
             Assert.Equal(InformationUnit.Kibibyte, quantity11.Unit);
 
-            var quantity12 = Information.From(1, InformationUnit.Kilobit);
+            var quantity12 = Information<double>.From(1, InformationUnit.Kilobit);
             AssertEx.EqualTolerance(1, quantity12.Kilobits, KilobitsTolerance);
             Assert.Equal(InformationUnit.Kilobit, quantity12.Unit);
 
-            var quantity13 = Information.From(1, InformationUnit.Kilobyte);
+            var quantity13 = Information<double>.From(1, InformationUnit.Kilobyte);
             AssertEx.EqualTolerance(1, quantity13.Kilobytes, KilobytesTolerance);
             Assert.Equal(InformationUnit.Kilobyte, quantity13.Unit);
 
-            var quantity14 = Information.From(1, InformationUnit.Mebibit);
+            var quantity14 = Information<double>.From(1, InformationUnit.Mebibit);
             AssertEx.EqualTolerance(1, quantity14.Mebibits, MebibitsTolerance);
             Assert.Equal(InformationUnit.Mebibit, quantity14.Unit);
 
-            var quantity15 = Information.From(1, InformationUnit.Mebibyte);
+            var quantity15 = Information<double>.From(1, InformationUnit.Mebibyte);
             AssertEx.EqualTolerance(1, quantity15.Mebibytes, MebibytesTolerance);
             Assert.Equal(InformationUnit.Mebibyte, quantity15.Unit);
 
-            var quantity16 = Information.From(1, InformationUnit.Megabit);
+            var quantity16 = Information<double>.From(1, InformationUnit.Megabit);
             AssertEx.EqualTolerance(1, quantity16.Megabits, MegabitsTolerance);
             Assert.Equal(InformationUnit.Megabit, quantity16.Unit);
 
-            var quantity17 = Information.From(1, InformationUnit.Megabyte);
+            var quantity17 = Information<double>.From(1, InformationUnit.Megabyte);
             AssertEx.EqualTolerance(1, quantity17.Megabytes, MegabytesTolerance);
             Assert.Equal(InformationUnit.Megabyte, quantity17.Unit);
 
-            var quantity18 = Information.From(1, InformationUnit.Pebibit);
+            var quantity18 = Information<double>.From(1, InformationUnit.Pebibit);
             AssertEx.EqualTolerance(1, quantity18.Pebibits, PebibitsTolerance);
             Assert.Equal(InformationUnit.Pebibit, quantity18.Unit);
 
-            var quantity19 = Information.From(1, InformationUnit.Pebibyte);
+            var quantity19 = Information<double>.From(1, InformationUnit.Pebibyte);
             AssertEx.EqualTolerance(1, quantity19.Pebibytes, PebibytesTolerance);
             Assert.Equal(InformationUnit.Pebibyte, quantity19.Unit);
 
-            var quantity20 = Information.From(1, InformationUnit.Petabit);
+            var quantity20 = Information<double>.From(1, InformationUnit.Petabit);
             AssertEx.EqualTolerance(1, quantity20.Petabits, PetabitsTolerance);
             Assert.Equal(InformationUnit.Petabit, quantity20.Unit);
 
-            var quantity21 = Information.From(1, InformationUnit.Petabyte);
+            var quantity21 = Information<double>.From(1, InformationUnit.Petabyte);
             AssertEx.EqualTolerance(1, quantity21.Petabytes, PetabytesTolerance);
             Assert.Equal(InformationUnit.Petabyte, quantity21.Unit);
 
-            var quantity22 = Information.From(1, InformationUnit.Tebibit);
+            var quantity22 = Information<double>.From(1, InformationUnit.Tebibit);
             AssertEx.EqualTolerance(1, quantity22.Tebibits, TebibitsTolerance);
             Assert.Equal(InformationUnit.Tebibit, quantity22.Unit);
 
-            var quantity23 = Information.From(1, InformationUnit.Tebibyte);
+            var quantity23 = Information<double>.From(1, InformationUnit.Tebibyte);
             AssertEx.EqualTolerance(1, quantity23.Tebibytes, TebibytesTolerance);
             Assert.Equal(InformationUnit.Tebibyte, quantity23.Unit);
 
-            var quantity24 = Information.From(1, InformationUnit.Terabit);
+            var quantity24 = Information<double>.From(1, InformationUnit.Terabit);
             AssertEx.EqualTolerance(1, quantity24.Terabits, TerabitsTolerance);
             Assert.Equal(InformationUnit.Terabit, quantity24.Unit);
 
-            var quantity25 = Information.From(1, InformationUnit.Terabyte);
+            var quantity25 = Information<double>.From(1, InformationUnit.Terabyte);
             AssertEx.EqualTolerance(1, quantity25.Terabytes, TerabytesTolerance);
             Assert.Equal(InformationUnit.Terabyte, quantity25.Unit);
 
@@ -293,7 +293,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void As()
         {
-            var bit = Information.FromBits(1);
+            var bit = Information<double>.FromBits(1);
             AssertEx.EqualTolerance(BitsInOneBit, bit.As(InformationUnit.Bit), BitsTolerance);
             AssertEx.EqualTolerance(BytesInOneBit, bit.As(InformationUnit.Byte), BytesTolerance);
             AssertEx.EqualTolerance(ExabitsInOneBit, bit.As(InformationUnit.Exabit), ExabitsTolerance);
@@ -342,7 +342,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var bit = Information.FromBits(1);
+            var bit = Information<double>.FromBits(1);
 
             var bitQuantity = bit.ToUnit(InformationUnit.Bit);
             AssertEx.EqualTolerance(BitsInOneBit, (double)bitQuantity.Value, BitsTolerance);
@@ -459,53 +459,53 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Information bit = Information.FromBits(1);
-            AssertEx.EqualTolerance(1, Information.FromBits(bit.Bits).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromBytes(bit.Bytes).Bits, BytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExabits(bit.Exabits).Bits, ExabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExabytes(bit.Exabytes).Bits, ExabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExbibits(bit.Exbibits).Bits, ExbibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExbibytes(bit.Exbibytes).Bits, ExbibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGibibits(bit.Gibibits).Bits, GibibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGibibytes(bit.Gibibytes).Bits, GibibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGigabits(bit.Gigabits).Bits, GigabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGigabytes(bit.Gigabytes).Bits, GigabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKibibits(bit.Kibibits).Bits, KibibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKibibytes(bit.Kibibytes).Bits, KibibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKilobits(bit.Kilobits).Bits, KilobitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKilobytes(bit.Kilobytes).Bits, KilobytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMebibits(bit.Mebibits).Bits, MebibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMebibytes(bit.Mebibytes).Bits, MebibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMegabits(bit.Megabits).Bits, MegabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMegabytes(bit.Megabytes).Bits, MegabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPebibits(bit.Pebibits).Bits, PebibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPebibytes(bit.Pebibytes).Bits, PebibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPetabits(bit.Petabits).Bits, PetabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPetabytes(bit.Petabytes).Bits, PetabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTebibits(bit.Tebibits).Bits, TebibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTebibytes(bit.Tebibytes).Bits, TebibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTerabits(bit.Terabits).Bits, TerabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTerabytes(bit.Terabytes).Bits, TerabytesTolerance);
+            Information<double> bit = Information<double>.FromBits(1);
+            AssertEx.EqualTolerance(1, Information<double>.FromBits(bit.Bits).Bits, BitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromBytes(bit.Bytes).Bits, BytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromExabits(bit.Exabits).Bits, ExabitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromExabytes(bit.Exabytes).Bits, ExabytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromExbibits(bit.Exbibits).Bits, ExbibitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromExbibytes(bit.Exbibytes).Bits, ExbibytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromGibibits(bit.Gibibits).Bits, GibibitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromGibibytes(bit.Gibibytes).Bits, GibibytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromGigabits(bit.Gigabits).Bits, GigabitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromGigabytes(bit.Gigabytes).Bits, GigabytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromKibibits(bit.Kibibits).Bits, KibibitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromKibibytes(bit.Kibibytes).Bits, KibibytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromKilobits(bit.Kilobits).Bits, KilobitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromKilobytes(bit.Kilobytes).Bits, KilobytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromMebibits(bit.Mebibits).Bits, MebibitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromMebibytes(bit.Mebibytes).Bits, MebibytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromMegabits(bit.Megabits).Bits, MegabitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromMegabytes(bit.Megabytes).Bits, MegabytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromPebibits(bit.Pebibits).Bits, PebibitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromPebibytes(bit.Pebibytes).Bits, PebibytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromPetabits(bit.Petabits).Bits, PetabitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromPetabytes(bit.Petabytes).Bits, PetabytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromTebibits(bit.Tebibits).Bits, TebibitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromTebibytes(bit.Tebibytes).Bits, TebibytesTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromTerabits(bit.Terabits).Bits, TerabitsTolerance);
+            AssertEx.EqualTolerance(1, Information<double>.FromTerabytes(bit.Terabytes).Bits, TerabytesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Information v = Information.FromBits(1);
+            Information<double> v = Information<double>.FromBits(1);
             AssertEx.EqualTolerance(-1, -v.Bits, BitsTolerance);
-            AssertEx.EqualTolerance(2, (Information.FromBits(3)-v).Bits, BitsTolerance);
+            AssertEx.EqualTolerance(2, (Information<double>.FromBits(3)-v).Bits, BitsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Bits, BitsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Bits, BitsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(2, (Information.FromBits(10)/5).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(2, Information.FromBits(10)/Information.FromBits(5), BitsTolerance);
+            AssertEx.EqualTolerance(2, (Information<double>.FromBits(10)/5).Bits, BitsTolerance);
+            AssertEx.EqualTolerance(2, Information<double>.FromBits(10)/Information<double>.FromBits(5), BitsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Information oneBit = Information.FromBits(1);
-            Information twoBits = Information.FromBits(2);
+            Information<double> oneBit = Information<double>.FromBits(1);
+            Information<double> twoBits = Information<double>.FromBits(2);
 
             Assert.True(oneBit < twoBits);
             Assert.True(oneBit <= twoBits);
@@ -521,31 +521,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Information bit = Information.FromBits(1);
+            Information<double> bit = Information<double>.FromBits(1);
             Assert.Equal(0, bit.CompareTo(bit));
-            Assert.True(bit.CompareTo(Information.Zero) > 0);
-            Assert.True(Information.Zero.CompareTo(bit) < 0);
+            Assert.True(bit.CompareTo(Information<double>.Zero) > 0);
+            Assert.True(Information<double>.Zero.CompareTo(bit) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Information bit = Information.FromBits(1);
+            Information<double> bit = Information<double>.FromBits(1);
             Assert.Throws<ArgumentException>(() => bit.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Information bit = Information.FromBits(1);
+            Information<double> bit = Information<double>.FromBits(1);
             Assert.Throws<ArgumentNullException>(() => bit.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Information.FromBits(1);
-            var b = Information.FromBits(2);
+            var a = Information<double>.FromBits(1);
+            var b = Information<double>.FromBits(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -564,8 +564,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Information.FromBits(1);
-            var b = Information.FromBits(2);
+            var a = Information<double>.FromBits(1);
+            var b = Information<double>.FromBits(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -585,9 +585,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Information.FromBits(1);
-            Assert.True(v.Equals(Information.FromBits(1), BitsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Information.Zero, BitsTolerance, ComparisonType.Relative));
+            var v = Information<double>.FromBits(1);
+            Assert.True(v.Equals(Information<double>.FromBits(1), BitsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Information<double>.Zero, BitsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -600,21 +600,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Information bit = Information.FromBits(1);
+            Information<double> bit = Information<double>.FromBits(1);
             Assert.False(bit.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Information bit = Information.FromBits(1);
+            Information<double> bit = Information<double>.FromBits(1);
             Assert.False(bit.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(InformationUnit.Undefined, Information.Units);
+            Assert.DoesNotContain(InformationUnit.Undefined, Information<double>.Units);
         }
 
         [Fact]
@@ -633,7 +633,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Information.BaseDimensions is null);
+            Assert.False(Information<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs
index 4013a7bdeb..8a357db41c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs
@@ -72,7 +72,7 @@ public abstract partial class IrradianceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Irradiance((double)0.0, IrradianceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Irradiance<double>((double)0.0, IrradianceUnit.Undefined));
         }
 
         [Fact]
@@ -87,14 +87,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Irradiance(double.PositiveInfinity, IrradianceUnit.WattPerSquareMeter));
-            Assert.Throws<ArgumentException>(() => new Irradiance(double.NegativeInfinity, IrradianceUnit.WattPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new Irradiance<double>(double.PositiveInfinity, IrradianceUnit.WattPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new Irradiance<double>(double.NegativeInfinity, IrradianceUnit.WattPerSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Irradiance(double.NaN, IrradianceUnit.WattPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new Irradiance<double>(double.NaN, IrradianceUnit.WattPerSquareMeter));
         }
 
         [Fact]
@@ -140,7 +140,7 @@ public void Irradiance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void WattPerSquareMeterToIrradianceUnits()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            Irradiance<double> wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
             AssertEx.EqualTolerance(KilowattsPerSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.KilowattsPerSquareCentimeter, KilowattsPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(KilowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.KilowattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(MegawattsPerSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.MegawattsPerSquareCentimeter, MegawattsPerSquareCentimeterTolerance);
@@ -160,59 +160,59 @@ public void WattPerSquareMeterToIrradianceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Irradiance.From(1, IrradianceUnit.KilowattPerSquareCentimeter);
+            var quantity00 = Irradiance<double>.From(1, IrradianceUnit.KilowattPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity00.KilowattsPerSquareCentimeter, KilowattsPerSquareCentimeterTolerance);
             Assert.Equal(IrradianceUnit.KilowattPerSquareCentimeter, quantity00.Unit);
 
-            var quantity01 = Irradiance.From(1, IrradianceUnit.KilowattPerSquareMeter);
+            var quantity01 = Irradiance<double>.From(1, IrradianceUnit.KilowattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity01.KilowattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
             Assert.Equal(IrradianceUnit.KilowattPerSquareMeter, quantity01.Unit);
 
-            var quantity02 = Irradiance.From(1, IrradianceUnit.MegawattPerSquareCentimeter);
+            var quantity02 = Irradiance<double>.From(1, IrradianceUnit.MegawattPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity02.MegawattsPerSquareCentimeter, MegawattsPerSquareCentimeterTolerance);
             Assert.Equal(IrradianceUnit.MegawattPerSquareCentimeter, quantity02.Unit);
 
-            var quantity03 = Irradiance.From(1, IrradianceUnit.MegawattPerSquareMeter);
+            var quantity03 = Irradiance<double>.From(1, IrradianceUnit.MegawattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity03.MegawattsPerSquareMeter, MegawattsPerSquareMeterTolerance);
             Assert.Equal(IrradianceUnit.MegawattPerSquareMeter, quantity03.Unit);
 
-            var quantity04 = Irradiance.From(1, IrradianceUnit.MicrowattPerSquareCentimeter);
+            var quantity04 = Irradiance<double>.From(1, IrradianceUnit.MicrowattPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity04.MicrowattsPerSquareCentimeter, MicrowattsPerSquareCentimeterTolerance);
             Assert.Equal(IrradianceUnit.MicrowattPerSquareCentimeter, quantity04.Unit);
 
-            var quantity05 = Irradiance.From(1, IrradianceUnit.MicrowattPerSquareMeter);
+            var quantity05 = Irradiance<double>.From(1, IrradianceUnit.MicrowattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity05.MicrowattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
             Assert.Equal(IrradianceUnit.MicrowattPerSquareMeter, quantity05.Unit);
 
-            var quantity06 = Irradiance.From(1, IrradianceUnit.MilliwattPerSquareCentimeter);
+            var quantity06 = Irradiance<double>.From(1, IrradianceUnit.MilliwattPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity06.MilliwattsPerSquareCentimeter, MilliwattsPerSquareCentimeterTolerance);
             Assert.Equal(IrradianceUnit.MilliwattPerSquareCentimeter, quantity06.Unit);
 
-            var quantity07 = Irradiance.From(1, IrradianceUnit.MilliwattPerSquareMeter);
+            var quantity07 = Irradiance<double>.From(1, IrradianceUnit.MilliwattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity07.MilliwattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
             Assert.Equal(IrradianceUnit.MilliwattPerSquareMeter, quantity07.Unit);
 
-            var quantity08 = Irradiance.From(1, IrradianceUnit.NanowattPerSquareCentimeter);
+            var quantity08 = Irradiance<double>.From(1, IrradianceUnit.NanowattPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity08.NanowattsPerSquareCentimeter, NanowattsPerSquareCentimeterTolerance);
             Assert.Equal(IrradianceUnit.NanowattPerSquareCentimeter, quantity08.Unit);
 
-            var quantity09 = Irradiance.From(1, IrradianceUnit.NanowattPerSquareMeter);
+            var quantity09 = Irradiance<double>.From(1, IrradianceUnit.NanowattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity09.NanowattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
             Assert.Equal(IrradianceUnit.NanowattPerSquareMeter, quantity09.Unit);
 
-            var quantity10 = Irradiance.From(1, IrradianceUnit.PicowattPerSquareCentimeter);
+            var quantity10 = Irradiance<double>.From(1, IrradianceUnit.PicowattPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity10.PicowattsPerSquareCentimeter, PicowattsPerSquareCentimeterTolerance);
             Assert.Equal(IrradianceUnit.PicowattPerSquareCentimeter, quantity10.Unit);
 
-            var quantity11 = Irradiance.From(1, IrradianceUnit.PicowattPerSquareMeter);
+            var quantity11 = Irradiance<double>.From(1, IrradianceUnit.PicowattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity11.PicowattsPerSquareMeter, PicowattsPerSquareMeterTolerance);
             Assert.Equal(IrradianceUnit.PicowattPerSquareMeter, quantity11.Unit);
 
-            var quantity12 = Irradiance.From(1, IrradianceUnit.WattPerSquareCentimeter);
+            var quantity12 = Irradiance<double>.From(1, IrradianceUnit.WattPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity12.WattsPerSquareCentimeter, WattsPerSquareCentimeterTolerance);
             Assert.Equal(IrradianceUnit.WattPerSquareCentimeter, quantity12.Unit);
 
-            var quantity13 = Irradiance.From(1, IrradianceUnit.WattPerSquareMeter);
+            var quantity13 = Irradiance<double>.From(1, IrradianceUnit.WattPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity13.WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             Assert.Equal(IrradianceUnit.WattPerSquareMeter, quantity13.Unit);
 
@@ -221,20 +221,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWattsPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Irradiance.FromWattsPerSquareMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Irradiance.FromWattsPerSquareMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Irradiance<double>.FromWattsPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Irradiance<double>.FromWattsPerSquareMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWattsPerSquareMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Irradiance.FromWattsPerSquareMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => Irradiance<double>.FromWattsPerSquareMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            var wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
             AssertEx.EqualTolerance(KilowattsPerSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.As(IrradianceUnit.KilowattPerSquareCentimeter), KilowattsPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(KilowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(IrradianceUnit.KilowattPerSquareMeter), KilowattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(MegawattsPerSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.As(IrradianceUnit.MegawattPerSquareCentimeter), MegawattsPerSquareCentimeterTolerance);
@@ -271,7 +271,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            var wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
 
             var kilowattpersquarecentimeterQuantity = wattpersquaremeter.ToUnit(IrradianceUnit.KilowattPerSquareCentimeter);
             AssertEx.EqualTolerance(KilowattsPerSquareCentimeterInOneWattPerSquareMeter, (double)kilowattpersquarecentimeterQuantity.Value, KilowattsPerSquareCentimeterTolerance);
@@ -340,41 +340,41 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, Irradiance.FromKilowattsPerSquareCentimeter(wattpersquaremeter.KilowattsPerSquareCentimeter).WattsPerSquareMeter, KilowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMegawattsPerSquareCentimeter(wattpersquaremeter.MegawattsPerSquareCentimeter).WattsPerSquareMeter, MegawattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMegawattsPerSquareMeter(wattpersquaremeter.MegawattsPerSquareMeter).WattsPerSquareMeter, MegawattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMicrowattsPerSquareCentimeter(wattpersquaremeter.MicrowattsPerSquareCentimeter).WattsPerSquareMeter, MicrowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMilliwattsPerSquareCentimeter(wattpersquaremeter.MilliwattsPerSquareCentimeter).WattsPerSquareMeter, MilliwattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromNanowattsPerSquareCentimeter(wattpersquaremeter.NanowattsPerSquareCentimeter).WattsPerSquareMeter, NanowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromPicowattsPerSquareCentimeter(wattpersquaremeter.PicowattsPerSquareCentimeter).WattsPerSquareMeter, PicowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromPicowattsPerSquareMeter(wattpersquaremeter.PicowattsPerSquareMeter).WattsPerSquareMeter, PicowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromWattsPerSquareCentimeter(wattpersquaremeter.WattsPerSquareCentimeter).WattsPerSquareMeter, WattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            Irradiance<double> wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromKilowattsPerSquareCentimeter(wattpersquaremeter.KilowattsPerSquareCentimeter).WattsPerSquareMeter, KilowattsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromMegawattsPerSquareCentimeter(wattpersquaremeter.MegawattsPerSquareCentimeter).WattsPerSquareMeter, MegawattsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromMegawattsPerSquareMeter(wattpersquaremeter.MegawattsPerSquareMeter).WattsPerSquareMeter, MegawattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromMicrowattsPerSquareCentimeter(wattpersquaremeter.MicrowattsPerSquareCentimeter).WattsPerSquareMeter, MicrowattsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromMilliwattsPerSquareCentimeter(wattpersquaremeter.MilliwattsPerSquareCentimeter).WattsPerSquareMeter, MilliwattsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromNanowattsPerSquareCentimeter(wattpersquaremeter.NanowattsPerSquareCentimeter).WattsPerSquareMeter, NanowattsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromPicowattsPerSquareCentimeter(wattpersquaremeter.PicowattsPerSquareCentimeter).WattsPerSquareMeter, PicowattsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromPicowattsPerSquareMeter(wattpersquaremeter.PicowattsPerSquareMeter).WattsPerSquareMeter, PicowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromWattsPerSquareCentimeter(wattpersquaremeter.WattsPerSquareCentimeter).WattsPerSquareMeter, WattsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiance<double>.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Irradiance v = Irradiance.FromWattsPerSquareMeter(1);
+            Irradiance<double> v = Irradiance<double>.FromWattsPerSquareMeter(1);
             AssertEx.EqualTolerance(-1, -v.WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiance.FromWattsPerSquareMeter(3)-v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (Irradiance<double>.FromWattsPerSquareMeter(3)-v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiance.FromWattsPerSquareMeter(10)/5).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, Irradiance.FromWattsPerSquareMeter(10)/Irradiance.FromWattsPerSquareMeter(5), WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (Irradiance<double>.FromWattsPerSquareMeter(10)/5).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, Irradiance<double>.FromWattsPerSquareMeter(10)/Irradiance<double>.FromWattsPerSquareMeter(5), WattsPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Irradiance oneWattPerSquareMeter = Irradiance.FromWattsPerSquareMeter(1);
-            Irradiance twoWattsPerSquareMeter = Irradiance.FromWattsPerSquareMeter(2);
+            Irradiance<double> oneWattPerSquareMeter = Irradiance<double>.FromWattsPerSquareMeter(1);
+            Irradiance<double> twoWattsPerSquareMeter = Irradiance<double>.FromWattsPerSquareMeter(2);
 
             Assert.True(oneWattPerSquareMeter < twoWattsPerSquareMeter);
             Assert.True(oneWattPerSquareMeter <= twoWattsPerSquareMeter);
@@ -390,31 +390,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            Irradiance<double> wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
             Assert.Equal(0, wattpersquaremeter.CompareTo(wattpersquaremeter));
-            Assert.True(wattpersquaremeter.CompareTo(Irradiance.Zero) > 0);
-            Assert.True(Irradiance.Zero.CompareTo(wattpersquaremeter) < 0);
+            Assert.True(wattpersquaremeter.CompareTo(Irradiance<double>.Zero) > 0);
+            Assert.True(Irradiance<double>.Zero.CompareTo(wattpersquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            Irradiance<double> wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
             Assert.Throws<ArgumentException>(() => wattpersquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            Irradiance<double> wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
             Assert.Throws<ArgumentNullException>(() => wattpersquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Irradiance.FromWattsPerSquareMeter(1);
-            var b = Irradiance.FromWattsPerSquareMeter(2);
+            var a = Irradiance<double>.FromWattsPerSquareMeter(1);
+            var b = Irradiance<double>.FromWattsPerSquareMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -433,8 +433,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Irradiance.FromWattsPerSquareMeter(1);
-            var b = Irradiance.FromWattsPerSquareMeter(2);
+            var a = Irradiance<double>.FromWattsPerSquareMeter(1);
+            var b = Irradiance<double>.FromWattsPerSquareMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -454,9 +454,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Irradiance.FromWattsPerSquareMeter(1);
-            Assert.True(v.Equals(Irradiance.FromWattsPerSquareMeter(1), WattsPerSquareMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Irradiance.Zero, WattsPerSquareMeterTolerance, ComparisonType.Relative));
+            var v = Irradiance<double>.FromWattsPerSquareMeter(1);
+            Assert.True(v.Equals(Irradiance<double>.FromWattsPerSquareMeter(1), WattsPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Irradiance<double>.Zero, WattsPerSquareMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -469,21 +469,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            Irradiance<double> wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
             Assert.False(wattpersquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
+            Irradiance<double> wattpersquaremeter = Irradiance<double>.FromWattsPerSquareMeter(1);
             Assert.False(wattpersquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(IrradianceUnit.Undefined, Irradiance.Units);
+            Assert.DoesNotContain(IrradianceUnit.Undefined, Irradiance<double>.Units);
         }
 
         [Fact]
@@ -502,7 +502,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Irradiance.BaseDimensions is null);
+            Assert.False(Irradiance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs
index b3ff06e565..cce768d778 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs
@@ -58,7 +58,7 @@ public abstract partial class IrradiationTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Irradiation((double)0.0, IrradiationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Irradiation<double>((double)0.0, IrradiationUnit.Undefined));
         }
 
         [Fact]
@@ -73,14 +73,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Irradiation(double.PositiveInfinity, IrradiationUnit.JoulePerSquareMeter));
-            Assert.Throws<ArgumentException>(() => new Irradiation(double.NegativeInfinity, IrradiationUnit.JoulePerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new Irradiation<double>(double.PositiveInfinity, IrradiationUnit.JoulePerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new Irradiation<double>(double.NegativeInfinity, IrradiationUnit.JoulePerSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Irradiation(double.NaN, IrradiationUnit.JoulePerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new Irradiation<double>(double.NaN, IrradiationUnit.JoulePerSquareMeter));
         }
 
         [Fact]
@@ -126,7 +126,7 @@ public void Irradiation_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void JoulePerSquareMeterToIrradiationUnits()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            Irradiation<double> joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
             AssertEx.EqualTolerance(JoulesPerSquareCentimeterInOneJoulePerSquareMeter, joulepersquaremeter.JoulesPerSquareCentimeter, JoulesPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(JoulesPerSquareMeterInOneJoulePerSquareMeter, joulepersquaremeter.JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(JoulesPerSquareMillimeterInOneJoulePerSquareMeter, joulepersquaremeter.JoulesPerSquareMillimeter, JoulesPerSquareMillimeterTolerance);
@@ -139,31 +139,31 @@ public void JoulePerSquareMeterToIrradiationUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Irradiation.From(1, IrradiationUnit.JoulePerSquareCentimeter);
+            var quantity00 = Irradiation<double>.From(1, IrradiationUnit.JoulePerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity00.JoulesPerSquareCentimeter, JoulesPerSquareCentimeterTolerance);
             Assert.Equal(IrradiationUnit.JoulePerSquareCentimeter, quantity00.Unit);
 
-            var quantity01 = Irradiation.From(1, IrradiationUnit.JoulePerSquareMeter);
+            var quantity01 = Irradiation<double>.From(1, IrradiationUnit.JoulePerSquareMeter);
             AssertEx.EqualTolerance(1, quantity01.JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
             Assert.Equal(IrradiationUnit.JoulePerSquareMeter, quantity01.Unit);
 
-            var quantity02 = Irradiation.From(1, IrradiationUnit.JoulePerSquareMillimeter);
+            var quantity02 = Irradiation<double>.From(1, IrradiationUnit.JoulePerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity02.JoulesPerSquareMillimeter, JoulesPerSquareMillimeterTolerance);
             Assert.Equal(IrradiationUnit.JoulePerSquareMillimeter, quantity02.Unit);
 
-            var quantity03 = Irradiation.From(1, IrradiationUnit.KilojoulePerSquareMeter);
+            var quantity03 = Irradiation<double>.From(1, IrradiationUnit.KilojoulePerSquareMeter);
             AssertEx.EqualTolerance(1, quantity03.KilojoulesPerSquareMeter, KilojoulesPerSquareMeterTolerance);
             Assert.Equal(IrradiationUnit.KilojoulePerSquareMeter, quantity03.Unit);
 
-            var quantity04 = Irradiation.From(1, IrradiationUnit.KilowattHourPerSquareMeter);
+            var quantity04 = Irradiation<double>.From(1, IrradiationUnit.KilowattHourPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity04.KilowattHoursPerSquareMeter, KilowattHoursPerSquareMeterTolerance);
             Assert.Equal(IrradiationUnit.KilowattHourPerSquareMeter, quantity04.Unit);
 
-            var quantity05 = Irradiation.From(1, IrradiationUnit.MillijoulePerSquareCentimeter);
+            var quantity05 = Irradiation<double>.From(1, IrradiationUnit.MillijoulePerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity05.MillijoulesPerSquareCentimeter, MillijoulesPerSquareCentimeterTolerance);
             Assert.Equal(IrradiationUnit.MillijoulePerSquareCentimeter, quantity05.Unit);
 
-            var quantity06 = Irradiation.From(1, IrradiationUnit.WattHourPerSquareMeter);
+            var quantity06 = Irradiation<double>.From(1, IrradiationUnit.WattHourPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity06.WattHoursPerSquareMeter, WattHoursPerSquareMeterTolerance);
             Assert.Equal(IrradiationUnit.WattHourPerSquareMeter, quantity06.Unit);
 
@@ -172,20 +172,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromJoulesPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Irradiation.FromJoulesPerSquareMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Irradiation.FromJoulesPerSquareMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Irradiation<double>.FromJoulesPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Irradiation<double>.FromJoulesPerSquareMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromJoulesPerSquareMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Irradiation.FromJoulesPerSquareMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => Irradiation<double>.FromJoulesPerSquareMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            var joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
             AssertEx.EqualTolerance(JoulesPerSquareCentimeterInOneJoulePerSquareMeter, joulepersquaremeter.As(IrradiationUnit.JoulePerSquareCentimeter), JoulesPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(JoulesPerSquareMeterInOneJoulePerSquareMeter, joulepersquaremeter.As(IrradiationUnit.JoulePerSquareMeter), JoulesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(JoulesPerSquareMillimeterInOneJoulePerSquareMeter, joulepersquaremeter.As(IrradiationUnit.JoulePerSquareMillimeter), JoulesPerSquareMillimeterTolerance);
@@ -215,7 +215,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            var joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
 
             var joulepersquarecentimeterQuantity = joulepersquaremeter.ToUnit(IrradiationUnit.JoulePerSquareCentimeter);
             AssertEx.EqualTolerance(JoulesPerSquareCentimeterInOneJoulePerSquareMeter, (double)joulepersquarecentimeterQuantity.Value, JoulesPerSquareCentimeterTolerance);
@@ -256,34 +256,34 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, Irradiation.FromJoulesPerSquareCentimeter(joulepersquaremeter.JoulesPerSquareCentimeter).JoulesPerSquareMeter, JoulesPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromJoulesPerSquareMeter(joulepersquaremeter.JoulesPerSquareMeter).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromJoulesPerSquareMillimeter(joulepersquaremeter.JoulesPerSquareMillimeter).JoulesPerSquareMeter, JoulesPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromKilojoulesPerSquareMeter(joulepersquaremeter.KilojoulesPerSquareMeter).JoulesPerSquareMeter, KilojoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromKilowattHoursPerSquareMeter(joulepersquaremeter.KilowattHoursPerSquareMeter).JoulesPerSquareMeter, KilowattHoursPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromMillijoulesPerSquareCentimeter(joulepersquaremeter.MillijoulesPerSquareCentimeter).JoulesPerSquareMeter, MillijoulesPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromWattHoursPerSquareMeter(joulepersquaremeter.WattHoursPerSquareMeter).JoulesPerSquareMeter, WattHoursPerSquareMeterTolerance);
+            Irradiation<double> joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, Irradiation<double>.FromJoulesPerSquareCentimeter(joulepersquaremeter.JoulesPerSquareCentimeter).JoulesPerSquareMeter, JoulesPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiation<double>.FromJoulesPerSquareMeter(joulepersquaremeter.JoulesPerSquareMeter).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiation<double>.FromJoulesPerSquareMillimeter(joulepersquaremeter.JoulesPerSquareMillimeter).JoulesPerSquareMeter, JoulesPerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiation<double>.FromKilojoulesPerSquareMeter(joulepersquaremeter.KilojoulesPerSquareMeter).JoulesPerSquareMeter, KilojoulesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiation<double>.FromKilowattHoursPerSquareMeter(joulepersquaremeter.KilowattHoursPerSquareMeter).JoulesPerSquareMeter, KilowattHoursPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiation<double>.FromMillijoulesPerSquareCentimeter(joulepersquaremeter.MillijoulesPerSquareCentimeter).JoulesPerSquareMeter, MillijoulesPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Irradiation<double>.FromWattHoursPerSquareMeter(joulepersquaremeter.WattHoursPerSquareMeter).JoulesPerSquareMeter, WattHoursPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Irradiation v = Irradiation.FromJoulesPerSquareMeter(1);
+            Irradiation<double> v = Irradiation<double>.FromJoulesPerSquareMeter(1);
             AssertEx.EqualTolerance(-1, -v.JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiation.FromJoulesPerSquareMeter(3)-v).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (Irradiation<double>.FromJoulesPerSquareMeter(3)-v).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiation.FromJoulesPerSquareMeter(10)/5).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, Irradiation.FromJoulesPerSquareMeter(10)/Irradiation.FromJoulesPerSquareMeter(5), JoulesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (Irradiation<double>.FromJoulesPerSquareMeter(10)/5).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, Irradiation<double>.FromJoulesPerSquareMeter(10)/Irradiation<double>.FromJoulesPerSquareMeter(5), JoulesPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Irradiation oneJoulePerSquareMeter = Irradiation.FromJoulesPerSquareMeter(1);
-            Irradiation twoJoulesPerSquareMeter = Irradiation.FromJoulesPerSquareMeter(2);
+            Irradiation<double> oneJoulePerSquareMeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
+            Irradiation<double> twoJoulesPerSquareMeter = Irradiation<double>.FromJoulesPerSquareMeter(2);
 
             Assert.True(oneJoulePerSquareMeter < twoJoulesPerSquareMeter);
             Assert.True(oneJoulePerSquareMeter <= twoJoulesPerSquareMeter);
@@ -299,31 +299,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            Irradiation<double> joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
             Assert.Equal(0, joulepersquaremeter.CompareTo(joulepersquaremeter));
-            Assert.True(joulepersquaremeter.CompareTo(Irradiation.Zero) > 0);
-            Assert.True(Irradiation.Zero.CompareTo(joulepersquaremeter) < 0);
+            Assert.True(joulepersquaremeter.CompareTo(Irradiation<double>.Zero) > 0);
+            Assert.True(Irradiation<double>.Zero.CompareTo(joulepersquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            Irradiation<double> joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
             Assert.Throws<ArgumentException>(() => joulepersquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            Irradiation<double> joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
             Assert.Throws<ArgumentNullException>(() => joulepersquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Irradiation.FromJoulesPerSquareMeter(1);
-            var b = Irradiation.FromJoulesPerSquareMeter(2);
+            var a = Irradiation<double>.FromJoulesPerSquareMeter(1);
+            var b = Irradiation<double>.FromJoulesPerSquareMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -342,8 +342,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Irradiation.FromJoulesPerSquareMeter(1);
-            var b = Irradiation.FromJoulesPerSquareMeter(2);
+            var a = Irradiation<double>.FromJoulesPerSquareMeter(1);
+            var b = Irradiation<double>.FromJoulesPerSquareMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -363,9 +363,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Irradiation.FromJoulesPerSquareMeter(1);
-            Assert.True(v.Equals(Irradiation.FromJoulesPerSquareMeter(1), JoulesPerSquareMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Irradiation.Zero, JoulesPerSquareMeterTolerance, ComparisonType.Relative));
+            var v = Irradiation<double>.FromJoulesPerSquareMeter(1);
+            Assert.True(v.Equals(Irradiation<double>.FromJoulesPerSquareMeter(1), JoulesPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Irradiation<double>.Zero, JoulesPerSquareMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -378,21 +378,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            Irradiation<double> joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
             Assert.False(joulepersquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
+            Irradiation<double> joulepersquaremeter = Irradiation<double>.FromJoulesPerSquareMeter(1);
             Assert.False(joulepersquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(IrradiationUnit.Undefined, Irradiation.Units);
+            Assert.DoesNotContain(IrradiationUnit.Undefined, Irradiation<double>.Units);
         }
 
         [Fact]
@@ -411,7 +411,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Irradiation.BaseDimensions is null);
+            Assert.False(Irradiation<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs
index 79710b63ce..a9c759795e 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs
@@ -60,7 +60,7 @@ public abstract partial class KinematicViscosityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new KinematicViscosity((double)0.0, KinematicViscosityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>((double)0.0, KinematicViscosityUnit.Undefined));
         }
 
         [Fact]
@@ -75,14 +75,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new KinematicViscosity(double.PositiveInfinity, KinematicViscosityUnit.SquareMeterPerSecond));
-            Assert.Throws<ArgumentException>(() => new KinematicViscosity(double.NegativeInfinity, KinematicViscosityUnit.SquareMeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>(double.PositiveInfinity, KinematicViscosityUnit.SquareMeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>(double.NegativeInfinity, KinematicViscosityUnit.SquareMeterPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new KinematicViscosity(double.NaN, KinematicViscosityUnit.SquareMeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new KinematicViscosity<double>(double.NaN, KinematicViscosityUnit.SquareMeterPerSecond));
         }
 
         [Fact]
@@ -128,7 +128,7 @@ public void KinematicViscosity_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
         [Fact]
         public void SquareMeterPerSecondToKinematicViscosityUnits()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, squaremeterpersecond.Centistokes, CentistokesTolerance);
             AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, squaremeterpersecond.Decistokes, DecistokesTolerance);
             AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, squaremeterpersecond.Kilostokes, KilostokesTolerance);
@@ -142,35 +142,35 @@ public void SquareMeterPerSecondToKinematicViscosityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes);
+            var quantity00 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.Centistokes);
             AssertEx.EqualTolerance(1, quantity00.Centistokes, CentistokesTolerance);
             Assert.Equal(KinematicViscosityUnit.Centistokes, quantity00.Unit);
 
-            var quantity01 = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes);
+            var quantity01 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.Decistokes);
             AssertEx.EqualTolerance(1, quantity01.Decistokes, DecistokesTolerance);
             Assert.Equal(KinematicViscosityUnit.Decistokes, quantity01.Unit);
 
-            var quantity02 = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes);
+            var quantity02 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.Kilostokes);
             AssertEx.EqualTolerance(1, quantity02.Kilostokes, KilostokesTolerance);
             Assert.Equal(KinematicViscosityUnit.Kilostokes, quantity02.Unit);
 
-            var quantity03 = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes);
+            var quantity03 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.Microstokes);
             AssertEx.EqualTolerance(1, quantity03.Microstokes, MicrostokesTolerance);
             Assert.Equal(KinematicViscosityUnit.Microstokes, quantity03.Unit);
 
-            var quantity04 = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes);
+            var quantity04 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.Millistokes);
             AssertEx.EqualTolerance(1, quantity04.Millistokes, MillistokesTolerance);
             Assert.Equal(KinematicViscosityUnit.Millistokes, quantity04.Unit);
 
-            var quantity05 = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes);
+            var quantity05 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.Nanostokes);
             AssertEx.EqualTolerance(1, quantity05.Nanostokes, NanostokesTolerance);
             Assert.Equal(KinematicViscosityUnit.Nanostokes, quantity05.Unit);
 
-            var quantity06 = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond);
+            var quantity06 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.SquareMeterPerSecond);
             AssertEx.EqualTolerance(1, quantity06.SquareMetersPerSecond, SquareMetersPerSecondTolerance);
             Assert.Equal(KinematicViscosityUnit.SquareMeterPerSecond, quantity06.Unit);
 
-            var quantity07 = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes);
+            var quantity07 = KinematicViscosity<double>.From(1, KinematicViscosityUnit.Stokes);
             AssertEx.EqualTolerance(1, quantity07.Stokes, StokesTolerance);
             Assert.Equal(KinematicViscosityUnit.Stokes, quantity07.Unit);
 
@@ -179,20 +179,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSquareMetersPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => KinematicViscosity.FromSquareMetersPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => KinematicViscosity.FromSquareMetersPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => KinematicViscosity<double>.FromSquareMetersPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => KinematicViscosity<double>.FromSquareMetersPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSquareMetersPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => KinematicViscosity.FromSquareMetersPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => KinematicViscosity<double>.FromSquareMetersPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            var squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Centistokes), CentistokesTolerance);
             AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Decistokes), DecistokesTolerance);
             AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Kilostokes), KilostokesTolerance);
@@ -223,7 +223,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            var squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
 
             var centistokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Centistokes);
             AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, (double)centistokesQuantity.Value, CentistokesTolerance);
@@ -268,35 +268,35 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromCentistokes(squaremeterpersecond.Centistokes).SquareMetersPerSecond, CentistokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromDecistokes(squaremeterpersecond.Decistokes).SquareMetersPerSecond, DecistokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromKilostokes(squaremeterpersecond.Kilostokes).SquareMetersPerSecond, KilostokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromMicrostokes(squaremeterpersecond.Microstokes).SquareMetersPerSecond, MicrostokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromMillistokes(squaremeterpersecond.Millistokes).SquareMetersPerSecond, MillistokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromNanostokes(squaremeterpersecond.Nanostokes).SquareMetersPerSecond, NanostokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromSquareMetersPerSecond(squaremeterpersecond.SquareMetersPerSecond).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromStokes(squaremeterpersecond.Stokes).SquareMetersPerSecond, StokesTolerance);
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromCentistokes(squaremeterpersecond.Centistokes).SquareMetersPerSecond, CentistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromDecistokes(squaremeterpersecond.Decistokes).SquareMetersPerSecond, DecistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromKilostokes(squaremeterpersecond.Kilostokes).SquareMetersPerSecond, KilostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromMicrostokes(squaremeterpersecond.Microstokes).SquareMetersPerSecond, MicrostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromMillistokes(squaremeterpersecond.Millistokes).SquareMetersPerSecond, MillistokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromNanostokes(squaremeterpersecond.Nanostokes).SquareMetersPerSecond, NanostokesTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromSquareMetersPerSecond(squaremeterpersecond.SquareMetersPerSecond).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, KinematicViscosity<double>.FromStokes(squaremeterpersecond.Stokes).SquareMetersPerSecond, StokesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            KinematicViscosity v = KinematicViscosity.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> v = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (KinematicViscosity.FromSquareMetersPerSecond(3)-v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (KinematicViscosity<double>.FromSquareMetersPerSecond(3)-v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (KinematicViscosity.FromSquareMetersPerSecond(10)/5).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, KinematicViscosity.FromSquareMetersPerSecond(10)/KinematicViscosity.FromSquareMetersPerSecond(5), SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (KinematicViscosity<double>.FromSquareMetersPerSecond(10)/5).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, KinematicViscosity<double>.FromSquareMetersPerSecond(10)/KinematicViscosity<double>.FromSquareMetersPerSecond(5), SquareMetersPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            KinematicViscosity oneSquareMeterPerSecond = KinematicViscosity.FromSquareMetersPerSecond(1);
-            KinematicViscosity twoSquareMetersPerSecond = KinematicViscosity.FromSquareMetersPerSecond(2);
+            KinematicViscosity<double> oneSquareMeterPerSecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> twoSquareMetersPerSecond = KinematicViscosity<double>.FromSquareMetersPerSecond(2);
 
             Assert.True(oneSquareMeterPerSecond < twoSquareMetersPerSecond);
             Assert.True(oneSquareMeterPerSecond <= twoSquareMetersPerSecond);
@@ -312,31 +312,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             Assert.Equal(0, squaremeterpersecond.CompareTo(squaremeterpersecond));
-            Assert.True(squaremeterpersecond.CompareTo(KinematicViscosity.Zero) > 0);
-            Assert.True(KinematicViscosity.Zero.CompareTo(squaremeterpersecond) < 0);
+            Assert.True(squaremeterpersecond.CompareTo(KinematicViscosity<double>.Zero) > 0);
+            Assert.True(KinematicViscosity<double>.Zero.CompareTo(squaremeterpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             Assert.Throws<ArgumentException>(() => squaremeterpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => squaremeterpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = KinematicViscosity.FromSquareMetersPerSecond(1);
-            var b = KinematicViscosity.FromSquareMetersPerSecond(2);
+            var a = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            var b = KinematicViscosity<double>.FromSquareMetersPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -355,8 +355,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = KinematicViscosity.FromSquareMetersPerSecond(1);
-            var b = KinematicViscosity.FromSquareMetersPerSecond(2);
+            var a = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            var b = KinematicViscosity<double>.FromSquareMetersPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -376,9 +376,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = KinematicViscosity.FromSquareMetersPerSecond(1);
-            Assert.True(v.Equals(KinematicViscosity.FromSquareMetersPerSecond(1), SquareMetersPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(KinematicViscosity.Zero, SquareMetersPerSecondTolerance, ComparisonType.Relative));
+            var v = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
+            Assert.True(v.Equals(KinematicViscosity<double>.FromSquareMetersPerSecond(1), SquareMetersPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(KinematicViscosity<double>.Zero, SquareMetersPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -391,21 +391,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             Assert.False(squaremeterpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
+            KinematicViscosity<double> squaremeterpersecond = KinematicViscosity<double>.FromSquareMetersPerSecond(1);
             Assert.False(squaremeterpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(KinematicViscosityUnit.Undefined, KinematicViscosity.Units);
+            Assert.DoesNotContain(KinematicViscosityUnit.Undefined, KinematicViscosity<double>.Units);
         }
 
         [Fact]
@@ -424,7 +424,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(KinematicViscosity.BaseDimensions is null);
+            Assert.False(KinematicViscosity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LapseRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LapseRateTestsBase.g.cs
index c6ce4cf2dd..8fd452fc2b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LapseRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LapseRateTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class LapseRateTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LapseRate((double)0.0, LapseRateUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>((double)0.0, LapseRateUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LapseRate(double.PositiveInfinity, LapseRateUnit.DegreeCelsiusPerKilometer));
-            Assert.Throws<ArgumentException>(() => new LapseRate(double.NegativeInfinity, LapseRateUnit.DegreeCelsiusPerKilometer));
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>(double.PositiveInfinity, LapseRateUnit.DegreeCelsiusPerKilometer));
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>(double.NegativeInfinity, LapseRateUnit.DegreeCelsiusPerKilometer));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LapseRate(double.NaN, LapseRateUnit.DegreeCelsiusPerKilometer));
+            Assert.Throws<ArgumentException>(() => new LapseRate<double>(double.NaN, LapseRateUnit.DegreeCelsiusPerKilometer));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void LapseRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DegreeCelsiusPerKilometerToLapseRateUnits()
         {
-            LapseRate degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             AssertEx.EqualTolerance(DegreesCelciusPerKilometerInOneDegreeCelsiusPerKilometer, degreecelsiusperkilometer.DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = LapseRate.From(1, LapseRateUnit.DegreeCelsiusPerKilometer);
+            var quantity00 = LapseRate<double>.From(1, LapseRateUnit.DegreeCelsiusPerKilometer);
             AssertEx.EqualTolerance(1, quantity00.DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
             Assert.Equal(LapseRateUnit.DegreeCelsiusPerKilometer, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDegreesCelciusPerKilometer_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LapseRate.FromDegreesCelciusPerKilometer(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => LapseRate.FromDegreesCelciusPerKilometer(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => LapseRate<double>.FromDegreesCelciusPerKilometer(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LapseRate<double>.FromDegreesCelciusPerKilometer(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDegreesCelciusPerKilometer_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LapseRate.FromDegreesCelciusPerKilometer(double.NaN));
+            Assert.Throws<ArgumentException>(() => LapseRate<double>.FromDegreesCelciusPerKilometer(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            var degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             AssertEx.EqualTolerance(DegreesCelciusPerKilometerInOneDegreeCelsiusPerKilometer, degreecelsiusperkilometer.As(LapseRateUnit.DegreeCelsiusPerKilometer), DegreesCelciusPerKilometerTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            var degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
 
             var degreecelsiusperkilometerQuantity = degreecelsiusperkilometer.ToUnit(LapseRateUnit.DegreeCelsiusPerKilometer);
             AssertEx.EqualTolerance(DegreesCelciusPerKilometerInOneDegreeCelsiusPerKilometer, (double)degreecelsiusperkilometerQuantity.Value, DegreesCelciusPerKilometerTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            LapseRate degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
-            AssertEx.EqualTolerance(1, LapseRate.FromDegreesCelciusPerKilometer(degreecelsiusperkilometer.DegreesCelciusPerKilometer).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            AssertEx.EqualTolerance(1, LapseRate<double>.FromDegreesCelciusPerKilometer(degreecelsiusperkilometer.DegreesCelciusPerKilometer).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            LapseRate v = LapseRate.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> v = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             AssertEx.EqualTolerance(-1, -v.DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
-            AssertEx.EqualTolerance(2, (LapseRate.FromDegreesCelciusPerKilometer(3)-v).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(2, (LapseRate<double>.FromDegreesCelciusPerKilometer(3)-v).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
             AssertEx.EqualTolerance(2, (v + v).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
             AssertEx.EqualTolerance(10, (v*10).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
             AssertEx.EqualTolerance(10, (10*v).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
-            AssertEx.EqualTolerance(2, (LapseRate.FromDegreesCelciusPerKilometer(10)/5).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
-            AssertEx.EqualTolerance(2, LapseRate.FromDegreesCelciusPerKilometer(10)/LapseRate.FromDegreesCelciusPerKilometer(5), DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(2, (LapseRate<double>.FromDegreesCelciusPerKilometer(10)/5).DegreesCelciusPerKilometer, DegreesCelciusPerKilometerTolerance);
+            AssertEx.EqualTolerance(2, LapseRate<double>.FromDegreesCelciusPerKilometer(10)/LapseRate<double>.FromDegreesCelciusPerKilometer(5), DegreesCelciusPerKilometerTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            LapseRate oneDegreeCelsiusPerKilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
-            LapseRate twoDegreesCelciusPerKilometer = LapseRate.FromDegreesCelciusPerKilometer(2);
+            LapseRate<double> oneDegreeCelsiusPerKilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> twoDegreesCelciusPerKilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(2);
 
             Assert.True(oneDegreeCelsiusPerKilometer < twoDegreesCelciusPerKilometer);
             Assert.True(oneDegreeCelsiusPerKilometer <= twoDegreesCelciusPerKilometer);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            LapseRate degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             Assert.Equal(0, degreecelsiusperkilometer.CompareTo(degreecelsiusperkilometer));
-            Assert.True(degreecelsiusperkilometer.CompareTo(LapseRate.Zero) > 0);
-            Assert.True(LapseRate.Zero.CompareTo(degreecelsiusperkilometer) < 0);
+            Assert.True(degreecelsiusperkilometer.CompareTo(LapseRate<double>.Zero) > 0);
+            Assert.True(LapseRate<double>.Zero.CompareTo(degreecelsiusperkilometer) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            LapseRate degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             Assert.Throws<ArgumentException>(() => degreecelsiusperkilometer.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            LapseRate degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             Assert.Throws<ArgumentNullException>(() => degreecelsiusperkilometer.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = LapseRate.FromDegreesCelciusPerKilometer(1);
-            var b = LapseRate.FromDegreesCelciusPerKilometer(2);
+            var a = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            var b = LapseRate<double>.FromDegreesCelciusPerKilometer(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = LapseRate.FromDegreesCelciusPerKilometer(1);
-            var b = LapseRate.FromDegreesCelciusPerKilometer(2);
+            var a = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            var b = LapseRate<double>.FromDegreesCelciusPerKilometer(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = LapseRate.FromDegreesCelciusPerKilometer(1);
-            Assert.True(v.Equals(LapseRate.FromDegreesCelciusPerKilometer(1), DegreesCelciusPerKilometerTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(LapseRate.Zero, DegreesCelciusPerKilometerTolerance, ComparisonType.Relative));
+            var v = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
+            Assert.True(v.Equals(LapseRate<double>.FromDegreesCelciusPerKilometer(1), DegreesCelciusPerKilometerTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LapseRate<double>.Zero, DegreesCelciusPerKilometerTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            LapseRate degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             Assert.False(degreecelsiusperkilometer.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            LapseRate degreecelsiusperkilometer = LapseRate.FromDegreesCelciusPerKilometer(1);
+            LapseRate<double> degreecelsiusperkilometer = LapseRate<double>.FromDegreesCelciusPerKilometer(1);
             Assert.False(degreecelsiusperkilometer.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LapseRateUnit.Undefined, LapseRate.Units);
+            Assert.DoesNotContain(LapseRateUnit.Undefined, LapseRate<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(LapseRate.BaseDimensions is null);
+            Assert.False(LapseRate<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs
index bf271f68af..08647db9ff 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs
@@ -110,7 +110,7 @@ public abstract partial class LengthTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Length((double)0.0, LengthUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Length<double>((double)0.0, LengthUnit.Undefined));
         }
 
         [Fact]
@@ -125,14 +125,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Length(double.PositiveInfinity, LengthUnit.Meter));
-            Assert.Throws<ArgumentException>(() => new Length(double.NegativeInfinity, LengthUnit.Meter));
+            Assert.Throws<ArgumentException>(() => new Length<double>(double.PositiveInfinity, LengthUnit.Meter));
+            Assert.Throws<ArgumentException>(() => new Length<double>(double.NegativeInfinity, LengthUnit.Meter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Length(double.NaN, LengthUnit.Meter));
+            Assert.Throws<ArgumentException>(() => new Length<double>(double.NaN, LengthUnit.Meter));
         }
 
         [Fact]
@@ -178,7 +178,7 @@ public void Length_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void MeterToLengthUnits()
         {
-            Length meter = Length.FromMeters(1);
+            Length<double> meter = Length<double>.FromMeters(1);
             AssertEx.EqualTolerance(AstronomicalUnitsInOneMeter, meter.AstronomicalUnits, AstronomicalUnitsTolerance);
             AssertEx.EqualTolerance(CentimetersInOneMeter, meter.Centimeters, CentimetersTolerance);
             AssertEx.EqualTolerance(ChainsInOneMeter, meter.Chains, ChainsTolerance);
@@ -217,135 +217,135 @@ public void MeterToLengthUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Length.From(1, LengthUnit.AstronomicalUnit);
+            var quantity00 = Length<double>.From(1, LengthUnit.AstronomicalUnit);
             AssertEx.EqualTolerance(1, quantity00.AstronomicalUnits, AstronomicalUnitsTolerance);
             Assert.Equal(LengthUnit.AstronomicalUnit, quantity00.Unit);
 
-            var quantity01 = Length.From(1, LengthUnit.Centimeter);
+            var quantity01 = Length<double>.From(1, LengthUnit.Centimeter);
             AssertEx.EqualTolerance(1, quantity01.Centimeters, CentimetersTolerance);
             Assert.Equal(LengthUnit.Centimeter, quantity01.Unit);
 
-            var quantity02 = Length.From(1, LengthUnit.Chain);
+            var quantity02 = Length<double>.From(1, LengthUnit.Chain);
             AssertEx.EqualTolerance(1, quantity02.Chains, ChainsTolerance);
             Assert.Equal(LengthUnit.Chain, quantity02.Unit);
 
-            var quantity03 = Length.From(1, LengthUnit.Decimeter);
+            var quantity03 = Length<double>.From(1, LengthUnit.Decimeter);
             AssertEx.EqualTolerance(1, quantity03.Decimeters, DecimetersTolerance);
             Assert.Equal(LengthUnit.Decimeter, quantity03.Unit);
 
-            var quantity04 = Length.From(1, LengthUnit.DtpPica);
+            var quantity04 = Length<double>.From(1, LengthUnit.DtpPica);
             AssertEx.EqualTolerance(1, quantity04.DtpPicas, DtpPicasTolerance);
             Assert.Equal(LengthUnit.DtpPica, quantity04.Unit);
 
-            var quantity05 = Length.From(1, LengthUnit.DtpPoint);
+            var quantity05 = Length<double>.From(1, LengthUnit.DtpPoint);
             AssertEx.EqualTolerance(1, quantity05.DtpPoints, DtpPointsTolerance);
             Assert.Equal(LengthUnit.DtpPoint, quantity05.Unit);
 
-            var quantity06 = Length.From(1, LengthUnit.Fathom);
+            var quantity06 = Length<double>.From(1, LengthUnit.Fathom);
             AssertEx.EqualTolerance(1, quantity06.Fathoms, FathomsTolerance);
             Assert.Equal(LengthUnit.Fathom, quantity06.Unit);
 
-            var quantity07 = Length.From(1, LengthUnit.Foot);
+            var quantity07 = Length<double>.From(1, LengthUnit.Foot);
             AssertEx.EqualTolerance(1, quantity07.Feet, FeetTolerance);
             Assert.Equal(LengthUnit.Foot, quantity07.Unit);
 
-            var quantity08 = Length.From(1, LengthUnit.Hand);
+            var quantity08 = Length<double>.From(1, LengthUnit.Hand);
             AssertEx.EqualTolerance(1, quantity08.Hands, HandsTolerance);
             Assert.Equal(LengthUnit.Hand, quantity08.Unit);
 
-            var quantity09 = Length.From(1, LengthUnit.Hectometer);
+            var quantity09 = Length<double>.From(1, LengthUnit.Hectometer);
             AssertEx.EqualTolerance(1, quantity09.Hectometers, HectometersTolerance);
             Assert.Equal(LengthUnit.Hectometer, quantity09.Unit);
 
-            var quantity10 = Length.From(1, LengthUnit.Inch);
+            var quantity10 = Length<double>.From(1, LengthUnit.Inch);
             AssertEx.EqualTolerance(1, quantity10.Inches, InchesTolerance);
             Assert.Equal(LengthUnit.Inch, quantity10.Unit);
 
-            var quantity11 = Length.From(1, LengthUnit.KilolightYear);
+            var quantity11 = Length<double>.From(1, LengthUnit.KilolightYear);
             AssertEx.EqualTolerance(1, quantity11.KilolightYears, KilolightYearsTolerance);
             Assert.Equal(LengthUnit.KilolightYear, quantity11.Unit);
 
-            var quantity12 = Length.From(1, LengthUnit.Kilometer);
+            var quantity12 = Length<double>.From(1, LengthUnit.Kilometer);
             AssertEx.EqualTolerance(1, quantity12.Kilometers, KilometersTolerance);
             Assert.Equal(LengthUnit.Kilometer, quantity12.Unit);
 
-            var quantity13 = Length.From(1, LengthUnit.Kiloparsec);
+            var quantity13 = Length<double>.From(1, LengthUnit.Kiloparsec);
             AssertEx.EqualTolerance(1, quantity13.Kiloparsecs, KiloparsecsTolerance);
             Assert.Equal(LengthUnit.Kiloparsec, quantity13.Unit);
 
-            var quantity14 = Length.From(1, LengthUnit.LightYear);
+            var quantity14 = Length<double>.From(1, LengthUnit.LightYear);
             AssertEx.EqualTolerance(1, quantity14.LightYears, LightYearsTolerance);
             Assert.Equal(LengthUnit.LightYear, quantity14.Unit);
 
-            var quantity15 = Length.From(1, LengthUnit.MegalightYear);
+            var quantity15 = Length<double>.From(1, LengthUnit.MegalightYear);
             AssertEx.EqualTolerance(1, quantity15.MegalightYears, MegalightYearsTolerance);
             Assert.Equal(LengthUnit.MegalightYear, quantity15.Unit);
 
-            var quantity16 = Length.From(1, LengthUnit.Megaparsec);
+            var quantity16 = Length<double>.From(1, LengthUnit.Megaparsec);
             AssertEx.EqualTolerance(1, quantity16.Megaparsecs, MegaparsecsTolerance);
             Assert.Equal(LengthUnit.Megaparsec, quantity16.Unit);
 
-            var quantity17 = Length.From(1, LengthUnit.Meter);
+            var quantity17 = Length<double>.From(1, LengthUnit.Meter);
             AssertEx.EqualTolerance(1, quantity17.Meters, MetersTolerance);
             Assert.Equal(LengthUnit.Meter, quantity17.Unit);
 
-            var quantity18 = Length.From(1, LengthUnit.Microinch);
+            var quantity18 = Length<double>.From(1, LengthUnit.Microinch);
             AssertEx.EqualTolerance(1, quantity18.Microinches, MicroinchesTolerance);
             Assert.Equal(LengthUnit.Microinch, quantity18.Unit);
 
-            var quantity19 = Length.From(1, LengthUnit.Micrometer);
+            var quantity19 = Length<double>.From(1, LengthUnit.Micrometer);
             AssertEx.EqualTolerance(1, quantity19.Micrometers, MicrometersTolerance);
             Assert.Equal(LengthUnit.Micrometer, quantity19.Unit);
 
-            var quantity20 = Length.From(1, LengthUnit.Mil);
+            var quantity20 = Length<double>.From(1, LengthUnit.Mil);
             AssertEx.EqualTolerance(1, quantity20.Mils, MilsTolerance);
             Assert.Equal(LengthUnit.Mil, quantity20.Unit);
 
-            var quantity21 = Length.From(1, LengthUnit.Mile);
+            var quantity21 = Length<double>.From(1, LengthUnit.Mile);
             AssertEx.EqualTolerance(1, quantity21.Miles, MilesTolerance);
             Assert.Equal(LengthUnit.Mile, quantity21.Unit);
 
-            var quantity22 = Length.From(1, LengthUnit.Millimeter);
+            var quantity22 = Length<double>.From(1, LengthUnit.Millimeter);
             AssertEx.EqualTolerance(1, quantity22.Millimeters, MillimetersTolerance);
             Assert.Equal(LengthUnit.Millimeter, quantity22.Unit);
 
-            var quantity23 = Length.From(1, LengthUnit.Nanometer);
+            var quantity23 = Length<double>.From(1, LengthUnit.Nanometer);
             AssertEx.EqualTolerance(1, quantity23.Nanometers, NanometersTolerance);
             Assert.Equal(LengthUnit.Nanometer, quantity23.Unit);
 
-            var quantity24 = Length.From(1, LengthUnit.NauticalMile);
+            var quantity24 = Length<double>.From(1, LengthUnit.NauticalMile);
             AssertEx.EqualTolerance(1, quantity24.NauticalMiles, NauticalMilesTolerance);
             Assert.Equal(LengthUnit.NauticalMile, quantity24.Unit);
 
-            var quantity25 = Length.From(1, LengthUnit.Parsec);
+            var quantity25 = Length<double>.From(1, LengthUnit.Parsec);
             AssertEx.EqualTolerance(1, quantity25.Parsecs, ParsecsTolerance);
             Assert.Equal(LengthUnit.Parsec, quantity25.Unit);
 
-            var quantity26 = Length.From(1, LengthUnit.PrinterPica);
+            var quantity26 = Length<double>.From(1, LengthUnit.PrinterPica);
             AssertEx.EqualTolerance(1, quantity26.PrinterPicas, PrinterPicasTolerance);
             Assert.Equal(LengthUnit.PrinterPica, quantity26.Unit);
 
-            var quantity27 = Length.From(1, LengthUnit.PrinterPoint);
+            var quantity27 = Length<double>.From(1, LengthUnit.PrinterPoint);
             AssertEx.EqualTolerance(1, quantity27.PrinterPoints, PrinterPointsTolerance);
             Assert.Equal(LengthUnit.PrinterPoint, quantity27.Unit);
 
-            var quantity28 = Length.From(1, LengthUnit.Shackle);
+            var quantity28 = Length<double>.From(1, LengthUnit.Shackle);
             AssertEx.EqualTolerance(1, quantity28.Shackles, ShacklesTolerance);
             Assert.Equal(LengthUnit.Shackle, quantity28.Unit);
 
-            var quantity29 = Length.From(1, LengthUnit.SolarRadius);
+            var quantity29 = Length<double>.From(1, LengthUnit.SolarRadius);
             AssertEx.EqualTolerance(1, quantity29.SolarRadiuses, SolarRadiusesTolerance);
             Assert.Equal(LengthUnit.SolarRadius, quantity29.Unit);
 
-            var quantity30 = Length.From(1, LengthUnit.Twip);
+            var quantity30 = Length<double>.From(1, LengthUnit.Twip);
             AssertEx.EqualTolerance(1, quantity30.Twips, TwipsTolerance);
             Assert.Equal(LengthUnit.Twip, quantity30.Unit);
 
-            var quantity31 = Length.From(1, LengthUnit.UsSurveyFoot);
+            var quantity31 = Length<double>.From(1, LengthUnit.UsSurveyFoot);
             AssertEx.EqualTolerance(1, quantity31.UsSurveyFeet, UsSurveyFeetTolerance);
             Assert.Equal(LengthUnit.UsSurveyFoot, quantity31.Unit);
 
-            var quantity32 = Length.From(1, LengthUnit.Yard);
+            var quantity32 = Length<double>.From(1, LengthUnit.Yard);
             AssertEx.EqualTolerance(1, quantity32.Yards, YardsTolerance);
             Assert.Equal(LengthUnit.Yard, quantity32.Unit);
 
@@ -354,20 +354,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromMeters_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Length.FromMeters(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Length.FromMeters(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Length<double>.FromMeters(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Length<double>.FromMeters(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromMeters_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Length.FromMeters(double.NaN));
+            Assert.Throws<ArgumentException>(() => Length<double>.FromMeters(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var meter = Length.FromMeters(1);
+            var meter = Length<double>.FromMeters(1);
             AssertEx.EqualTolerance(AstronomicalUnitsInOneMeter, meter.As(LengthUnit.AstronomicalUnit), AstronomicalUnitsTolerance);
             AssertEx.EqualTolerance(CentimetersInOneMeter, meter.As(LengthUnit.Centimeter), CentimetersTolerance);
             AssertEx.EqualTolerance(ChainsInOneMeter, meter.As(LengthUnit.Chain), ChainsTolerance);
@@ -423,7 +423,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var meter = Length.FromMeters(1);
+            var meter = Length<double>.FromMeters(1);
 
             var astronomicalunitQuantity = meter.ToUnit(LengthUnit.AstronomicalUnit);
             AssertEx.EqualTolerance(AstronomicalUnitsInOneMeter, (double)astronomicalunitQuantity.Value, AstronomicalUnitsTolerance);
@@ -568,60 +568,60 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Length meter = Length.FromMeters(1);
-            AssertEx.EqualTolerance(1, Length.FromAstronomicalUnits(meter.AstronomicalUnits).Meters, AstronomicalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromCentimeters(meter.Centimeters).Meters, CentimetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromChains(meter.Chains).Meters, ChainsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDecimeters(meter.Decimeters).Meters, DecimetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDtpPicas(meter.DtpPicas).Meters, DtpPicasTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDtpPoints(meter.DtpPoints).Meters, DtpPointsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromFathoms(meter.Fathoms).Meters, FathomsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromFeet(meter.Feet).Meters, FeetTolerance);
-            AssertEx.EqualTolerance(1, Length.FromHands(meter.Hands).Meters, HandsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromHectometers(meter.Hectometers).Meters, HectometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromInches(meter.Inches).Meters, InchesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKilolightYears(meter.KilolightYears).Meters, KilolightYearsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKilometers(meter.Kilometers).Meters, KilometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKiloparsecs(meter.Kiloparsecs).Meters, KiloparsecsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromLightYears(meter.LightYears).Meters, LightYearsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMegalightYears(meter.MegalightYears).Meters, MegalightYearsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMegaparsecs(meter.Megaparsecs).Meters, MegaparsecsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMeters(meter.Meters).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMicroinches(meter.Microinches).Meters, MicroinchesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMicrometers(meter.Micrometers).Meters, MicrometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMils(meter.Mils).Meters, MilsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMiles(meter.Miles).Meters, MilesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMillimeters(meter.Millimeters).Meters, MillimetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromNanometers(meter.Nanometers).Meters, NanometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromNauticalMiles(meter.NauticalMiles).Meters, NauticalMilesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromParsecs(meter.Parsecs).Meters, ParsecsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromPrinterPicas(meter.PrinterPicas).Meters, PrinterPicasTolerance);
-            AssertEx.EqualTolerance(1, Length.FromPrinterPoints(meter.PrinterPoints).Meters, PrinterPointsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromShackles(meter.Shackles).Meters, ShacklesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromSolarRadiuses(meter.SolarRadiuses).Meters, SolarRadiusesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromTwips(meter.Twips).Meters, TwipsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromUsSurveyFeet(meter.UsSurveyFeet).Meters, UsSurveyFeetTolerance);
-            AssertEx.EqualTolerance(1, Length.FromYards(meter.Yards).Meters, YardsTolerance);
+            Length<double> meter = Length<double>.FromMeters(1);
+            AssertEx.EqualTolerance(1, Length<double>.FromAstronomicalUnits(meter.AstronomicalUnits).Meters, AstronomicalUnitsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromCentimeters(meter.Centimeters).Meters, CentimetersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromChains(meter.Chains).Meters, ChainsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromDecimeters(meter.Decimeters).Meters, DecimetersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromDtpPicas(meter.DtpPicas).Meters, DtpPicasTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromDtpPoints(meter.DtpPoints).Meters, DtpPointsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromFathoms(meter.Fathoms).Meters, FathomsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromFeet(meter.Feet).Meters, FeetTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromHands(meter.Hands).Meters, HandsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromHectometers(meter.Hectometers).Meters, HectometersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromInches(meter.Inches).Meters, InchesTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromKilolightYears(meter.KilolightYears).Meters, KilolightYearsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromKilometers(meter.Kilometers).Meters, KilometersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromKiloparsecs(meter.Kiloparsecs).Meters, KiloparsecsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromLightYears(meter.LightYears).Meters, LightYearsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMegalightYears(meter.MegalightYears).Meters, MegalightYearsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMegaparsecs(meter.Megaparsecs).Meters, MegaparsecsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMeters(meter.Meters).Meters, MetersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMicroinches(meter.Microinches).Meters, MicroinchesTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMicrometers(meter.Micrometers).Meters, MicrometersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMils(meter.Mils).Meters, MilsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMiles(meter.Miles).Meters, MilesTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromMillimeters(meter.Millimeters).Meters, MillimetersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromNanometers(meter.Nanometers).Meters, NanometersTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromNauticalMiles(meter.NauticalMiles).Meters, NauticalMilesTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromParsecs(meter.Parsecs).Meters, ParsecsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromPrinterPicas(meter.PrinterPicas).Meters, PrinterPicasTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromPrinterPoints(meter.PrinterPoints).Meters, PrinterPointsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromShackles(meter.Shackles).Meters, ShacklesTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromSolarRadiuses(meter.SolarRadiuses).Meters, SolarRadiusesTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromTwips(meter.Twips).Meters, TwipsTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromUsSurveyFeet(meter.UsSurveyFeet).Meters, UsSurveyFeetTolerance);
+            AssertEx.EqualTolerance(1, Length<double>.FromYards(meter.Yards).Meters, YardsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Length v = Length.FromMeters(1);
+            Length<double> v = Length<double>.FromMeters(1);
             AssertEx.EqualTolerance(-1, -v.Meters, MetersTolerance);
-            AssertEx.EqualTolerance(2, (Length.FromMeters(3)-v).Meters, MetersTolerance);
+            AssertEx.EqualTolerance(2, (Length<double>.FromMeters(3)-v).Meters, MetersTolerance);
             AssertEx.EqualTolerance(2, (v + v).Meters, MetersTolerance);
             AssertEx.EqualTolerance(10, (v*10).Meters, MetersTolerance);
             AssertEx.EqualTolerance(10, (10*v).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(2, (Length.FromMeters(10)/5).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(2, Length.FromMeters(10)/Length.FromMeters(5), MetersTolerance);
+            AssertEx.EqualTolerance(2, (Length<double>.FromMeters(10)/5).Meters, MetersTolerance);
+            AssertEx.EqualTolerance(2, Length<double>.FromMeters(10)/Length<double>.FromMeters(5), MetersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Length oneMeter = Length.FromMeters(1);
-            Length twoMeters = Length.FromMeters(2);
+            Length<double> oneMeter = Length<double>.FromMeters(1);
+            Length<double> twoMeters = Length<double>.FromMeters(2);
 
             Assert.True(oneMeter < twoMeters);
             Assert.True(oneMeter <= twoMeters);
@@ -637,31 +637,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Length meter = Length.FromMeters(1);
+            Length<double> meter = Length<double>.FromMeters(1);
             Assert.Equal(0, meter.CompareTo(meter));
-            Assert.True(meter.CompareTo(Length.Zero) > 0);
-            Assert.True(Length.Zero.CompareTo(meter) < 0);
+            Assert.True(meter.CompareTo(Length<double>.Zero) > 0);
+            Assert.True(Length<double>.Zero.CompareTo(meter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Length meter = Length.FromMeters(1);
+            Length<double> meter = Length<double>.FromMeters(1);
             Assert.Throws<ArgumentException>(() => meter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Length meter = Length.FromMeters(1);
+            Length<double> meter = Length<double>.FromMeters(1);
             Assert.Throws<ArgumentNullException>(() => meter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Length.FromMeters(1);
-            var b = Length.FromMeters(2);
+            var a = Length<double>.FromMeters(1);
+            var b = Length<double>.FromMeters(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -680,8 +680,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Length.FromMeters(1);
-            var b = Length.FromMeters(2);
+            var a = Length<double>.FromMeters(1);
+            var b = Length<double>.FromMeters(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -701,9 +701,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Length.FromMeters(1);
-            Assert.True(v.Equals(Length.FromMeters(1), MetersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Length.Zero, MetersTolerance, ComparisonType.Relative));
+            var v = Length<double>.FromMeters(1);
+            Assert.True(v.Equals(Length<double>.FromMeters(1), MetersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Length<double>.Zero, MetersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -716,21 +716,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Length meter = Length.FromMeters(1);
+            Length<double> meter = Length<double>.FromMeters(1);
             Assert.False(meter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Length meter = Length.FromMeters(1);
+            Length<double> meter = Length<double>.FromMeters(1);
             Assert.False(meter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LengthUnit.Undefined, Length.Units);
+            Assert.DoesNotContain(LengthUnit.Undefined, Length<double>.Units);
         }
 
         [Fact]
@@ -749,7 +749,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Length.BaseDimensions is null);
+            Assert.False(Length<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs
index 045a83b8dc..b088784a94 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs
@@ -48,7 +48,7 @@ public abstract partial class LevelTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Level((double)0.0, LevelUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Level<double>((double)0.0, LevelUnit.Undefined));
         }
 
         [Fact]
@@ -63,14 +63,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Level(double.PositiveInfinity, LevelUnit.Decibel));
-            Assert.Throws<ArgumentException>(() => new Level(double.NegativeInfinity, LevelUnit.Decibel));
+            Assert.Throws<ArgumentException>(() => new Level<double>(double.PositiveInfinity, LevelUnit.Decibel));
+            Assert.Throws<ArgumentException>(() => new Level<double>(double.NegativeInfinity, LevelUnit.Decibel));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Level(double.NaN, LevelUnit.Decibel));
+            Assert.Throws<ArgumentException>(() => new Level<double>(double.NaN, LevelUnit.Decibel));
         }
 
         [Fact]
@@ -116,7 +116,7 @@ public void Level_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DecibelToLevelUnits()
         {
-            Level decibel = Level.FromDecibels(1);
+            Level<double> decibel = Level<double>.FromDecibels(1);
             AssertEx.EqualTolerance(DecibelsInOneDecibel, decibel.Decibels, DecibelsTolerance);
             AssertEx.EqualTolerance(NepersInOneDecibel, decibel.Nepers, NepersTolerance);
         }
@@ -124,11 +124,11 @@ public void DecibelToLevelUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Level.From(1, LevelUnit.Decibel);
+            var quantity00 = Level<double>.From(1, LevelUnit.Decibel);
             AssertEx.EqualTolerance(1, quantity00.Decibels, DecibelsTolerance);
             Assert.Equal(LevelUnit.Decibel, quantity00.Unit);
 
-            var quantity01 = Level.From(1, LevelUnit.Neper);
+            var quantity01 = Level<double>.From(1, LevelUnit.Neper);
             AssertEx.EqualTolerance(1, quantity01.Nepers, NepersTolerance);
             Assert.Equal(LevelUnit.Neper, quantity01.Unit);
 
@@ -137,20 +137,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDecibels_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Level.FromDecibels(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Level.FromDecibels(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Level<double>.FromDecibels(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Level<double>.FromDecibels(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDecibels_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Level.FromDecibels(double.NaN));
+            Assert.Throws<ArgumentException>(() => Level<double>.FromDecibels(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var decibel = Level.FromDecibels(1);
+            var decibel = Level<double>.FromDecibels(1);
             AssertEx.EqualTolerance(DecibelsInOneDecibel, decibel.As(LevelUnit.Decibel), DecibelsTolerance);
             AssertEx.EqualTolerance(NepersInOneDecibel, decibel.As(LevelUnit.Neper), NepersTolerance);
         }
@@ -175,7 +175,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var decibel = Level.FromDecibels(1);
+            var decibel = Level<double>.FromDecibels(1);
 
             var decibelQuantity = decibel.ToUnit(LevelUnit.Decibel);
             AssertEx.EqualTolerance(DecibelsInOneDecibel, (double)decibelQuantity.Value, DecibelsTolerance);
@@ -196,22 +196,22 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Level decibel = Level.FromDecibels(1);
-            AssertEx.EqualTolerance(1, Level.FromDecibels(decibel.Decibels).Decibels, DecibelsTolerance);
-            AssertEx.EqualTolerance(1, Level.FromNepers(decibel.Nepers).Decibels, NepersTolerance);
+            Level<double> decibel = Level<double>.FromDecibels(1);
+            AssertEx.EqualTolerance(1, Level<double>.FromDecibels(decibel.Decibels).Decibels, DecibelsTolerance);
+            AssertEx.EqualTolerance(1, Level<double>.FromNepers(decibel.Nepers).Decibels, NepersTolerance);
         }
 
         [Fact]
         public void LogarithmicArithmeticOperators()
         {
-            Level v = Level.FromDecibels(40);
+            Level<double> v = Level<double>.FromDecibels(40);
             AssertEx.EqualTolerance(-40, -v.Decibels, NepersTolerance);
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
             AssertEx.EqualTolerance(50, (v*10).Decibels, NepersTolerance);
             AssertEx.EqualTolerance(50, (10*v).Decibels, NepersTolerance);
             AssertEx.EqualTolerance(35, (v/5).Decibels, NepersTolerance);
-            AssertEx.EqualTolerance(35, v/Level.FromDecibels(5), NepersTolerance);
+            AssertEx.EqualTolerance(35, v/Level<double>.FromDecibels(5), NepersTolerance);
         }
 
         protected abstract void AssertLogarithmicAddition();
@@ -221,8 +221,8 @@ public void LogarithmicArithmeticOperators()
         [Fact]
         public void ComparisonOperators()
         {
-            Level oneDecibel = Level.FromDecibels(1);
-            Level twoDecibels = Level.FromDecibels(2);
+            Level<double> oneDecibel = Level<double>.FromDecibels(1);
+            Level<double> twoDecibels = Level<double>.FromDecibels(2);
 
             Assert.True(oneDecibel < twoDecibels);
             Assert.True(oneDecibel <= twoDecibels);
@@ -238,31 +238,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Level decibel = Level.FromDecibels(1);
+            Level<double> decibel = Level<double>.FromDecibels(1);
             Assert.Equal(0, decibel.CompareTo(decibel));
-            Assert.True(decibel.CompareTo(Level.Zero) > 0);
-            Assert.True(Level.Zero.CompareTo(decibel) < 0);
+            Assert.True(decibel.CompareTo(Level<double>.Zero) > 0);
+            Assert.True(Level<double>.Zero.CompareTo(decibel) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Level decibel = Level.FromDecibels(1);
+            Level<double> decibel = Level<double>.FromDecibels(1);
             Assert.Throws<ArgumentException>(() => decibel.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Level decibel = Level.FromDecibels(1);
+            Level<double> decibel = Level<double>.FromDecibels(1);
             Assert.Throws<ArgumentNullException>(() => decibel.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Level.FromDecibels(1);
-            var b = Level.FromDecibels(2);
+            var a = Level<double>.FromDecibels(1);
+            var b = Level<double>.FromDecibels(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -281,8 +281,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Level.FromDecibels(1);
-            var b = Level.FromDecibels(2);
+            var a = Level<double>.FromDecibels(1);
+            var b = Level<double>.FromDecibels(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -302,9 +302,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Level.FromDecibels(1);
-            Assert.True(v.Equals(Level.FromDecibels(1), DecibelsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Level.Zero, DecibelsTolerance, ComparisonType.Relative));
+            var v = Level<double>.FromDecibels(1);
+            Assert.True(v.Equals(Level<double>.FromDecibels(1), DecibelsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Level<double>.Zero, DecibelsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -317,21 +317,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Level decibel = Level.FromDecibels(1);
+            Level<double> decibel = Level<double>.FromDecibels(1);
             Assert.False(decibel.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Level decibel = Level.FromDecibels(1);
+            Level<double> decibel = Level<double>.FromDecibels(1);
             Assert.False(decibel.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LevelUnit.Undefined, Level.Units);
+            Assert.DoesNotContain(LevelUnit.Undefined, Level<double>.Units);
         }
 
         [Fact]
@@ -350,7 +350,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Level.BaseDimensions is null);
+            Assert.False(Level<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs
index 9358d3f574..127e0a865b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs
@@ -72,7 +72,7 @@ public abstract partial class LinearDensityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LinearDensity((double)0.0, LinearDensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>((double)0.0, LinearDensityUnit.Undefined));
         }
 
         [Fact]
@@ -87,14 +87,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LinearDensity(double.PositiveInfinity, LinearDensityUnit.KilogramPerMeter));
-            Assert.Throws<ArgumentException>(() => new LinearDensity(double.NegativeInfinity, LinearDensityUnit.KilogramPerMeter));
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>(double.PositiveInfinity, LinearDensityUnit.KilogramPerMeter));
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>(double.NegativeInfinity, LinearDensityUnit.KilogramPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LinearDensity(double.NaN, LinearDensityUnit.KilogramPerMeter));
+            Assert.Throws<ArgumentException>(() => new LinearDensity<double>(double.NaN, LinearDensityUnit.KilogramPerMeter));
         }
 
         [Fact]
@@ -140,7 +140,7 @@ public void LinearDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void KilogramPerMeterToLinearDensityUnits()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
             AssertEx.EqualTolerance(GramsPerCentimeterInOneKilogramPerMeter, kilogrampermeter.GramsPerCentimeter, GramsPerCentimeterTolerance);
             AssertEx.EqualTolerance(GramsPerMeterInOneKilogramPerMeter, kilogrampermeter.GramsPerMeter, GramsPerMeterTolerance);
             AssertEx.EqualTolerance(GramsPerMillimeterInOneKilogramPerMeter, kilogrampermeter.GramsPerMillimeter, GramsPerMillimeterTolerance);
@@ -160,59 +160,59 @@ public void KilogramPerMeterToLinearDensityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = LinearDensity.From(1, LinearDensityUnit.GramPerCentimeter);
+            var quantity00 = LinearDensity<double>.From(1, LinearDensityUnit.GramPerCentimeter);
             AssertEx.EqualTolerance(1, quantity00.GramsPerCentimeter, GramsPerCentimeterTolerance);
             Assert.Equal(LinearDensityUnit.GramPerCentimeter, quantity00.Unit);
 
-            var quantity01 = LinearDensity.From(1, LinearDensityUnit.GramPerMeter);
+            var quantity01 = LinearDensity<double>.From(1, LinearDensityUnit.GramPerMeter);
             AssertEx.EqualTolerance(1, quantity01.GramsPerMeter, GramsPerMeterTolerance);
             Assert.Equal(LinearDensityUnit.GramPerMeter, quantity01.Unit);
 
-            var quantity02 = LinearDensity.From(1, LinearDensityUnit.GramPerMillimeter);
+            var quantity02 = LinearDensity<double>.From(1, LinearDensityUnit.GramPerMillimeter);
             AssertEx.EqualTolerance(1, quantity02.GramsPerMillimeter, GramsPerMillimeterTolerance);
             Assert.Equal(LinearDensityUnit.GramPerMillimeter, quantity02.Unit);
 
-            var quantity03 = LinearDensity.From(1, LinearDensityUnit.KilogramPerCentimeter);
+            var quantity03 = LinearDensity<double>.From(1, LinearDensityUnit.KilogramPerCentimeter);
             AssertEx.EqualTolerance(1, quantity03.KilogramsPerCentimeter, KilogramsPerCentimeterTolerance);
             Assert.Equal(LinearDensityUnit.KilogramPerCentimeter, quantity03.Unit);
 
-            var quantity04 = LinearDensity.From(1, LinearDensityUnit.KilogramPerMeter);
+            var quantity04 = LinearDensity<double>.From(1, LinearDensityUnit.KilogramPerMeter);
             AssertEx.EqualTolerance(1, quantity04.KilogramsPerMeter, KilogramsPerMeterTolerance);
             Assert.Equal(LinearDensityUnit.KilogramPerMeter, quantity04.Unit);
 
-            var quantity05 = LinearDensity.From(1, LinearDensityUnit.KilogramPerMillimeter);
+            var quantity05 = LinearDensity<double>.From(1, LinearDensityUnit.KilogramPerMillimeter);
             AssertEx.EqualTolerance(1, quantity05.KilogramsPerMillimeter, KilogramsPerMillimeterTolerance);
             Assert.Equal(LinearDensityUnit.KilogramPerMillimeter, quantity05.Unit);
 
-            var quantity06 = LinearDensity.From(1, LinearDensityUnit.MicrogramPerCentimeter);
+            var quantity06 = LinearDensity<double>.From(1, LinearDensityUnit.MicrogramPerCentimeter);
             AssertEx.EqualTolerance(1, quantity06.MicrogramsPerCentimeter, MicrogramsPerCentimeterTolerance);
             Assert.Equal(LinearDensityUnit.MicrogramPerCentimeter, quantity06.Unit);
 
-            var quantity07 = LinearDensity.From(1, LinearDensityUnit.MicrogramPerMeter);
+            var quantity07 = LinearDensity<double>.From(1, LinearDensityUnit.MicrogramPerMeter);
             AssertEx.EqualTolerance(1, quantity07.MicrogramsPerMeter, MicrogramsPerMeterTolerance);
             Assert.Equal(LinearDensityUnit.MicrogramPerMeter, quantity07.Unit);
 
-            var quantity08 = LinearDensity.From(1, LinearDensityUnit.MicrogramPerMillimeter);
+            var quantity08 = LinearDensity<double>.From(1, LinearDensityUnit.MicrogramPerMillimeter);
             AssertEx.EqualTolerance(1, quantity08.MicrogramsPerMillimeter, MicrogramsPerMillimeterTolerance);
             Assert.Equal(LinearDensityUnit.MicrogramPerMillimeter, quantity08.Unit);
 
-            var quantity09 = LinearDensity.From(1, LinearDensityUnit.MilligramPerCentimeter);
+            var quantity09 = LinearDensity<double>.From(1, LinearDensityUnit.MilligramPerCentimeter);
             AssertEx.EqualTolerance(1, quantity09.MilligramsPerCentimeter, MilligramsPerCentimeterTolerance);
             Assert.Equal(LinearDensityUnit.MilligramPerCentimeter, quantity09.Unit);
 
-            var quantity10 = LinearDensity.From(1, LinearDensityUnit.MilligramPerMeter);
+            var quantity10 = LinearDensity<double>.From(1, LinearDensityUnit.MilligramPerMeter);
             AssertEx.EqualTolerance(1, quantity10.MilligramsPerMeter, MilligramsPerMeterTolerance);
             Assert.Equal(LinearDensityUnit.MilligramPerMeter, quantity10.Unit);
 
-            var quantity11 = LinearDensity.From(1, LinearDensityUnit.MilligramPerMillimeter);
+            var quantity11 = LinearDensity<double>.From(1, LinearDensityUnit.MilligramPerMillimeter);
             AssertEx.EqualTolerance(1, quantity11.MilligramsPerMillimeter, MilligramsPerMillimeterTolerance);
             Assert.Equal(LinearDensityUnit.MilligramPerMillimeter, quantity11.Unit);
 
-            var quantity12 = LinearDensity.From(1, LinearDensityUnit.PoundPerFoot);
+            var quantity12 = LinearDensity<double>.From(1, LinearDensityUnit.PoundPerFoot);
             AssertEx.EqualTolerance(1, quantity12.PoundsPerFoot, PoundsPerFootTolerance);
             Assert.Equal(LinearDensityUnit.PoundPerFoot, quantity12.Unit);
 
-            var quantity13 = LinearDensity.From(1, LinearDensityUnit.PoundPerInch);
+            var quantity13 = LinearDensity<double>.From(1, LinearDensityUnit.PoundPerInch);
             AssertEx.EqualTolerance(1, quantity13.PoundsPerInch, PoundsPerInchTolerance);
             Assert.Equal(LinearDensityUnit.PoundPerInch, quantity13.Unit);
 
@@ -221,20 +221,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramsPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LinearDensity.FromKilogramsPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => LinearDensity.FromKilogramsPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => LinearDensity<double>.FromKilogramsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LinearDensity<double>.FromKilogramsPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramsPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LinearDensity.FromKilogramsPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => LinearDensity<double>.FromKilogramsPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            var kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
             AssertEx.EqualTolerance(GramsPerCentimeterInOneKilogramPerMeter, kilogrampermeter.As(LinearDensityUnit.GramPerCentimeter), GramsPerCentimeterTolerance);
             AssertEx.EqualTolerance(GramsPerMeterInOneKilogramPerMeter, kilogrampermeter.As(LinearDensityUnit.GramPerMeter), GramsPerMeterTolerance);
             AssertEx.EqualTolerance(GramsPerMillimeterInOneKilogramPerMeter, kilogrampermeter.As(LinearDensityUnit.GramPerMillimeter), GramsPerMillimeterTolerance);
@@ -271,7 +271,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            var kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
 
             var grampercentimeterQuantity = kilogrampermeter.ToUnit(LinearDensityUnit.GramPerCentimeter);
             AssertEx.EqualTolerance(GramsPerCentimeterInOneKilogramPerMeter, (double)grampercentimeterQuantity.Value, GramsPerCentimeterTolerance);
@@ -340,41 +340,41 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
-            AssertEx.EqualTolerance(1, LinearDensity.FromGramsPerCentimeter(kilogrampermeter.GramsPerCentimeter).KilogramsPerMeter, GramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromGramsPerMeter(kilogrampermeter.GramsPerMeter).KilogramsPerMeter, GramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromGramsPerMillimeter(kilogrampermeter.GramsPerMillimeter).KilogramsPerMeter, GramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromKilogramsPerCentimeter(kilogrampermeter.KilogramsPerCentimeter).KilogramsPerMeter, KilogramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromKilogramsPerMeter(kilogrampermeter.KilogramsPerMeter).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromKilogramsPerMillimeter(kilogrampermeter.KilogramsPerMillimeter).KilogramsPerMeter, KilogramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMicrogramsPerCentimeter(kilogrampermeter.MicrogramsPerCentimeter).KilogramsPerMeter, MicrogramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMicrogramsPerMeter(kilogrampermeter.MicrogramsPerMeter).KilogramsPerMeter, MicrogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMicrogramsPerMillimeter(kilogrampermeter.MicrogramsPerMillimeter).KilogramsPerMeter, MicrogramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMilligramsPerCentimeter(kilogrampermeter.MilligramsPerCentimeter).KilogramsPerMeter, MilligramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMilligramsPerMeter(kilogrampermeter.MilligramsPerMeter).KilogramsPerMeter, MilligramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMilligramsPerMillimeter(kilogrampermeter.MilligramsPerMillimeter).KilogramsPerMeter, MilligramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromPoundsPerFoot(kilogrampermeter.PoundsPerFoot).KilogramsPerMeter, PoundsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromPoundsPerInch(kilogrampermeter.PoundsPerInch).KilogramsPerMeter, PoundsPerInchTolerance);
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromGramsPerCentimeter(kilogrampermeter.GramsPerCentimeter).KilogramsPerMeter, GramsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromGramsPerMeter(kilogrampermeter.GramsPerMeter).KilogramsPerMeter, GramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromGramsPerMillimeter(kilogrampermeter.GramsPerMillimeter).KilogramsPerMeter, GramsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromKilogramsPerCentimeter(kilogrampermeter.KilogramsPerCentimeter).KilogramsPerMeter, KilogramsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromKilogramsPerMeter(kilogrampermeter.KilogramsPerMeter).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromKilogramsPerMillimeter(kilogrampermeter.KilogramsPerMillimeter).KilogramsPerMeter, KilogramsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromMicrogramsPerCentimeter(kilogrampermeter.MicrogramsPerCentimeter).KilogramsPerMeter, MicrogramsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromMicrogramsPerMeter(kilogrampermeter.MicrogramsPerMeter).KilogramsPerMeter, MicrogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromMicrogramsPerMillimeter(kilogrampermeter.MicrogramsPerMillimeter).KilogramsPerMeter, MicrogramsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromMilligramsPerCentimeter(kilogrampermeter.MilligramsPerCentimeter).KilogramsPerMeter, MilligramsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromMilligramsPerMeter(kilogrampermeter.MilligramsPerMeter).KilogramsPerMeter, MilligramsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromMilligramsPerMillimeter(kilogrampermeter.MilligramsPerMillimeter).KilogramsPerMeter, MilligramsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromPoundsPerFoot(kilogrampermeter.PoundsPerFoot).KilogramsPerMeter, PoundsPerFootTolerance);
+            AssertEx.EqualTolerance(1, LinearDensity<double>.FromPoundsPerInch(kilogrampermeter.PoundsPerInch).KilogramsPerMeter, PoundsPerInchTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            LinearDensity v = LinearDensity.FromKilogramsPerMeter(1);
+            LinearDensity<double> v = LinearDensity<double>.FromKilogramsPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearDensity.FromKilogramsPerMeter(3)-v).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (LinearDensity<double>.FromKilogramsPerMeter(3)-v).KilogramsPerMeter, KilogramsPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramsPerMeter, KilogramsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramsPerMeter, KilogramsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearDensity.FromKilogramsPerMeter(10)/5).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, LinearDensity.FromKilogramsPerMeter(10)/LinearDensity.FromKilogramsPerMeter(5), KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (LinearDensity<double>.FromKilogramsPerMeter(10)/5).KilogramsPerMeter, KilogramsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, LinearDensity<double>.FromKilogramsPerMeter(10)/LinearDensity<double>.FromKilogramsPerMeter(5), KilogramsPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            LinearDensity oneKilogramPerMeter = LinearDensity.FromKilogramsPerMeter(1);
-            LinearDensity twoKilogramsPerMeter = LinearDensity.FromKilogramsPerMeter(2);
+            LinearDensity<double> oneKilogramPerMeter = LinearDensity<double>.FromKilogramsPerMeter(1);
+            LinearDensity<double> twoKilogramsPerMeter = LinearDensity<double>.FromKilogramsPerMeter(2);
 
             Assert.True(oneKilogramPerMeter < twoKilogramsPerMeter);
             Assert.True(oneKilogramPerMeter <= twoKilogramsPerMeter);
@@ -390,31 +390,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
             Assert.Equal(0, kilogrampermeter.CompareTo(kilogrampermeter));
-            Assert.True(kilogrampermeter.CompareTo(LinearDensity.Zero) > 0);
-            Assert.True(LinearDensity.Zero.CompareTo(kilogrampermeter) < 0);
+            Assert.True(kilogrampermeter.CompareTo(LinearDensity<double>.Zero) > 0);
+            Assert.True(LinearDensity<double>.Zero.CompareTo(kilogrampermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
             Assert.Throws<ArgumentException>(() => kilogrampermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => kilogrampermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = LinearDensity.FromKilogramsPerMeter(1);
-            var b = LinearDensity.FromKilogramsPerMeter(2);
+            var a = LinearDensity<double>.FromKilogramsPerMeter(1);
+            var b = LinearDensity<double>.FromKilogramsPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -433,8 +433,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = LinearDensity.FromKilogramsPerMeter(1);
-            var b = LinearDensity.FromKilogramsPerMeter(2);
+            var a = LinearDensity<double>.FromKilogramsPerMeter(1);
+            var b = LinearDensity<double>.FromKilogramsPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -454,9 +454,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = LinearDensity.FromKilogramsPerMeter(1);
-            Assert.True(v.Equals(LinearDensity.FromKilogramsPerMeter(1), KilogramsPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(LinearDensity.Zero, KilogramsPerMeterTolerance, ComparisonType.Relative));
+            var v = LinearDensity<double>.FromKilogramsPerMeter(1);
+            Assert.True(v.Equals(LinearDensity<double>.FromKilogramsPerMeter(1), KilogramsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LinearDensity<double>.Zero, KilogramsPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -469,21 +469,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
             Assert.False(kilogrampermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
+            LinearDensity<double> kilogrampermeter = LinearDensity<double>.FromKilogramsPerMeter(1);
             Assert.False(kilogrampermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LinearDensityUnit.Undefined, LinearDensity.Units);
+            Assert.DoesNotContain(LinearDensityUnit.Undefined, LinearDensity<double>.Units);
         }
 
         [Fact]
@@ -502,7 +502,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(LinearDensity.BaseDimensions is null);
+            Assert.False(LinearDensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs
index a766ca22f2..2bf4b4b3de 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs
@@ -94,7 +94,7 @@ public abstract partial class LinearPowerDensityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LinearPowerDensity((double)0.0, LinearPowerDensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new LinearPowerDensity<double>((double)0.0, LinearPowerDensityUnit.Undefined));
         }
 
         [Fact]
@@ -109,14 +109,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LinearPowerDensity(double.PositiveInfinity, LinearPowerDensityUnit.WattPerMeter));
-            Assert.Throws<ArgumentException>(() => new LinearPowerDensity(double.NegativeInfinity, LinearPowerDensityUnit.WattPerMeter));
+            Assert.Throws<ArgumentException>(() => new LinearPowerDensity<double>(double.PositiveInfinity, LinearPowerDensityUnit.WattPerMeter));
+            Assert.Throws<ArgumentException>(() => new LinearPowerDensity<double>(double.NegativeInfinity, LinearPowerDensityUnit.WattPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LinearPowerDensity(double.NaN, LinearPowerDensityUnit.WattPerMeter));
+            Assert.Throws<ArgumentException>(() => new LinearPowerDensity<double>(double.NaN, LinearPowerDensityUnit.WattPerMeter));
         }
 
         [Fact]
@@ -162,7 +162,7 @@ public void LinearPowerDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
         [Fact]
         public void WattPerMeterToLinearPowerDensityUnits()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            LinearPowerDensity<double> wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
             AssertEx.EqualTolerance(GigawattsPerCentimeterInOneWattPerMeter, wattpermeter.GigawattsPerCentimeter, GigawattsPerCentimeterTolerance);
             AssertEx.EqualTolerance(GigawattsPerFootInOneWattPerMeter, wattpermeter.GigawattsPerFoot, GigawattsPerFootTolerance);
             AssertEx.EqualTolerance(GigawattsPerInchInOneWattPerMeter, wattpermeter.GigawattsPerInch, GigawattsPerInchTolerance);
@@ -193,103 +193,103 @@ public void WattPerMeterToLinearPowerDensityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerCentimeter);
+            var quantity00 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.GigawattPerCentimeter);
             AssertEx.EqualTolerance(1, quantity00.GigawattsPerCentimeter, GigawattsPerCentimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.GigawattPerCentimeter, quantity00.Unit);
 
-            var quantity01 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerFoot);
+            var quantity01 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.GigawattPerFoot);
             AssertEx.EqualTolerance(1, quantity01.GigawattsPerFoot, GigawattsPerFootTolerance);
             Assert.Equal(LinearPowerDensityUnit.GigawattPerFoot, quantity01.Unit);
 
-            var quantity02 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerInch);
+            var quantity02 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.GigawattPerInch);
             AssertEx.EqualTolerance(1, quantity02.GigawattsPerInch, GigawattsPerInchTolerance);
             Assert.Equal(LinearPowerDensityUnit.GigawattPerInch, quantity02.Unit);
 
-            var quantity03 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerMeter);
+            var quantity03 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.GigawattPerMeter);
             AssertEx.EqualTolerance(1, quantity03.GigawattsPerMeter, GigawattsPerMeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.GigawattPerMeter, quantity03.Unit);
 
-            var quantity04 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerMillimeter);
+            var quantity04 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.GigawattPerMillimeter);
             AssertEx.EqualTolerance(1, quantity04.GigawattsPerMillimeter, GigawattsPerMillimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.GigawattPerMillimeter, quantity04.Unit);
 
-            var quantity05 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerCentimeter);
+            var quantity05 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.KilowattPerCentimeter);
             AssertEx.EqualTolerance(1, quantity05.KilowattsPerCentimeter, KilowattsPerCentimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.KilowattPerCentimeter, quantity05.Unit);
 
-            var quantity06 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerFoot);
+            var quantity06 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.KilowattPerFoot);
             AssertEx.EqualTolerance(1, quantity06.KilowattsPerFoot, KilowattsPerFootTolerance);
             Assert.Equal(LinearPowerDensityUnit.KilowattPerFoot, quantity06.Unit);
 
-            var quantity07 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerInch);
+            var quantity07 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.KilowattPerInch);
             AssertEx.EqualTolerance(1, quantity07.KilowattsPerInch, KilowattsPerInchTolerance);
             Assert.Equal(LinearPowerDensityUnit.KilowattPerInch, quantity07.Unit);
 
-            var quantity08 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerMeter);
+            var quantity08 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.KilowattPerMeter);
             AssertEx.EqualTolerance(1, quantity08.KilowattsPerMeter, KilowattsPerMeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.KilowattPerMeter, quantity08.Unit);
 
-            var quantity09 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerMillimeter);
+            var quantity09 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.KilowattPerMillimeter);
             AssertEx.EqualTolerance(1, quantity09.KilowattsPerMillimeter, KilowattsPerMillimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.KilowattPerMillimeter, quantity09.Unit);
 
-            var quantity10 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerCentimeter);
+            var quantity10 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MegawattPerCentimeter);
             AssertEx.EqualTolerance(1, quantity10.MegawattsPerCentimeter, MegawattsPerCentimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.MegawattPerCentimeter, quantity10.Unit);
 
-            var quantity11 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerFoot);
+            var quantity11 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MegawattPerFoot);
             AssertEx.EqualTolerance(1, quantity11.MegawattsPerFoot, MegawattsPerFootTolerance);
             Assert.Equal(LinearPowerDensityUnit.MegawattPerFoot, quantity11.Unit);
 
-            var quantity12 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerInch);
+            var quantity12 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MegawattPerInch);
             AssertEx.EqualTolerance(1, quantity12.MegawattsPerInch, MegawattsPerInchTolerance);
             Assert.Equal(LinearPowerDensityUnit.MegawattPerInch, quantity12.Unit);
 
-            var quantity13 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerMeter);
+            var quantity13 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MegawattPerMeter);
             AssertEx.EqualTolerance(1, quantity13.MegawattsPerMeter, MegawattsPerMeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.MegawattPerMeter, quantity13.Unit);
 
-            var quantity14 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerMillimeter);
+            var quantity14 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MegawattPerMillimeter);
             AssertEx.EqualTolerance(1, quantity14.MegawattsPerMillimeter, MegawattsPerMillimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.MegawattPerMillimeter, quantity14.Unit);
 
-            var quantity15 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerCentimeter);
+            var quantity15 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MilliwattPerCentimeter);
             AssertEx.EqualTolerance(1, quantity15.MilliwattsPerCentimeter, MilliwattsPerCentimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.MilliwattPerCentimeter, quantity15.Unit);
 
-            var quantity16 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerFoot);
+            var quantity16 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MilliwattPerFoot);
             AssertEx.EqualTolerance(1, quantity16.MilliwattsPerFoot, MilliwattsPerFootTolerance);
             Assert.Equal(LinearPowerDensityUnit.MilliwattPerFoot, quantity16.Unit);
 
-            var quantity17 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerInch);
+            var quantity17 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MilliwattPerInch);
             AssertEx.EqualTolerance(1, quantity17.MilliwattsPerInch, MilliwattsPerInchTolerance);
             Assert.Equal(LinearPowerDensityUnit.MilliwattPerInch, quantity17.Unit);
 
-            var quantity18 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerMeter);
+            var quantity18 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MilliwattPerMeter);
             AssertEx.EqualTolerance(1, quantity18.MilliwattsPerMeter, MilliwattsPerMeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.MilliwattPerMeter, quantity18.Unit);
 
-            var quantity19 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerMillimeter);
+            var quantity19 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.MilliwattPerMillimeter);
             AssertEx.EqualTolerance(1, quantity19.MilliwattsPerMillimeter, MilliwattsPerMillimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.MilliwattPerMillimeter, quantity19.Unit);
 
-            var quantity20 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerCentimeter);
+            var quantity20 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.WattPerCentimeter);
             AssertEx.EqualTolerance(1, quantity20.WattsPerCentimeter, WattsPerCentimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.WattPerCentimeter, quantity20.Unit);
 
-            var quantity21 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerFoot);
+            var quantity21 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.WattPerFoot);
             AssertEx.EqualTolerance(1, quantity21.WattsPerFoot, WattsPerFootTolerance);
             Assert.Equal(LinearPowerDensityUnit.WattPerFoot, quantity21.Unit);
 
-            var quantity22 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerInch);
+            var quantity22 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.WattPerInch);
             AssertEx.EqualTolerance(1, quantity22.WattsPerInch, WattsPerInchTolerance);
             Assert.Equal(LinearPowerDensityUnit.WattPerInch, quantity22.Unit);
 
-            var quantity23 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerMeter);
+            var quantity23 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.WattPerMeter);
             AssertEx.EqualTolerance(1, quantity23.WattsPerMeter, WattsPerMeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.WattPerMeter, quantity23.Unit);
 
-            var quantity24 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerMillimeter);
+            var quantity24 = LinearPowerDensity<double>.From(1, LinearPowerDensityUnit.WattPerMillimeter);
             AssertEx.EqualTolerance(1, quantity24.WattsPerMillimeter, WattsPerMillimeterTolerance);
             Assert.Equal(LinearPowerDensityUnit.WattPerMillimeter, quantity24.Unit);
 
@@ -298,20 +298,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWattsPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LinearPowerDensity.FromWattsPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => LinearPowerDensity.FromWattsPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => LinearPowerDensity<double>.FromWattsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LinearPowerDensity<double>.FromWattsPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWattsPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LinearPowerDensity.FromWattsPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => LinearPowerDensity<double>.FromWattsPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            var wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
             AssertEx.EqualTolerance(GigawattsPerCentimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerCentimeter), GigawattsPerCentimeterTolerance);
             AssertEx.EqualTolerance(GigawattsPerFootInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerFoot), GigawattsPerFootTolerance);
             AssertEx.EqualTolerance(GigawattsPerInchInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerInch), GigawattsPerInchTolerance);
@@ -359,7 +359,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            var wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
 
             var gigawattpercentimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.GigawattPerCentimeter);
             AssertEx.EqualTolerance(GigawattsPerCentimeterInOneWattPerMeter, (double)gigawattpercentimeterQuantity.Value, GigawattsPerCentimeterTolerance);
@@ -472,52 +472,52 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerCentimeter(wattpermeter.GigawattsPerCentimeter).WattsPerMeter, GigawattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerFoot(wattpermeter.GigawattsPerFoot).WattsPerMeter, GigawattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerInch(wattpermeter.GigawattsPerInch).WattsPerMeter, GigawattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerMeter(wattpermeter.GigawattsPerMeter).WattsPerMeter, GigawattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerMillimeter(wattpermeter.GigawattsPerMillimeter).WattsPerMeter, GigawattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerCentimeter(wattpermeter.KilowattsPerCentimeter).WattsPerMeter, KilowattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerFoot(wattpermeter.KilowattsPerFoot).WattsPerMeter, KilowattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerInch(wattpermeter.KilowattsPerInch).WattsPerMeter, KilowattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerMeter(wattpermeter.KilowattsPerMeter).WattsPerMeter, KilowattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerMillimeter(wattpermeter.KilowattsPerMillimeter).WattsPerMeter, KilowattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerCentimeter(wattpermeter.MegawattsPerCentimeter).WattsPerMeter, MegawattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerFoot(wattpermeter.MegawattsPerFoot).WattsPerMeter, MegawattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerInch(wattpermeter.MegawattsPerInch).WattsPerMeter, MegawattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerMeter(wattpermeter.MegawattsPerMeter).WattsPerMeter, MegawattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerMillimeter(wattpermeter.MegawattsPerMillimeter).WattsPerMeter, MegawattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerCentimeter(wattpermeter.MilliwattsPerCentimeter).WattsPerMeter, MilliwattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerFoot(wattpermeter.MilliwattsPerFoot).WattsPerMeter, MilliwattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerInch(wattpermeter.MilliwattsPerInch).WattsPerMeter, MilliwattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerMeter(wattpermeter.MilliwattsPerMeter).WattsPerMeter, MilliwattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerMillimeter(wattpermeter.MilliwattsPerMillimeter).WattsPerMeter, MilliwattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerCentimeter(wattpermeter.WattsPerCentimeter).WattsPerMeter, WattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerFoot(wattpermeter.WattsPerFoot).WattsPerMeter, WattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerInch(wattpermeter.WattsPerInch).WattsPerMeter, WattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerMeter(wattpermeter.WattsPerMeter).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerMillimeter(wattpermeter.WattsPerMillimeter).WattsPerMeter, WattsPerMillimeterTolerance);
+            LinearPowerDensity<double> wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromGigawattsPerCentimeter(wattpermeter.GigawattsPerCentimeter).WattsPerMeter, GigawattsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromGigawattsPerFoot(wattpermeter.GigawattsPerFoot).WattsPerMeter, GigawattsPerFootTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromGigawattsPerInch(wattpermeter.GigawattsPerInch).WattsPerMeter, GigawattsPerInchTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromGigawattsPerMeter(wattpermeter.GigawattsPerMeter).WattsPerMeter, GigawattsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromGigawattsPerMillimeter(wattpermeter.GigawattsPerMillimeter).WattsPerMeter, GigawattsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromKilowattsPerCentimeter(wattpermeter.KilowattsPerCentimeter).WattsPerMeter, KilowattsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromKilowattsPerFoot(wattpermeter.KilowattsPerFoot).WattsPerMeter, KilowattsPerFootTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromKilowattsPerInch(wattpermeter.KilowattsPerInch).WattsPerMeter, KilowattsPerInchTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromKilowattsPerMeter(wattpermeter.KilowattsPerMeter).WattsPerMeter, KilowattsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromKilowattsPerMillimeter(wattpermeter.KilowattsPerMillimeter).WattsPerMeter, KilowattsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMegawattsPerCentimeter(wattpermeter.MegawattsPerCentimeter).WattsPerMeter, MegawattsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMegawattsPerFoot(wattpermeter.MegawattsPerFoot).WattsPerMeter, MegawattsPerFootTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMegawattsPerInch(wattpermeter.MegawattsPerInch).WattsPerMeter, MegawattsPerInchTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMegawattsPerMeter(wattpermeter.MegawattsPerMeter).WattsPerMeter, MegawattsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMegawattsPerMillimeter(wattpermeter.MegawattsPerMillimeter).WattsPerMeter, MegawattsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMilliwattsPerCentimeter(wattpermeter.MilliwattsPerCentimeter).WattsPerMeter, MilliwattsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMilliwattsPerFoot(wattpermeter.MilliwattsPerFoot).WattsPerMeter, MilliwattsPerFootTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMilliwattsPerInch(wattpermeter.MilliwattsPerInch).WattsPerMeter, MilliwattsPerInchTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMilliwattsPerMeter(wattpermeter.MilliwattsPerMeter).WattsPerMeter, MilliwattsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromMilliwattsPerMillimeter(wattpermeter.MilliwattsPerMillimeter).WattsPerMeter, MilliwattsPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromWattsPerCentimeter(wattpermeter.WattsPerCentimeter).WattsPerMeter, WattsPerCentimeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromWattsPerFoot(wattpermeter.WattsPerFoot).WattsPerMeter, WattsPerFootTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromWattsPerInch(wattpermeter.WattsPerInch).WattsPerMeter, WattsPerInchTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromWattsPerMeter(wattpermeter.WattsPerMeter).WattsPerMeter, WattsPerMeterTolerance);
+            AssertEx.EqualTolerance(1, LinearPowerDensity<double>.FromWattsPerMillimeter(wattpermeter.WattsPerMillimeter).WattsPerMeter, WattsPerMillimeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            LinearPowerDensity v = LinearPowerDensity.FromWattsPerMeter(1);
+            LinearPowerDensity<double> v = LinearPowerDensity<double>.FromWattsPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearPowerDensity.FromWattsPerMeter(3)-v).WattsPerMeter, WattsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (LinearPowerDensity<double>.FromWattsPerMeter(3)-v).WattsPerMeter, WattsPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).WattsPerMeter, WattsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).WattsPerMeter, WattsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearPowerDensity.FromWattsPerMeter(10)/5).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, LinearPowerDensity.FromWattsPerMeter(10)/LinearPowerDensity.FromWattsPerMeter(5), WattsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (LinearPowerDensity<double>.FromWattsPerMeter(10)/5).WattsPerMeter, WattsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, LinearPowerDensity<double>.FromWattsPerMeter(10)/LinearPowerDensity<double>.FromWattsPerMeter(5), WattsPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            LinearPowerDensity oneWattPerMeter = LinearPowerDensity.FromWattsPerMeter(1);
-            LinearPowerDensity twoWattsPerMeter = LinearPowerDensity.FromWattsPerMeter(2);
+            LinearPowerDensity<double> oneWattPerMeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
+            LinearPowerDensity<double> twoWattsPerMeter = LinearPowerDensity<double>.FromWattsPerMeter(2);
 
             Assert.True(oneWattPerMeter < twoWattsPerMeter);
             Assert.True(oneWattPerMeter <= twoWattsPerMeter);
@@ -533,31 +533,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            LinearPowerDensity<double> wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
             Assert.Equal(0, wattpermeter.CompareTo(wattpermeter));
-            Assert.True(wattpermeter.CompareTo(LinearPowerDensity.Zero) > 0);
-            Assert.True(LinearPowerDensity.Zero.CompareTo(wattpermeter) < 0);
+            Assert.True(wattpermeter.CompareTo(LinearPowerDensity<double>.Zero) > 0);
+            Assert.True(LinearPowerDensity<double>.Zero.CompareTo(wattpermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            LinearPowerDensity<double> wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
             Assert.Throws<ArgumentException>(() => wattpermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            LinearPowerDensity<double> wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => wattpermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = LinearPowerDensity.FromWattsPerMeter(1);
-            var b = LinearPowerDensity.FromWattsPerMeter(2);
+            var a = LinearPowerDensity<double>.FromWattsPerMeter(1);
+            var b = LinearPowerDensity<double>.FromWattsPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -576,8 +576,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = LinearPowerDensity.FromWattsPerMeter(1);
-            var b = LinearPowerDensity.FromWattsPerMeter(2);
+            var a = LinearPowerDensity<double>.FromWattsPerMeter(1);
+            var b = LinearPowerDensity<double>.FromWattsPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -597,9 +597,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = LinearPowerDensity.FromWattsPerMeter(1);
-            Assert.True(v.Equals(LinearPowerDensity.FromWattsPerMeter(1), WattsPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(LinearPowerDensity.Zero, WattsPerMeterTolerance, ComparisonType.Relative));
+            var v = LinearPowerDensity<double>.FromWattsPerMeter(1);
+            Assert.True(v.Equals(LinearPowerDensity<double>.FromWattsPerMeter(1), WattsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LinearPowerDensity<double>.Zero, WattsPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -612,21 +612,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            LinearPowerDensity<double> wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
             Assert.False(wattpermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
+            LinearPowerDensity<double> wattpermeter = LinearPowerDensity<double>.FromWattsPerMeter(1);
             Assert.False(wattpermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LinearPowerDensityUnit.Undefined, LinearPowerDensity.Units);
+            Assert.DoesNotContain(LinearPowerDensityUnit.Undefined, LinearPowerDensity<double>.Units);
         }
 
         [Fact]
@@ -645,7 +645,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(LinearPowerDensity.BaseDimensions is null);
+            Assert.False(LinearPowerDensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs
index 73a8415d7f..747179577a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs
@@ -72,7 +72,7 @@ public abstract partial class LuminosityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Luminosity((double)0.0, LuminosityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>((double)0.0, LuminosityUnit.Undefined));
         }
 
         [Fact]
@@ -87,14 +87,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Luminosity(double.PositiveInfinity, LuminosityUnit.Watt));
-            Assert.Throws<ArgumentException>(() => new Luminosity(double.NegativeInfinity, LuminosityUnit.Watt));
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>(double.PositiveInfinity, LuminosityUnit.Watt));
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>(double.NegativeInfinity, LuminosityUnit.Watt));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Luminosity(double.NaN, LuminosityUnit.Watt));
+            Assert.Throws<ArgumentException>(() => new Luminosity<double>(double.NaN, LuminosityUnit.Watt));
         }
 
         [Fact]
@@ -140,7 +140,7 @@ public void Luminosity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void WattToLuminosityUnits()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
             AssertEx.EqualTolerance(DecawattsInOneWatt, watt.Decawatts, DecawattsTolerance);
             AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.Deciwatts, DeciwattsTolerance);
             AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.Femtowatts, FemtowattsTolerance);
@@ -160,59 +160,59 @@ public void WattToLuminosityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Luminosity.From(1, LuminosityUnit.Decawatt);
+            var quantity00 = Luminosity<double>.From(1, LuminosityUnit.Decawatt);
             AssertEx.EqualTolerance(1, quantity00.Decawatts, DecawattsTolerance);
             Assert.Equal(LuminosityUnit.Decawatt, quantity00.Unit);
 
-            var quantity01 = Luminosity.From(1, LuminosityUnit.Deciwatt);
+            var quantity01 = Luminosity<double>.From(1, LuminosityUnit.Deciwatt);
             AssertEx.EqualTolerance(1, quantity01.Deciwatts, DeciwattsTolerance);
             Assert.Equal(LuminosityUnit.Deciwatt, quantity01.Unit);
 
-            var quantity02 = Luminosity.From(1, LuminosityUnit.Femtowatt);
+            var quantity02 = Luminosity<double>.From(1, LuminosityUnit.Femtowatt);
             AssertEx.EqualTolerance(1, quantity02.Femtowatts, FemtowattsTolerance);
             Assert.Equal(LuminosityUnit.Femtowatt, quantity02.Unit);
 
-            var quantity03 = Luminosity.From(1, LuminosityUnit.Gigawatt);
+            var quantity03 = Luminosity<double>.From(1, LuminosityUnit.Gigawatt);
             AssertEx.EqualTolerance(1, quantity03.Gigawatts, GigawattsTolerance);
             Assert.Equal(LuminosityUnit.Gigawatt, quantity03.Unit);
 
-            var quantity04 = Luminosity.From(1, LuminosityUnit.Kilowatt);
+            var quantity04 = Luminosity<double>.From(1, LuminosityUnit.Kilowatt);
             AssertEx.EqualTolerance(1, quantity04.Kilowatts, KilowattsTolerance);
             Assert.Equal(LuminosityUnit.Kilowatt, quantity04.Unit);
 
-            var quantity05 = Luminosity.From(1, LuminosityUnit.Megawatt);
+            var quantity05 = Luminosity<double>.From(1, LuminosityUnit.Megawatt);
             AssertEx.EqualTolerance(1, quantity05.Megawatts, MegawattsTolerance);
             Assert.Equal(LuminosityUnit.Megawatt, quantity05.Unit);
 
-            var quantity06 = Luminosity.From(1, LuminosityUnit.Microwatt);
+            var quantity06 = Luminosity<double>.From(1, LuminosityUnit.Microwatt);
             AssertEx.EqualTolerance(1, quantity06.Microwatts, MicrowattsTolerance);
             Assert.Equal(LuminosityUnit.Microwatt, quantity06.Unit);
 
-            var quantity07 = Luminosity.From(1, LuminosityUnit.Milliwatt);
+            var quantity07 = Luminosity<double>.From(1, LuminosityUnit.Milliwatt);
             AssertEx.EqualTolerance(1, quantity07.Milliwatts, MilliwattsTolerance);
             Assert.Equal(LuminosityUnit.Milliwatt, quantity07.Unit);
 
-            var quantity08 = Luminosity.From(1, LuminosityUnit.Nanowatt);
+            var quantity08 = Luminosity<double>.From(1, LuminosityUnit.Nanowatt);
             AssertEx.EqualTolerance(1, quantity08.Nanowatts, NanowattsTolerance);
             Assert.Equal(LuminosityUnit.Nanowatt, quantity08.Unit);
 
-            var quantity09 = Luminosity.From(1, LuminosityUnit.Petawatt);
+            var quantity09 = Luminosity<double>.From(1, LuminosityUnit.Petawatt);
             AssertEx.EqualTolerance(1, quantity09.Petawatts, PetawattsTolerance);
             Assert.Equal(LuminosityUnit.Petawatt, quantity09.Unit);
 
-            var quantity10 = Luminosity.From(1, LuminosityUnit.Picowatt);
+            var quantity10 = Luminosity<double>.From(1, LuminosityUnit.Picowatt);
             AssertEx.EqualTolerance(1, quantity10.Picowatts, PicowattsTolerance);
             Assert.Equal(LuminosityUnit.Picowatt, quantity10.Unit);
 
-            var quantity11 = Luminosity.From(1, LuminosityUnit.SolarLuminosity);
+            var quantity11 = Luminosity<double>.From(1, LuminosityUnit.SolarLuminosity);
             AssertEx.EqualTolerance(1, quantity11.SolarLuminosities, SolarLuminositiesTolerance);
             Assert.Equal(LuminosityUnit.SolarLuminosity, quantity11.Unit);
 
-            var quantity12 = Luminosity.From(1, LuminosityUnit.Terawatt);
+            var quantity12 = Luminosity<double>.From(1, LuminosityUnit.Terawatt);
             AssertEx.EqualTolerance(1, quantity12.Terawatts, TerawattsTolerance);
             Assert.Equal(LuminosityUnit.Terawatt, quantity12.Unit);
 
-            var quantity13 = Luminosity.From(1, LuminosityUnit.Watt);
+            var quantity13 = Luminosity<double>.From(1, LuminosityUnit.Watt);
             AssertEx.EqualTolerance(1, quantity13.Watts, WattsTolerance);
             Assert.Equal(LuminosityUnit.Watt, quantity13.Unit);
 
@@ -221,20 +221,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWatts_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Luminosity.FromWatts(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Luminosity.FromWatts(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Luminosity<double>.FromWatts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Luminosity<double>.FromWatts(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWatts_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Luminosity.FromWatts(double.NaN));
+            Assert.Throws<ArgumentException>(() => Luminosity<double>.FromWatts(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var watt = Luminosity.FromWatts(1);
+            var watt = Luminosity<double>.FromWatts(1);
             AssertEx.EqualTolerance(DecawattsInOneWatt, watt.As(LuminosityUnit.Decawatt), DecawattsTolerance);
             AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.As(LuminosityUnit.Deciwatt), DeciwattsTolerance);
             AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.As(LuminosityUnit.Femtowatt), FemtowattsTolerance);
@@ -271,7 +271,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var watt = Luminosity.FromWatts(1);
+            var watt = Luminosity<double>.FromWatts(1);
 
             var decawattQuantity = watt.ToUnit(LuminosityUnit.Decawatt);
             AssertEx.EqualTolerance(DecawattsInOneWatt, (double)decawattQuantity.Value, DecawattsTolerance);
@@ -340,41 +340,41 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
-            AssertEx.EqualTolerance(1, Luminosity.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromSolarLuminosities(watt.SolarLuminosities).Watts, SolarLuminositiesTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromWatts(watt.Watts).Watts, WattsTolerance);
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromSolarLuminosities(watt.SolarLuminosities).Watts, SolarLuminositiesTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
+            AssertEx.EqualTolerance(1, Luminosity<double>.FromWatts(watt.Watts).Watts, WattsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Luminosity v = Luminosity.FromWatts(1);
+            Luminosity<double> v = Luminosity<double>.FromWatts(1);
             AssertEx.EqualTolerance(-1, -v.Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Luminosity.FromWatts(3)-v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (Luminosity<double>.FromWatts(3)-v).Watts, WattsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Watts, WattsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Watts, WattsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Luminosity.FromWatts(10)/5).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, Luminosity.FromWatts(10)/Luminosity.FromWatts(5), WattsTolerance);
+            AssertEx.EqualTolerance(2, (Luminosity<double>.FromWatts(10)/5).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, Luminosity<double>.FromWatts(10)/Luminosity<double>.FromWatts(5), WattsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Luminosity oneWatt = Luminosity.FromWatts(1);
-            Luminosity twoWatts = Luminosity.FromWatts(2);
+            Luminosity<double> oneWatt = Luminosity<double>.FromWatts(1);
+            Luminosity<double> twoWatts = Luminosity<double>.FromWatts(2);
 
             Assert.True(oneWatt < twoWatts);
             Assert.True(oneWatt <= twoWatts);
@@ -390,31 +390,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
             Assert.Equal(0, watt.CompareTo(watt));
-            Assert.True(watt.CompareTo(Luminosity.Zero) > 0);
-            Assert.True(Luminosity.Zero.CompareTo(watt) < 0);
+            Assert.True(watt.CompareTo(Luminosity<double>.Zero) > 0);
+            Assert.True(Luminosity<double>.Zero.CompareTo(watt) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
             Assert.Throws<ArgumentException>(() => watt.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
             Assert.Throws<ArgumentNullException>(() => watt.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Luminosity.FromWatts(1);
-            var b = Luminosity.FromWatts(2);
+            var a = Luminosity<double>.FromWatts(1);
+            var b = Luminosity<double>.FromWatts(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -433,8 +433,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Luminosity.FromWatts(1);
-            var b = Luminosity.FromWatts(2);
+            var a = Luminosity<double>.FromWatts(1);
+            var b = Luminosity<double>.FromWatts(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -454,9 +454,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Luminosity.FromWatts(1);
-            Assert.True(v.Equals(Luminosity.FromWatts(1), WattsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Luminosity.Zero, WattsTolerance, ComparisonType.Relative));
+            var v = Luminosity<double>.FromWatts(1);
+            Assert.True(v.Equals(Luminosity<double>.FromWatts(1), WattsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Luminosity<double>.Zero, WattsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -469,21 +469,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
             Assert.False(watt.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
+            Luminosity<double> watt = Luminosity<double>.FromWatts(1);
             Assert.False(watt.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LuminosityUnit.Undefined, Luminosity.Units);
+            Assert.DoesNotContain(LuminosityUnit.Undefined, Luminosity<double>.Units);
         }
 
         [Fact]
@@ -502,7 +502,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Luminosity.BaseDimensions is null);
+            Assert.False(Luminosity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs
index 8d4b78a299..560aa9e966 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class LuminousFluxTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LuminousFlux((double)0.0, LuminousFluxUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>((double)0.0, LuminousFluxUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LuminousFlux(double.PositiveInfinity, LuminousFluxUnit.Lumen));
-            Assert.Throws<ArgumentException>(() => new LuminousFlux(double.NegativeInfinity, LuminousFluxUnit.Lumen));
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>(double.PositiveInfinity, LuminousFluxUnit.Lumen));
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>(double.NegativeInfinity, LuminousFluxUnit.Lumen));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LuminousFlux(double.NaN, LuminousFluxUnit.Lumen));
+            Assert.Throws<ArgumentException>(() => new LuminousFlux<double>(double.NaN, LuminousFluxUnit.Lumen));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void LuminousFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void LumenToLuminousFluxUnits()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
             AssertEx.EqualTolerance(LumensInOneLumen, lumen.Lumens, LumensTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = LuminousFlux.From(1, LuminousFluxUnit.Lumen);
+            var quantity00 = LuminousFlux<double>.From(1, LuminousFluxUnit.Lumen);
             AssertEx.EqualTolerance(1, quantity00.Lumens, LumensTolerance);
             Assert.Equal(LuminousFluxUnit.Lumen, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromLumens_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LuminousFlux.FromLumens(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => LuminousFlux.FromLumens(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => LuminousFlux<double>.FromLumens(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LuminousFlux<double>.FromLumens(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromLumens_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LuminousFlux.FromLumens(double.NaN));
+            Assert.Throws<ArgumentException>(() => LuminousFlux<double>.FromLumens(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var lumen = LuminousFlux.FromLumens(1);
+            var lumen = LuminousFlux<double>.FromLumens(1);
             AssertEx.EqualTolerance(LumensInOneLumen, lumen.As(LuminousFluxUnit.Lumen), LumensTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var lumen = LuminousFlux.FromLumens(1);
+            var lumen = LuminousFlux<double>.FromLumens(1);
 
             var lumenQuantity = lumen.ToUnit(LuminousFluxUnit.Lumen);
             AssertEx.EqualTolerance(LumensInOneLumen, (double)lumenQuantity.Value, LumensTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
-            AssertEx.EqualTolerance(1, LuminousFlux.FromLumens(lumen.Lumens).Lumens, LumensTolerance);
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
+            AssertEx.EqualTolerance(1, LuminousFlux<double>.FromLumens(lumen.Lumens).Lumens, LumensTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            LuminousFlux v = LuminousFlux.FromLumens(1);
+            LuminousFlux<double> v = LuminousFlux<double>.FromLumens(1);
             AssertEx.EqualTolerance(-1, -v.Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(2, (LuminousFlux.FromLumens(3)-v).Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(2, (LuminousFlux<double>.FromLumens(3)-v).Lumens, LumensTolerance);
             AssertEx.EqualTolerance(2, (v + v).Lumens, LumensTolerance);
             AssertEx.EqualTolerance(10, (v*10).Lumens, LumensTolerance);
             AssertEx.EqualTolerance(10, (10*v).Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(2, (LuminousFlux.FromLumens(10)/5).Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(2, LuminousFlux.FromLumens(10)/LuminousFlux.FromLumens(5), LumensTolerance);
+            AssertEx.EqualTolerance(2, (LuminousFlux<double>.FromLumens(10)/5).Lumens, LumensTolerance);
+            AssertEx.EqualTolerance(2, LuminousFlux<double>.FromLumens(10)/LuminousFlux<double>.FromLumens(5), LumensTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            LuminousFlux oneLumen = LuminousFlux.FromLumens(1);
-            LuminousFlux twoLumens = LuminousFlux.FromLumens(2);
+            LuminousFlux<double> oneLumen = LuminousFlux<double>.FromLumens(1);
+            LuminousFlux<double> twoLumens = LuminousFlux<double>.FromLumens(2);
 
             Assert.True(oneLumen < twoLumens);
             Assert.True(oneLumen <= twoLumens);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
             Assert.Equal(0, lumen.CompareTo(lumen));
-            Assert.True(lumen.CompareTo(LuminousFlux.Zero) > 0);
-            Assert.True(LuminousFlux.Zero.CompareTo(lumen) < 0);
+            Assert.True(lumen.CompareTo(LuminousFlux<double>.Zero) > 0);
+            Assert.True(LuminousFlux<double>.Zero.CompareTo(lumen) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
             Assert.Throws<ArgumentException>(() => lumen.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
             Assert.Throws<ArgumentNullException>(() => lumen.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = LuminousFlux.FromLumens(1);
-            var b = LuminousFlux.FromLumens(2);
+            var a = LuminousFlux<double>.FromLumens(1);
+            var b = LuminousFlux<double>.FromLumens(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = LuminousFlux.FromLumens(1);
-            var b = LuminousFlux.FromLumens(2);
+            var a = LuminousFlux<double>.FromLumens(1);
+            var b = LuminousFlux<double>.FromLumens(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = LuminousFlux.FromLumens(1);
-            Assert.True(v.Equals(LuminousFlux.FromLumens(1), LumensTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(LuminousFlux.Zero, LumensTolerance, ComparisonType.Relative));
+            var v = LuminousFlux<double>.FromLumens(1);
+            Assert.True(v.Equals(LuminousFlux<double>.FromLumens(1), LumensTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LuminousFlux<double>.Zero, LumensTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
             Assert.False(lumen.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
+            LuminousFlux<double> lumen = LuminousFlux<double>.FromLumens(1);
             Assert.False(lumen.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LuminousFluxUnit.Undefined, LuminousFlux.Units);
+            Assert.DoesNotContain(LuminousFluxUnit.Undefined, LuminousFlux<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(LuminousFlux.BaseDimensions is null);
+            Assert.False(LuminousFlux<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs
index 0e6e307400..d311aa1894 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class LuminousIntensityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LuminousIntensity((double)0.0, LuminousIntensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>((double)0.0, LuminousIntensityUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LuminousIntensity(double.PositiveInfinity, LuminousIntensityUnit.Candela));
-            Assert.Throws<ArgumentException>(() => new LuminousIntensity(double.NegativeInfinity, LuminousIntensityUnit.Candela));
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>(double.PositiveInfinity, LuminousIntensityUnit.Candela));
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>(double.NegativeInfinity, LuminousIntensityUnit.Candela));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new LuminousIntensity(double.NaN, LuminousIntensityUnit.Candela));
+            Assert.Throws<ArgumentException>(() => new LuminousIntensity<double>(double.NaN, LuminousIntensityUnit.Candela));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void LuminousIntensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
         [Fact]
         public void CandelaToLuminousIntensityUnits()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
             AssertEx.EqualTolerance(CandelaInOneCandela, candela.Candela, CandelaTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = LuminousIntensity.From(1, LuminousIntensityUnit.Candela);
+            var quantity00 = LuminousIntensity<double>.From(1, LuminousIntensityUnit.Candela);
             AssertEx.EqualTolerance(1, quantity00.Candela, CandelaTolerance);
             Assert.Equal(LuminousIntensityUnit.Candela, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCandela_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LuminousIntensity.FromCandela(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => LuminousIntensity.FromCandela(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => LuminousIntensity<double>.FromCandela(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => LuminousIntensity<double>.FromCandela(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCandela_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => LuminousIntensity.FromCandela(double.NaN));
+            Assert.Throws<ArgumentException>(() => LuminousIntensity<double>.FromCandela(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var candela = LuminousIntensity.FromCandela(1);
+            var candela = LuminousIntensity<double>.FromCandela(1);
             AssertEx.EqualTolerance(CandelaInOneCandela, candela.As(LuminousIntensityUnit.Candela), CandelaTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var candela = LuminousIntensity.FromCandela(1);
+            var candela = LuminousIntensity<double>.FromCandela(1);
 
             var candelaQuantity = candela.ToUnit(LuminousIntensityUnit.Candela);
             AssertEx.EqualTolerance(CandelaInOneCandela, (double)candelaQuantity.Value, CandelaTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
-            AssertEx.EqualTolerance(1, LuminousIntensity.FromCandela(candela.Candela).Candela, CandelaTolerance);
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
+            AssertEx.EqualTolerance(1, LuminousIntensity<double>.FromCandela(candela.Candela).Candela, CandelaTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            LuminousIntensity v = LuminousIntensity.FromCandela(1);
+            LuminousIntensity<double> v = LuminousIntensity<double>.FromCandela(1);
             AssertEx.EqualTolerance(-1, -v.Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(2, (LuminousIntensity.FromCandela(3)-v).Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(2, (LuminousIntensity<double>.FromCandela(3)-v).Candela, CandelaTolerance);
             AssertEx.EqualTolerance(2, (v + v).Candela, CandelaTolerance);
             AssertEx.EqualTolerance(10, (v*10).Candela, CandelaTolerance);
             AssertEx.EqualTolerance(10, (10*v).Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(2, (LuminousIntensity.FromCandela(10)/5).Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(2, LuminousIntensity.FromCandela(10)/LuminousIntensity.FromCandela(5), CandelaTolerance);
+            AssertEx.EqualTolerance(2, (LuminousIntensity<double>.FromCandela(10)/5).Candela, CandelaTolerance);
+            AssertEx.EqualTolerance(2, LuminousIntensity<double>.FromCandela(10)/LuminousIntensity<double>.FromCandela(5), CandelaTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            LuminousIntensity oneCandela = LuminousIntensity.FromCandela(1);
-            LuminousIntensity twoCandela = LuminousIntensity.FromCandela(2);
+            LuminousIntensity<double> oneCandela = LuminousIntensity<double>.FromCandela(1);
+            LuminousIntensity<double> twoCandela = LuminousIntensity<double>.FromCandela(2);
 
             Assert.True(oneCandela < twoCandela);
             Assert.True(oneCandela <= twoCandela);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
             Assert.Equal(0, candela.CompareTo(candela));
-            Assert.True(candela.CompareTo(LuminousIntensity.Zero) > 0);
-            Assert.True(LuminousIntensity.Zero.CompareTo(candela) < 0);
+            Assert.True(candela.CompareTo(LuminousIntensity<double>.Zero) > 0);
+            Assert.True(LuminousIntensity<double>.Zero.CompareTo(candela) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
             Assert.Throws<ArgumentException>(() => candela.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
             Assert.Throws<ArgumentNullException>(() => candela.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = LuminousIntensity.FromCandela(1);
-            var b = LuminousIntensity.FromCandela(2);
+            var a = LuminousIntensity<double>.FromCandela(1);
+            var b = LuminousIntensity<double>.FromCandela(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = LuminousIntensity.FromCandela(1);
-            var b = LuminousIntensity.FromCandela(2);
+            var a = LuminousIntensity<double>.FromCandela(1);
+            var b = LuminousIntensity<double>.FromCandela(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = LuminousIntensity.FromCandela(1);
-            Assert.True(v.Equals(LuminousIntensity.FromCandela(1), CandelaTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(LuminousIntensity.Zero, CandelaTolerance, ComparisonType.Relative));
+            var v = LuminousIntensity<double>.FromCandela(1);
+            Assert.True(v.Equals(LuminousIntensity<double>.FromCandela(1), CandelaTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(LuminousIntensity<double>.Zero, CandelaTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
             Assert.False(candela.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
+            LuminousIntensity<double> candela = LuminousIntensity<double>.FromCandela(1);
             Assert.False(candela.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(LuminousIntensityUnit.Undefined, LuminousIntensity.Units);
+            Assert.DoesNotContain(LuminousIntensityUnit.Undefined, LuminousIntensity<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(LuminousIntensity.BaseDimensions is null);
+            Assert.False(LuminousIntensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs
index 95e3c606ff..ebf21924f8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs
@@ -54,7 +54,7 @@ public abstract partial class MagneticFieldTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MagneticField((double)0.0, MagneticFieldUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>((double)0.0, MagneticFieldUnit.Undefined));
         }
 
         [Fact]
@@ -69,14 +69,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MagneticField(double.PositiveInfinity, MagneticFieldUnit.Tesla));
-            Assert.Throws<ArgumentException>(() => new MagneticField(double.NegativeInfinity, MagneticFieldUnit.Tesla));
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>(double.PositiveInfinity, MagneticFieldUnit.Tesla));
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>(double.NegativeInfinity, MagneticFieldUnit.Tesla));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MagneticField(double.NaN, MagneticFieldUnit.Tesla));
+            Assert.Throws<ArgumentException>(() => new MagneticField<double>(double.NaN, MagneticFieldUnit.Tesla));
         }
 
         [Fact]
@@ -122,7 +122,7 @@ public void MagneticField_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void TeslaToMagneticFieldUnits()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
             AssertEx.EqualTolerance(GaussesInOneTesla, tesla.Gausses, GaussesTolerance);
             AssertEx.EqualTolerance(MicroteslasInOneTesla, tesla.Microteslas, MicroteslasTolerance);
             AssertEx.EqualTolerance(MilliteslasInOneTesla, tesla.Milliteslas, MilliteslasTolerance);
@@ -133,23 +133,23 @@ public void TeslaToMagneticFieldUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MagneticField.From(1, MagneticFieldUnit.Gauss);
+            var quantity00 = MagneticField<double>.From(1, MagneticFieldUnit.Gauss);
             AssertEx.EqualTolerance(1, quantity00.Gausses, GaussesTolerance);
             Assert.Equal(MagneticFieldUnit.Gauss, quantity00.Unit);
 
-            var quantity01 = MagneticField.From(1, MagneticFieldUnit.Microtesla);
+            var quantity01 = MagneticField<double>.From(1, MagneticFieldUnit.Microtesla);
             AssertEx.EqualTolerance(1, quantity01.Microteslas, MicroteslasTolerance);
             Assert.Equal(MagneticFieldUnit.Microtesla, quantity01.Unit);
 
-            var quantity02 = MagneticField.From(1, MagneticFieldUnit.Millitesla);
+            var quantity02 = MagneticField<double>.From(1, MagneticFieldUnit.Millitesla);
             AssertEx.EqualTolerance(1, quantity02.Milliteslas, MilliteslasTolerance);
             Assert.Equal(MagneticFieldUnit.Millitesla, quantity02.Unit);
 
-            var quantity03 = MagneticField.From(1, MagneticFieldUnit.Nanotesla);
+            var quantity03 = MagneticField<double>.From(1, MagneticFieldUnit.Nanotesla);
             AssertEx.EqualTolerance(1, quantity03.Nanoteslas, NanoteslasTolerance);
             Assert.Equal(MagneticFieldUnit.Nanotesla, quantity03.Unit);
 
-            var quantity04 = MagneticField.From(1, MagneticFieldUnit.Tesla);
+            var quantity04 = MagneticField<double>.From(1, MagneticFieldUnit.Tesla);
             AssertEx.EqualTolerance(1, quantity04.Teslas, TeslasTolerance);
             Assert.Equal(MagneticFieldUnit.Tesla, quantity04.Unit);
 
@@ -158,20 +158,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromTeslas_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MagneticField.FromTeslas(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MagneticField.FromTeslas(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MagneticField<double>.FromTeslas(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MagneticField<double>.FromTeslas(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromTeslas_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MagneticField.FromTeslas(double.NaN));
+            Assert.Throws<ArgumentException>(() => MagneticField<double>.FromTeslas(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var tesla = MagneticField.FromTeslas(1);
+            var tesla = MagneticField<double>.FromTeslas(1);
             AssertEx.EqualTolerance(GaussesInOneTesla, tesla.As(MagneticFieldUnit.Gauss), GaussesTolerance);
             AssertEx.EqualTolerance(MicroteslasInOneTesla, tesla.As(MagneticFieldUnit.Microtesla), MicroteslasTolerance);
             AssertEx.EqualTolerance(MilliteslasInOneTesla, tesla.As(MagneticFieldUnit.Millitesla), MilliteslasTolerance);
@@ -199,7 +199,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var tesla = MagneticField.FromTeslas(1);
+            var tesla = MagneticField<double>.FromTeslas(1);
 
             var gaussQuantity = tesla.ToUnit(MagneticFieldUnit.Gauss);
             AssertEx.EqualTolerance(GaussesInOneTesla, (double)gaussQuantity.Value, GaussesTolerance);
@@ -232,32 +232,32 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
-            AssertEx.EqualTolerance(1, MagneticField.FromGausses(tesla.Gausses).Teslas, GaussesTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromMicroteslas(tesla.Microteslas).Teslas, MicroteslasTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromMilliteslas(tesla.Milliteslas).Teslas, MilliteslasTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromNanoteslas(tesla.Nanoteslas).Teslas, NanoteslasTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromTeslas(tesla.Teslas).Teslas, TeslasTolerance);
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromGausses(tesla.Gausses).Teslas, GaussesTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromMicroteslas(tesla.Microteslas).Teslas, MicroteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromMilliteslas(tesla.Milliteslas).Teslas, MilliteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromNanoteslas(tesla.Nanoteslas).Teslas, NanoteslasTolerance);
+            AssertEx.EqualTolerance(1, MagneticField<double>.FromTeslas(tesla.Teslas).Teslas, TeslasTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MagneticField v = MagneticField.FromTeslas(1);
+            MagneticField<double> v = MagneticField<double>.FromTeslas(1);
             AssertEx.EqualTolerance(-1, -v.Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(2, (MagneticField.FromTeslas(3)-v).Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(2, (MagneticField<double>.FromTeslas(3)-v).Teslas, TeslasTolerance);
             AssertEx.EqualTolerance(2, (v + v).Teslas, TeslasTolerance);
             AssertEx.EqualTolerance(10, (v*10).Teslas, TeslasTolerance);
             AssertEx.EqualTolerance(10, (10*v).Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(2, (MagneticField.FromTeslas(10)/5).Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(2, MagneticField.FromTeslas(10)/MagneticField.FromTeslas(5), TeslasTolerance);
+            AssertEx.EqualTolerance(2, (MagneticField<double>.FromTeslas(10)/5).Teslas, TeslasTolerance);
+            AssertEx.EqualTolerance(2, MagneticField<double>.FromTeslas(10)/MagneticField<double>.FromTeslas(5), TeslasTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MagneticField oneTesla = MagneticField.FromTeslas(1);
-            MagneticField twoTeslas = MagneticField.FromTeslas(2);
+            MagneticField<double> oneTesla = MagneticField<double>.FromTeslas(1);
+            MagneticField<double> twoTeslas = MagneticField<double>.FromTeslas(2);
 
             Assert.True(oneTesla < twoTeslas);
             Assert.True(oneTesla <= twoTeslas);
@@ -273,31 +273,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
             Assert.Equal(0, tesla.CompareTo(tesla));
-            Assert.True(tesla.CompareTo(MagneticField.Zero) > 0);
-            Assert.True(MagneticField.Zero.CompareTo(tesla) < 0);
+            Assert.True(tesla.CompareTo(MagneticField<double>.Zero) > 0);
+            Assert.True(MagneticField<double>.Zero.CompareTo(tesla) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
             Assert.Throws<ArgumentException>(() => tesla.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
             Assert.Throws<ArgumentNullException>(() => tesla.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MagneticField.FromTeslas(1);
-            var b = MagneticField.FromTeslas(2);
+            var a = MagneticField<double>.FromTeslas(1);
+            var b = MagneticField<double>.FromTeslas(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -316,8 +316,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MagneticField.FromTeslas(1);
-            var b = MagneticField.FromTeslas(2);
+            var a = MagneticField<double>.FromTeslas(1);
+            var b = MagneticField<double>.FromTeslas(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -337,9 +337,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MagneticField.FromTeslas(1);
-            Assert.True(v.Equals(MagneticField.FromTeslas(1), TeslasTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MagneticField.Zero, TeslasTolerance, ComparisonType.Relative));
+            var v = MagneticField<double>.FromTeslas(1);
+            Assert.True(v.Equals(MagneticField<double>.FromTeslas(1), TeslasTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MagneticField<double>.Zero, TeslasTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -352,21 +352,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
             Assert.False(tesla.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
+            MagneticField<double> tesla = MagneticField<double>.FromTeslas(1);
             Assert.False(tesla.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MagneticFieldUnit.Undefined, MagneticField.Units);
+            Assert.DoesNotContain(MagneticFieldUnit.Undefined, MagneticField<double>.Units);
         }
 
         [Fact]
@@ -385,7 +385,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MagneticField.BaseDimensions is null);
+            Assert.False(MagneticField<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs
index 1771a18323..fb504d99ee 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class MagneticFluxTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MagneticFlux((double)0.0, MagneticFluxUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>((double)0.0, MagneticFluxUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MagneticFlux(double.PositiveInfinity, MagneticFluxUnit.Weber));
-            Assert.Throws<ArgumentException>(() => new MagneticFlux(double.NegativeInfinity, MagneticFluxUnit.Weber));
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>(double.PositiveInfinity, MagneticFluxUnit.Weber));
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>(double.NegativeInfinity, MagneticFluxUnit.Weber));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MagneticFlux(double.NaN, MagneticFluxUnit.Weber));
+            Assert.Throws<ArgumentException>(() => new MagneticFlux<double>(double.NaN, MagneticFluxUnit.Weber));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void MagneticFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void WeberToMagneticFluxUnits()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
             AssertEx.EqualTolerance(WebersInOneWeber, weber.Webers, WebersTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MagneticFlux.From(1, MagneticFluxUnit.Weber);
+            var quantity00 = MagneticFlux<double>.From(1, MagneticFluxUnit.Weber);
             AssertEx.EqualTolerance(1, quantity00.Webers, WebersTolerance);
             Assert.Equal(MagneticFluxUnit.Weber, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWebers_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MagneticFlux.FromWebers(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MagneticFlux.FromWebers(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MagneticFlux<double>.FromWebers(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MagneticFlux<double>.FromWebers(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWebers_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MagneticFlux.FromWebers(double.NaN));
+            Assert.Throws<ArgumentException>(() => MagneticFlux<double>.FromWebers(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var weber = MagneticFlux.FromWebers(1);
+            var weber = MagneticFlux<double>.FromWebers(1);
             AssertEx.EqualTolerance(WebersInOneWeber, weber.As(MagneticFluxUnit.Weber), WebersTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var weber = MagneticFlux.FromWebers(1);
+            var weber = MagneticFlux<double>.FromWebers(1);
 
             var weberQuantity = weber.ToUnit(MagneticFluxUnit.Weber);
             AssertEx.EqualTolerance(WebersInOneWeber, (double)weberQuantity.Value, WebersTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
-            AssertEx.EqualTolerance(1, MagneticFlux.FromWebers(weber.Webers).Webers, WebersTolerance);
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
+            AssertEx.EqualTolerance(1, MagneticFlux<double>.FromWebers(weber.Webers).Webers, WebersTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MagneticFlux v = MagneticFlux.FromWebers(1);
+            MagneticFlux<double> v = MagneticFlux<double>.FromWebers(1);
             AssertEx.EqualTolerance(-1, -v.Webers, WebersTolerance);
-            AssertEx.EqualTolerance(2, (MagneticFlux.FromWebers(3)-v).Webers, WebersTolerance);
+            AssertEx.EqualTolerance(2, (MagneticFlux<double>.FromWebers(3)-v).Webers, WebersTolerance);
             AssertEx.EqualTolerance(2, (v + v).Webers, WebersTolerance);
             AssertEx.EqualTolerance(10, (v*10).Webers, WebersTolerance);
             AssertEx.EqualTolerance(10, (10*v).Webers, WebersTolerance);
-            AssertEx.EqualTolerance(2, (MagneticFlux.FromWebers(10)/5).Webers, WebersTolerance);
-            AssertEx.EqualTolerance(2, MagneticFlux.FromWebers(10)/MagneticFlux.FromWebers(5), WebersTolerance);
+            AssertEx.EqualTolerance(2, (MagneticFlux<double>.FromWebers(10)/5).Webers, WebersTolerance);
+            AssertEx.EqualTolerance(2, MagneticFlux<double>.FromWebers(10)/MagneticFlux<double>.FromWebers(5), WebersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MagneticFlux oneWeber = MagneticFlux.FromWebers(1);
-            MagneticFlux twoWebers = MagneticFlux.FromWebers(2);
+            MagneticFlux<double> oneWeber = MagneticFlux<double>.FromWebers(1);
+            MagneticFlux<double> twoWebers = MagneticFlux<double>.FromWebers(2);
 
             Assert.True(oneWeber < twoWebers);
             Assert.True(oneWeber <= twoWebers);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
             Assert.Equal(0, weber.CompareTo(weber));
-            Assert.True(weber.CompareTo(MagneticFlux.Zero) > 0);
-            Assert.True(MagneticFlux.Zero.CompareTo(weber) < 0);
+            Assert.True(weber.CompareTo(MagneticFlux<double>.Zero) > 0);
+            Assert.True(MagneticFlux<double>.Zero.CompareTo(weber) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
             Assert.Throws<ArgumentException>(() => weber.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
             Assert.Throws<ArgumentNullException>(() => weber.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MagneticFlux.FromWebers(1);
-            var b = MagneticFlux.FromWebers(2);
+            var a = MagneticFlux<double>.FromWebers(1);
+            var b = MagneticFlux<double>.FromWebers(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MagneticFlux.FromWebers(1);
-            var b = MagneticFlux.FromWebers(2);
+            var a = MagneticFlux<double>.FromWebers(1);
+            var b = MagneticFlux<double>.FromWebers(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MagneticFlux.FromWebers(1);
-            Assert.True(v.Equals(MagneticFlux.FromWebers(1), WebersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MagneticFlux.Zero, WebersTolerance, ComparisonType.Relative));
+            var v = MagneticFlux<double>.FromWebers(1);
+            Assert.True(v.Equals(MagneticFlux<double>.FromWebers(1), WebersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MagneticFlux<double>.Zero, WebersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
             Assert.False(weber.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
+            MagneticFlux<double> weber = MagneticFlux<double>.FromWebers(1);
             Assert.False(weber.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MagneticFluxUnit.Undefined, MagneticFlux.Units);
+            Assert.DoesNotContain(MagneticFluxUnit.Undefined, MagneticFlux<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MagneticFlux.BaseDimensions is null);
+            Assert.False(MagneticFlux<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs
index d0b173b2fe..49161dd0a8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class MagnetizationTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Magnetization((double)0.0, MagnetizationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>((double)0.0, MagnetizationUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Magnetization(double.PositiveInfinity, MagnetizationUnit.AmperePerMeter));
-            Assert.Throws<ArgumentException>(() => new Magnetization(double.NegativeInfinity, MagnetizationUnit.AmperePerMeter));
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>(double.PositiveInfinity, MagnetizationUnit.AmperePerMeter));
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>(double.NegativeInfinity, MagnetizationUnit.AmperePerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Magnetization(double.NaN, MagnetizationUnit.AmperePerMeter));
+            Assert.Throws<ArgumentException>(() => new Magnetization<double>(double.NaN, MagnetizationUnit.AmperePerMeter));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void Magnetization_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void AmperePerMeterToMagnetizationUnits()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
             AssertEx.EqualTolerance(AmperesPerMeterInOneAmperePerMeter, amperepermeter.AmperesPerMeter, AmperesPerMeterTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Magnetization.From(1, MagnetizationUnit.AmperePerMeter);
+            var quantity00 = Magnetization<double>.From(1, MagnetizationUnit.AmperePerMeter);
             AssertEx.EqualTolerance(1, quantity00.AmperesPerMeter, AmperesPerMeterTolerance);
             Assert.Equal(MagnetizationUnit.AmperePerMeter, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromAmperesPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Magnetization.FromAmperesPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Magnetization.FromAmperesPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Magnetization<double>.FromAmperesPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Magnetization<double>.FromAmperesPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromAmperesPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Magnetization.FromAmperesPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => Magnetization<double>.FromAmperesPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            var amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
             AssertEx.EqualTolerance(AmperesPerMeterInOneAmperePerMeter, amperepermeter.As(MagnetizationUnit.AmperePerMeter), AmperesPerMeterTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            var amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
 
             var amperepermeterQuantity = amperepermeter.ToUnit(MagnetizationUnit.AmperePerMeter);
             AssertEx.EqualTolerance(AmperesPerMeterInOneAmperePerMeter, (double)amperepermeterQuantity.Value, AmperesPerMeterTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
-            AssertEx.EqualTolerance(1, Magnetization.FromAmperesPerMeter(amperepermeter.AmperesPerMeter).AmperesPerMeter, AmperesPerMeterTolerance);
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
+            AssertEx.EqualTolerance(1, Magnetization<double>.FromAmperesPerMeter(amperepermeter.AmperesPerMeter).AmperesPerMeter, AmperesPerMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Magnetization v = Magnetization.FromAmperesPerMeter(1);
+            Magnetization<double> v = Magnetization<double>.FromAmperesPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Magnetization.FromAmperesPerMeter(3)-v).AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Magnetization<double>.FromAmperesPerMeter(3)-v).AmperesPerMeter, AmperesPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).AmperesPerMeter, AmperesPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).AmperesPerMeter, AmperesPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Magnetization.FromAmperesPerMeter(10)/5).AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, Magnetization.FromAmperesPerMeter(10)/Magnetization.FromAmperesPerMeter(5), AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Magnetization<double>.FromAmperesPerMeter(10)/5).AmperesPerMeter, AmperesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, Magnetization<double>.FromAmperesPerMeter(10)/Magnetization<double>.FromAmperesPerMeter(5), AmperesPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Magnetization oneAmperePerMeter = Magnetization.FromAmperesPerMeter(1);
-            Magnetization twoAmperesPerMeter = Magnetization.FromAmperesPerMeter(2);
+            Magnetization<double> oneAmperePerMeter = Magnetization<double>.FromAmperesPerMeter(1);
+            Magnetization<double> twoAmperesPerMeter = Magnetization<double>.FromAmperesPerMeter(2);
 
             Assert.True(oneAmperePerMeter < twoAmperesPerMeter);
             Assert.True(oneAmperePerMeter <= twoAmperesPerMeter);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
             Assert.Equal(0, amperepermeter.CompareTo(amperepermeter));
-            Assert.True(amperepermeter.CompareTo(Magnetization.Zero) > 0);
-            Assert.True(Magnetization.Zero.CompareTo(amperepermeter) < 0);
+            Assert.True(amperepermeter.CompareTo(Magnetization<double>.Zero) > 0);
+            Assert.True(Magnetization<double>.Zero.CompareTo(amperepermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
             Assert.Throws<ArgumentException>(() => amperepermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => amperepermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Magnetization.FromAmperesPerMeter(1);
-            var b = Magnetization.FromAmperesPerMeter(2);
+            var a = Magnetization<double>.FromAmperesPerMeter(1);
+            var b = Magnetization<double>.FromAmperesPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Magnetization.FromAmperesPerMeter(1);
-            var b = Magnetization.FromAmperesPerMeter(2);
+            var a = Magnetization<double>.FromAmperesPerMeter(1);
+            var b = Magnetization<double>.FromAmperesPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Magnetization.FromAmperesPerMeter(1);
-            Assert.True(v.Equals(Magnetization.FromAmperesPerMeter(1), AmperesPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Magnetization.Zero, AmperesPerMeterTolerance, ComparisonType.Relative));
+            var v = Magnetization<double>.FromAmperesPerMeter(1);
+            Assert.True(v.Equals(Magnetization<double>.FromAmperesPerMeter(1), AmperesPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Magnetization<double>.Zero, AmperesPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
             Assert.False(amperepermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
+            Magnetization<double> amperepermeter = Magnetization<double>.FromAmperesPerMeter(1);
             Assert.False(amperepermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MagnetizationUnit.Undefined, Magnetization.Units);
+            Assert.DoesNotContain(MagnetizationUnit.Undefined, Magnetization<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Magnetization.BaseDimensions is null);
+            Assert.False(Magnetization<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
index 8bcb3466a7..8ce6b94b3f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
@@ -138,7 +138,7 @@ public abstract partial class MassConcentrationTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassConcentration((double)0.0, MassConcentrationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MassConcentration<double>((double)0.0, MassConcentrationUnit.Undefined));
         }
 
         [Fact]
@@ -153,14 +153,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassConcentration(double.PositiveInfinity, MassConcentrationUnit.KilogramPerCubicMeter));
-            Assert.Throws<ArgumentException>(() => new MassConcentration(double.NegativeInfinity, MassConcentrationUnit.KilogramPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new MassConcentration<double>(double.PositiveInfinity, MassConcentrationUnit.KilogramPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new MassConcentration<double>(double.NegativeInfinity, MassConcentrationUnit.KilogramPerCubicMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassConcentration(double.NaN, MassConcentrationUnit.KilogramPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new MassConcentration<double>(double.NaN, MassConcentrationUnit.KilogramPerCubicMeter));
         }
 
         [Fact]
@@ -206,7 +206,7 @@ public void MassConcentration_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
         [Fact]
         public void KilogramPerCubicMeterToMassConcentrationUnits()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             AssertEx.EqualTolerance(CentigramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerDeciliter, CentigramsPerDeciliterTolerance);
             AssertEx.EqualTolerance(CentigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerLiter, CentigramsPerLiterTolerance);
             AssertEx.EqualTolerance(CentigramsPerMicroliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerMicroliter, CentigramsPerMicroliterTolerance);
@@ -259,191 +259,191 @@ public void KilogramPerCubicMeterToMassConcentrationUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MassConcentration.From(1, MassConcentrationUnit.CentigramPerDeciliter);
+            var quantity00 = MassConcentration<double>.From(1, MassConcentrationUnit.CentigramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity00.CentigramsPerDeciliter, CentigramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.CentigramPerDeciliter, quantity00.Unit);
 
-            var quantity01 = MassConcentration.From(1, MassConcentrationUnit.CentigramPerLiter);
+            var quantity01 = MassConcentration<double>.From(1, MassConcentrationUnit.CentigramPerLiter);
             AssertEx.EqualTolerance(1, quantity01.CentigramsPerLiter, CentigramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.CentigramPerLiter, quantity01.Unit);
 
-            var quantity02 = MassConcentration.From(1, MassConcentrationUnit.CentigramPerMicroliter);
+            var quantity02 = MassConcentration<double>.From(1, MassConcentrationUnit.CentigramPerMicroliter);
             AssertEx.EqualTolerance(1, quantity02.CentigramsPerMicroliter, CentigramsPerMicroliterTolerance);
             Assert.Equal(MassConcentrationUnit.CentigramPerMicroliter, quantity02.Unit);
 
-            var quantity03 = MassConcentration.From(1, MassConcentrationUnit.CentigramPerMilliliter);
+            var quantity03 = MassConcentration<double>.From(1, MassConcentrationUnit.CentigramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity03.CentigramsPerMilliliter, CentigramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.CentigramPerMilliliter, quantity03.Unit);
 
-            var quantity04 = MassConcentration.From(1, MassConcentrationUnit.DecigramPerDeciliter);
+            var quantity04 = MassConcentration<double>.From(1, MassConcentrationUnit.DecigramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity04.DecigramsPerDeciliter, DecigramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.DecigramPerDeciliter, quantity04.Unit);
 
-            var quantity05 = MassConcentration.From(1, MassConcentrationUnit.DecigramPerLiter);
+            var quantity05 = MassConcentration<double>.From(1, MassConcentrationUnit.DecigramPerLiter);
             AssertEx.EqualTolerance(1, quantity05.DecigramsPerLiter, DecigramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.DecigramPerLiter, quantity05.Unit);
 
-            var quantity06 = MassConcentration.From(1, MassConcentrationUnit.DecigramPerMicroliter);
+            var quantity06 = MassConcentration<double>.From(1, MassConcentrationUnit.DecigramPerMicroliter);
             AssertEx.EqualTolerance(1, quantity06.DecigramsPerMicroliter, DecigramsPerMicroliterTolerance);
             Assert.Equal(MassConcentrationUnit.DecigramPerMicroliter, quantity06.Unit);
 
-            var quantity07 = MassConcentration.From(1, MassConcentrationUnit.DecigramPerMilliliter);
+            var quantity07 = MassConcentration<double>.From(1, MassConcentrationUnit.DecigramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity07.DecigramsPerMilliliter, DecigramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.DecigramPerMilliliter, quantity07.Unit);
 
-            var quantity08 = MassConcentration.From(1, MassConcentrationUnit.GramPerCubicCentimeter);
+            var quantity08 = MassConcentration<double>.From(1, MassConcentrationUnit.GramPerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity08.GramsPerCubicCentimeter, GramsPerCubicCentimeterTolerance);
             Assert.Equal(MassConcentrationUnit.GramPerCubicCentimeter, quantity08.Unit);
 
-            var quantity09 = MassConcentration.From(1, MassConcentrationUnit.GramPerCubicMeter);
+            var quantity09 = MassConcentration<double>.From(1, MassConcentrationUnit.GramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity09.GramsPerCubicMeter, GramsPerCubicMeterTolerance);
             Assert.Equal(MassConcentrationUnit.GramPerCubicMeter, quantity09.Unit);
 
-            var quantity10 = MassConcentration.From(1, MassConcentrationUnit.GramPerCubicMillimeter);
+            var quantity10 = MassConcentration<double>.From(1, MassConcentrationUnit.GramPerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity10.GramsPerCubicMillimeter, GramsPerCubicMillimeterTolerance);
             Assert.Equal(MassConcentrationUnit.GramPerCubicMillimeter, quantity10.Unit);
 
-            var quantity11 = MassConcentration.From(1, MassConcentrationUnit.GramPerDeciliter);
+            var quantity11 = MassConcentration<double>.From(1, MassConcentrationUnit.GramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity11.GramsPerDeciliter, GramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.GramPerDeciliter, quantity11.Unit);
 
-            var quantity12 = MassConcentration.From(1, MassConcentrationUnit.GramPerLiter);
+            var quantity12 = MassConcentration<double>.From(1, MassConcentrationUnit.GramPerLiter);
             AssertEx.EqualTolerance(1, quantity12.GramsPerLiter, GramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.GramPerLiter, quantity12.Unit);
 
-            var quantity13 = MassConcentration.From(1, MassConcentrationUnit.GramPerMicroliter);
+            var quantity13 = MassConcentration<double>.From(1, MassConcentrationUnit.GramPerMicroliter);
             AssertEx.EqualTolerance(1, quantity13.GramsPerMicroliter, GramsPerMicroliterTolerance);
             Assert.Equal(MassConcentrationUnit.GramPerMicroliter, quantity13.Unit);
 
-            var quantity14 = MassConcentration.From(1, MassConcentrationUnit.GramPerMilliliter);
+            var quantity14 = MassConcentration<double>.From(1, MassConcentrationUnit.GramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity14.GramsPerMilliliter, GramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.GramPerMilliliter, quantity14.Unit);
 
-            var quantity15 = MassConcentration.From(1, MassConcentrationUnit.KilogramPerCubicCentimeter);
+            var quantity15 = MassConcentration<double>.From(1, MassConcentrationUnit.KilogramPerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity15.KilogramsPerCubicCentimeter, KilogramsPerCubicCentimeterTolerance);
             Assert.Equal(MassConcentrationUnit.KilogramPerCubicCentimeter, quantity15.Unit);
 
-            var quantity16 = MassConcentration.From(1, MassConcentrationUnit.KilogramPerCubicMeter);
+            var quantity16 = MassConcentration<double>.From(1, MassConcentrationUnit.KilogramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity16.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             Assert.Equal(MassConcentrationUnit.KilogramPerCubicMeter, quantity16.Unit);
 
-            var quantity17 = MassConcentration.From(1, MassConcentrationUnit.KilogramPerCubicMillimeter);
+            var quantity17 = MassConcentration<double>.From(1, MassConcentrationUnit.KilogramPerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity17.KilogramsPerCubicMillimeter, KilogramsPerCubicMillimeterTolerance);
             Assert.Equal(MassConcentrationUnit.KilogramPerCubicMillimeter, quantity17.Unit);
 
-            var quantity18 = MassConcentration.From(1, MassConcentrationUnit.KilogramPerLiter);
+            var quantity18 = MassConcentration<double>.From(1, MassConcentrationUnit.KilogramPerLiter);
             AssertEx.EqualTolerance(1, quantity18.KilogramsPerLiter, KilogramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.KilogramPerLiter, quantity18.Unit);
 
-            var quantity19 = MassConcentration.From(1, MassConcentrationUnit.KilopoundPerCubicFoot);
+            var quantity19 = MassConcentration<double>.From(1, MassConcentrationUnit.KilopoundPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity19.KilopoundsPerCubicFoot, KilopoundsPerCubicFootTolerance);
             Assert.Equal(MassConcentrationUnit.KilopoundPerCubicFoot, quantity19.Unit);
 
-            var quantity20 = MassConcentration.From(1, MassConcentrationUnit.KilopoundPerCubicInch);
+            var quantity20 = MassConcentration<double>.From(1, MassConcentrationUnit.KilopoundPerCubicInch);
             AssertEx.EqualTolerance(1, quantity20.KilopoundsPerCubicInch, KilopoundsPerCubicInchTolerance);
             Assert.Equal(MassConcentrationUnit.KilopoundPerCubicInch, quantity20.Unit);
 
-            var quantity21 = MassConcentration.From(1, MassConcentrationUnit.MicrogramPerCubicMeter);
+            var quantity21 = MassConcentration<double>.From(1, MassConcentrationUnit.MicrogramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity21.MicrogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
             Assert.Equal(MassConcentrationUnit.MicrogramPerCubicMeter, quantity21.Unit);
 
-            var quantity22 = MassConcentration.From(1, MassConcentrationUnit.MicrogramPerDeciliter);
+            var quantity22 = MassConcentration<double>.From(1, MassConcentrationUnit.MicrogramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity22.MicrogramsPerDeciliter, MicrogramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.MicrogramPerDeciliter, quantity22.Unit);
 
-            var quantity23 = MassConcentration.From(1, MassConcentrationUnit.MicrogramPerLiter);
+            var quantity23 = MassConcentration<double>.From(1, MassConcentrationUnit.MicrogramPerLiter);
             AssertEx.EqualTolerance(1, quantity23.MicrogramsPerLiter, MicrogramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.MicrogramPerLiter, quantity23.Unit);
 
-            var quantity24 = MassConcentration.From(1, MassConcentrationUnit.MicrogramPerMicroliter);
+            var quantity24 = MassConcentration<double>.From(1, MassConcentrationUnit.MicrogramPerMicroliter);
             AssertEx.EqualTolerance(1, quantity24.MicrogramsPerMicroliter, MicrogramsPerMicroliterTolerance);
             Assert.Equal(MassConcentrationUnit.MicrogramPerMicroliter, quantity24.Unit);
 
-            var quantity25 = MassConcentration.From(1, MassConcentrationUnit.MicrogramPerMilliliter);
+            var quantity25 = MassConcentration<double>.From(1, MassConcentrationUnit.MicrogramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity25.MicrogramsPerMilliliter, MicrogramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.MicrogramPerMilliliter, quantity25.Unit);
 
-            var quantity26 = MassConcentration.From(1, MassConcentrationUnit.MilligramPerCubicMeter);
+            var quantity26 = MassConcentration<double>.From(1, MassConcentrationUnit.MilligramPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity26.MilligramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
             Assert.Equal(MassConcentrationUnit.MilligramPerCubicMeter, quantity26.Unit);
 
-            var quantity27 = MassConcentration.From(1, MassConcentrationUnit.MilligramPerDeciliter);
+            var quantity27 = MassConcentration<double>.From(1, MassConcentrationUnit.MilligramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity27.MilligramsPerDeciliter, MilligramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.MilligramPerDeciliter, quantity27.Unit);
 
-            var quantity28 = MassConcentration.From(1, MassConcentrationUnit.MilligramPerLiter);
+            var quantity28 = MassConcentration<double>.From(1, MassConcentrationUnit.MilligramPerLiter);
             AssertEx.EqualTolerance(1, quantity28.MilligramsPerLiter, MilligramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.MilligramPerLiter, quantity28.Unit);
 
-            var quantity29 = MassConcentration.From(1, MassConcentrationUnit.MilligramPerMicroliter);
+            var quantity29 = MassConcentration<double>.From(1, MassConcentrationUnit.MilligramPerMicroliter);
             AssertEx.EqualTolerance(1, quantity29.MilligramsPerMicroliter, MilligramsPerMicroliterTolerance);
             Assert.Equal(MassConcentrationUnit.MilligramPerMicroliter, quantity29.Unit);
 
-            var quantity30 = MassConcentration.From(1, MassConcentrationUnit.MilligramPerMilliliter);
+            var quantity30 = MassConcentration<double>.From(1, MassConcentrationUnit.MilligramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity30.MilligramsPerMilliliter, MilligramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.MilligramPerMilliliter, quantity30.Unit);
 
-            var quantity31 = MassConcentration.From(1, MassConcentrationUnit.NanogramPerDeciliter);
+            var quantity31 = MassConcentration<double>.From(1, MassConcentrationUnit.NanogramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity31.NanogramsPerDeciliter, NanogramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.NanogramPerDeciliter, quantity31.Unit);
 
-            var quantity32 = MassConcentration.From(1, MassConcentrationUnit.NanogramPerLiter);
+            var quantity32 = MassConcentration<double>.From(1, MassConcentrationUnit.NanogramPerLiter);
             AssertEx.EqualTolerance(1, quantity32.NanogramsPerLiter, NanogramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.NanogramPerLiter, quantity32.Unit);
 
-            var quantity33 = MassConcentration.From(1, MassConcentrationUnit.NanogramPerMicroliter);
+            var quantity33 = MassConcentration<double>.From(1, MassConcentrationUnit.NanogramPerMicroliter);
             AssertEx.EqualTolerance(1, quantity33.NanogramsPerMicroliter, NanogramsPerMicroliterTolerance);
             Assert.Equal(MassConcentrationUnit.NanogramPerMicroliter, quantity33.Unit);
 
-            var quantity34 = MassConcentration.From(1, MassConcentrationUnit.NanogramPerMilliliter);
+            var quantity34 = MassConcentration<double>.From(1, MassConcentrationUnit.NanogramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity34.NanogramsPerMilliliter, NanogramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.NanogramPerMilliliter, quantity34.Unit);
 
-            var quantity35 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerDeciliter);
+            var quantity35 = MassConcentration<double>.From(1, MassConcentrationUnit.PicogramPerDeciliter);
             AssertEx.EqualTolerance(1, quantity35.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.PicogramPerDeciliter, quantity35.Unit);
 
-            var quantity36 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerLiter);
+            var quantity36 = MassConcentration<double>.From(1, MassConcentrationUnit.PicogramPerLiter);
             AssertEx.EqualTolerance(1, quantity36.PicogramsPerLiter, PicogramsPerLiterTolerance);
             Assert.Equal(MassConcentrationUnit.PicogramPerLiter, quantity36.Unit);
 
-            var quantity37 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerMicroliter);
+            var quantity37 = MassConcentration<double>.From(1, MassConcentrationUnit.PicogramPerMicroliter);
             AssertEx.EqualTolerance(1, quantity37.PicogramsPerMicroliter, PicogramsPerMicroliterTolerance);
             Assert.Equal(MassConcentrationUnit.PicogramPerMicroliter, quantity37.Unit);
 
-            var quantity38 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerMilliliter);
+            var quantity38 = MassConcentration<double>.From(1, MassConcentrationUnit.PicogramPerMilliliter);
             AssertEx.EqualTolerance(1, quantity38.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.PicogramPerMilliliter, quantity38.Unit);
 
-            var quantity39 = MassConcentration.From(1, MassConcentrationUnit.PoundPerCubicFoot);
+            var quantity39 = MassConcentration<double>.From(1, MassConcentrationUnit.PoundPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity39.PoundsPerCubicFoot, PoundsPerCubicFootTolerance);
             Assert.Equal(MassConcentrationUnit.PoundPerCubicFoot, quantity39.Unit);
 
-            var quantity40 = MassConcentration.From(1, MassConcentrationUnit.PoundPerCubicInch);
+            var quantity40 = MassConcentration<double>.From(1, MassConcentrationUnit.PoundPerCubicInch);
             AssertEx.EqualTolerance(1, quantity40.PoundsPerCubicInch, PoundsPerCubicInchTolerance);
             Assert.Equal(MassConcentrationUnit.PoundPerCubicInch, quantity40.Unit);
 
-            var quantity41 = MassConcentration.From(1, MassConcentrationUnit.PoundPerImperialGallon);
+            var quantity41 = MassConcentration<double>.From(1, MassConcentrationUnit.PoundPerImperialGallon);
             AssertEx.EqualTolerance(1, quantity41.PoundsPerImperialGallon, PoundsPerImperialGallonTolerance);
             Assert.Equal(MassConcentrationUnit.PoundPerImperialGallon, quantity41.Unit);
 
-            var quantity42 = MassConcentration.From(1, MassConcentrationUnit.PoundPerUSGallon);
+            var quantity42 = MassConcentration<double>.From(1, MassConcentrationUnit.PoundPerUSGallon);
             AssertEx.EqualTolerance(1, quantity42.PoundsPerUSGallon, PoundsPerUSGallonTolerance);
             Assert.Equal(MassConcentrationUnit.PoundPerUSGallon, quantity42.Unit);
 
-            var quantity43 = MassConcentration.From(1, MassConcentrationUnit.SlugPerCubicFoot);
+            var quantity43 = MassConcentration<double>.From(1, MassConcentrationUnit.SlugPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity43.SlugsPerCubicFoot, SlugsPerCubicFootTolerance);
             Assert.Equal(MassConcentrationUnit.SlugPerCubicFoot, quantity43.Unit);
 
-            var quantity44 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicCentimeter);
+            var quantity44 = MassConcentration<double>.From(1, MassConcentrationUnit.TonnePerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity44.TonnesPerCubicCentimeter, TonnesPerCubicCentimeterTolerance);
             Assert.Equal(MassConcentrationUnit.TonnePerCubicCentimeter, quantity44.Unit);
 
-            var quantity45 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicMeter);
+            var quantity45 = MassConcentration<double>.From(1, MassConcentrationUnit.TonnePerCubicMeter);
             AssertEx.EqualTolerance(1, quantity45.TonnesPerCubicMeter, TonnesPerCubicMeterTolerance);
             Assert.Equal(MassConcentrationUnit.TonnePerCubicMeter, quantity45.Unit);
 
-            var quantity46 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicMillimeter);
+            var quantity46 = MassConcentration<double>.From(1, MassConcentrationUnit.TonnePerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity46.TonnesPerCubicMillimeter, TonnesPerCubicMillimeterTolerance);
             Assert.Equal(MassConcentrationUnit.TonnePerCubicMillimeter, quantity46.Unit);
 
@@ -452,20 +452,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramsPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassConcentration.FromKilogramsPerCubicMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MassConcentration.FromKilogramsPerCubicMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MassConcentration<double>.FromKilogramsPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MassConcentration<double>.FromKilogramsPerCubicMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramsPerCubicMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassConcentration.FromKilogramsPerCubicMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => MassConcentration<double>.FromKilogramsPerCubicMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            var kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             AssertEx.EqualTolerance(CentigramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.CentigramPerDeciliter), CentigramsPerDeciliterTolerance);
             AssertEx.EqualTolerance(CentigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.CentigramPerLiter), CentigramsPerLiterTolerance);
             AssertEx.EqualTolerance(CentigramsPerMicroliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.CentigramPerMicroliter), CentigramsPerMicroliterTolerance);
@@ -535,7 +535,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            var kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
 
             var centigramperdeciliterQuantity = kilogrampercubicmeter.ToUnit(MassConcentrationUnit.CentigramPerDeciliter);
             AssertEx.EqualTolerance(CentigramsPerDeciliterInOneKilogramPerCubicMeter, (double)centigramperdeciliterQuantity.Value, CentigramsPerDeciliterTolerance);
@@ -736,74 +736,74 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerDeciliter(kilogrampercubicmeter.CentigramsPerDeciliter).KilogramsPerCubicMeter, CentigramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter, CentigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerMicroliter(kilogrampercubicmeter.CentigramsPerMicroliter).KilogramsPerCubicMeter, CentigramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter, CentigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerDeciliter(kilogrampercubicmeter.DecigramsPerDeciliter).KilogramsPerCubicMeter, DecigramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerMicroliter(kilogrampercubicmeter.DecigramsPerMicroliter).KilogramsPerCubicMeter, DecigramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerDeciliter(kilogrampercubicmeter.GramsPerDeciliter).KilogramsPerCubicMeter, GramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter, GramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerMicroliter(kilogrampercubicmeter.GramsPerMicroliter).KilogramsPerCubicMeter, GramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter, GramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter, KilogramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter, KilogramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter, KilogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter, KilopoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter, KilopoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerDeciliter(kilogrampercubicmeter.MicrogramsPerDeciliter).KilogramsPerCubicMeter, MicrogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter, MicrogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerMicroliter(kilogrampercubicmeter.MicrogramsPerMicroliter).KilogramsPerCubicMeter, MicrogramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter, MicrogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerDeciliter(kilogrampercubicmeter.MilligramsPerDeciliter).KilogramsPerCubicMeter, MilligramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter, MilligramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerMicroliter(kilogrampercubicmeter.MilligramsPerMicroliter).KilogramsPerCubicMeter, MilligramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter, MilligramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerDeciliter(kilogrampercubicmeter.NanogramsPerDeciliter).KilogramsPerCubicMeter, NanogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerMicroliter(kilogrampercubicmeter.NanogramsPerMicroliter).KilogramsPerCubicMeter, NanogramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter, PicogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerMicroliter(kilogrampercubicmeter.PicogramsPerMicroliter).KilogramsPerCubicMeter, PicogramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter, PoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter, PoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter, PoundsPerImperialGallonTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter, PoundsPerUSGallonTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter, SlugsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter, TonnesPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter, TonnesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter, TonnesPerCubicMillimeterTolerance);
+            MassConcentration<double> kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromCentigramsPerDeciliter(kilogrampercubicmeter.CentigramsPerDeciliter).KilogramsPerCubicMeter, CentigramsPerDeciliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter, CentigramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromCentigramsPerMicroliter(kilogrampercubicmeter.CentigramsPerMicroliter).KilogramsPerCubicMeter, CentigramsPerMicroliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter, CentigramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromDecigramsPerDeciliter(kilogrampercubicmeter.DecigramsPerDeciliter).KilogramsPerCubicMeter, DecigramsPerDeciliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromDecigramsPerMicroliter(kilogrampercubicmeter.DecigramsPerMicroliter).KilogramsPerCubicMeter, DecigramsPerMicroliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromGramsPerDeciliter(kilogrampercubicmeter.GramsPerDeciliter).KilogramsPerCubicMeter, GramsPerDeciliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter, GramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromGramsPerMicroliter(kilogrampercubicmeter.GramsPerMicroliter).KilogramsPerCubicMeter, GramsPerMicroliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter, GramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter, KilogramsPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter, KilogramsPerCubicMillimeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter, KilogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter, KilopoundsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter, KilopoundsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMicrogramsPerDeciliter(kilogrampercubicmeter.MicrogramsPerDeciliter).KilogramsPerCubicMeter, MicrogramsPerDeciliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter, MicrogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMicrogramsPerMicroliter(kilogrampercubicmeter.MicrogramsPerMicroliter).KilogramsPerCubicMeter, MicrogramsPerMicroliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter, MicrogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMilligramsPerDeciliter(kilogrampercubicmeter.MilligramsPerDeciliter).KilogramsPerCubicMeter, MilligramsPerDeciliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter, MilligramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMilligramsPerMicroliter(kilogrampercubicmeter.MilligramsPerMicroliter).KilogramsPerCubicMeter, MilligramsPerMicroliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter, MilligramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromNanogramsPerDeciliter(kilogrampercubicmeter.NanogramsPerDeciliter).KilogramsPerCubicMeter, NanogramsPerDeciliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromNanogramsPerMicroliter(kilogrampercubicmeter.NanogramsPerMicroliter).KilogramsPerCubicMeter, NanogramsPerMicroliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter, PicogramsPerDeciliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPicogramsPerMicroliter(kilogrampercubicmeter.PicogramsPerMicroliter).KilogramsPerCubicMeter, PicogramsPerMicroliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter, PoundsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter, PoundsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter, PoundsPerImperialGallonTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter, PoundsPerUSGallonTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter, SlugsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter, TonnesPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter, TonnesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration<double>.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter, TonnesPerCubicMillimeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MassConcentration v = MassConcentration.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> v = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             AssertEx.EqualTolerance(-1, -v.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassConcentration.FromKilogramsPerCubicMeter(3)-v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (MassConcentration<double>.FromKilogramsPerCubicMeter(3)-v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassConcentration.FromKilogramsPerCubicMeter(10)/5).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, MassConcentration.FromKilogramsPerCubicMeter(10)/MassConcentration.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (MassConcentration<double>.FromKilogramsPerCubicMeter(10)/5).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, MassConcentration<double>.FromKilogramsPerCubicMeter(10)/MassConcentration<double>.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MassConcentration oneKilogramPerCubicMeter = MassConcentration.FromKilogramsPerCubicMeter(1);
-            MassConcentration twoKilogramsPerCubicMeter = MassConcentration.FromKilogramsPerCubicMeter(2);
+            MassConcentration<double> oneKilogramPerCubicMeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> twoKilogramsPerCubicMeter = MassConcentration<double>.FromKilogramsPerCubicMeter(2);
 
             Assert.True(oneKilogramPerCubicMeter < twoKilogramsPerCubicMeter);
             Assert.True(oneKilogramPerCubicMeter <= twoKilogramsPerCubicMeter);
@@ -819,31 +819,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             Assert.Equal(0, kilogrampercubicmeter.CompareTo(kilogrampercubicmeter));
-            Assert.True(kilogrampercubicmeter.CompareTo(MassConcentration.Zero) > 0);
-            Assert.True(MassConcentration.Zero.CompareTo(kilogrampercubicmeter) < 0);
+            Assert.True(kilogrampercubicmeter.CompareTo(MassConcentration<double>.Zero) > 0);
+            Assert.True(MassConcentration<double>.Zero.CompareTo(kilogrampercubicmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             Assert.Throws<ArgumentException>(() => kilogrampercubicmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             Assert.Throws<ArgumentNullException>(() => kilogrampercubicmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MassConcentration.FromKilogramsPerCubicMeter(1);
-            var b = MassConcentration.FromKilogramsPerCubicMeter(2);
+            var a = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
+            var b = MassConcentration<double>.FromKilogramsPerCubicMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -862,8 +862,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MassConcentration.FromKilogramsPerCubicMeter(1);
-            var b = MassConcentration.FromKilogramsPerCubicMeter(2);
+            var a = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
+            var b = MassConcentration<double>.FromKilogramsPerCubicMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -883,9 +883,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MassConcentration.FromKilogramsPerCubicMeter(1);
-            Assert.True(v.Equals(MassConcentration.FromKilogramsPerCubicMeter(1), KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MassConcentration.Zero, KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
+            var v = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
+            Assert.True(v.Equals(MassConcentration<double>.FromKilogramsPerCubicMeter(1), KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MassConcentration<double>.Zero, KilogramsPerCubicMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -898,21 +898,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             Assert.False(kilogrampercubicmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
+            MassConcentration<double> kilogrampercubicmeter = MassConcentration<double>.FromKilogramsPerCubicMeter(1);
             Assert.False(kilogrampercubicmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MassConcentrationUnit.Undefined, MassConcentration.Units);
+            Assert.DoesNotContain(MassConcentrationUnit.Undefined, MassConcentration<double>.Units);
         }
 
         [Fact]
@@ -931,7 +931,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MassConcentration.BaseDimensions is null);
+            Assert.False(MassConcentration<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs
index 7ded290846..72e1249f37 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs
@@ -110,7 +110,7 @@ public abstract partial class MassFlowTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFlow((double)0.0, MassFlowUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MassFlow<double>((double)0.0, MassFlowUnit.Undefined));
         }
 
         [Fact]
@@ -125,14 +125,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFlow(double.PositiveInfinity, MassFlowUnit.GramPerSecond));
-            Assert.Throws<ArgumentException>(() => new MassFlow(double.NegativeInfinity, MassFlowUnit.GramPerSecond));
+            Assert.Throws<ArgumentException>(() => new MassFlow<double>(double.PositiveInfinity, MassFlowUnit.GramPerSecond));
+            Assert.Throws<ArgumentException>(() => new MassFlow<double>(double.NegativeInfinity, MassFlowUnit.GramPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFlow(double.NaN, MassFlowUnit.GramPerSecond));
+            Assert.Throws<ArgumentException>(() => new MassFlow<double>(double.NaN, MassFlowUnit.GramPerSecond));
         }
 
         [Fact]
@@ -178,7 +178,7 @@ public void MassFlow_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void GramPerSecondToMassFlowUnits()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
+            MassFlow<double> grampersecond = MassFlow<double>.FromGramsPerSecond(1);
             AssertEx.EqualTolerance(CentigramsPerDayInOneGramPerSecond, grampersecond.CentigramsPerDay, CentigramsPerDayTolerance);
             AssertEx.EqualTolerance(CentigramsPerSecondInOneGramPerSecond, grampersecond.CentigramsPerSecond, CentigramsPerSecondTolerance);
             AssertEx.EqualTolerance(DecagramsPerDayInOneGramPerSecond, grampersecond.DecagramsPerDay, DecagramsPerDayTolerance);
@@ -217,135 +217,135 @@ public void GramPerSecondToMassFlowUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MassFlow.From(1, MassFlowUnit.CentigramPerDay);
+            var quantity00 = MassFlow<double>.From(1, MassFlowUnit.CentigramPerDay);
             AssertEx.EqualTolerance(1, quantity00.CentigramsPerDay, CentigramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.CentigramPerDay, quantity00.Unit);
 
-            var quantity01 = MassFlow.From(1, MassFlowUnit.CentigramPerSecond);
+            var quantity01 = MassFlow<double>.From(1, MassFlowUnit.CentigramPerSecond);
             AssertEx.EqualTolerance(1, quantity01.CentigramsPerSecond, CentigramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.CentigramPerSecond, quantity01.Unit);
 
-            var quantity02 = MassFlow.From(1, MassFlowUnit.DecagramPerDay);
+            var quantity02 = MassFlow<double>.From(1, MassFlowUnit.DecagramPerDay);
             AssertEx.EqualTolerance(1, quantity02.DecagramsPerDay, DecagramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.DecagramPerDay, quantity02.Unit);
 
-            var quantity03 = MassFlow.From(1, MassFlowUnit.DecagramPerSecond);
+            var quantity03 = MassFlow<double>.From(1, MassFlowUnit.DecagramPerSecond);
             AssertEx.EqualTolerance(1, quantity03.DecagramsPerSecond, DecagramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.DecagramPerSecond, quantity03.Unit);
 
-            var quantity04 = MassFlow.From(1, MassFlowUnit.DecigramPerDay);
+            var quantity04 = MassFlow<double>.From(1, MassFlowUnit.DecigramPerDay);
             AssertEx.EqualTolerance(1, quantity04.DecigramsPerDay, DecigramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.DecigramPerDay, quantity04.Unit);
 
-            var quantity05 = MassFlow.From(1, MassFlowUnit.DecigramPerSecond);
+            var quantity05 = MassFlow<double>.From(1, MassFlowUnit.DecigramPerSecond);
             AssertEx.EqualTolerance(1, quantity05.DecigramsPerSecond, DecigramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.DecigramPerSecond, quantity05.Unit);
 
-            var quantity06 = MassFlow.From(1, MassFlowUnit.GramPerDay);
+            var quantity06 = MassFlow<double>.From(1, MassFlowUnit.GramPerDay);
             AssertEx.EqualTolerance(1, quantity06.GramsPerDay, GramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.GramPerDay, quantity06.Unit);
 
-            var quantity07 = MassFlow.From(1, MassFlowUnit.GramPerHour);
+            var quantity07 = MassFlow<double>.From(1, MassFlowUnit.GramPerHour);
             AssertEx.EqualTolerance(1, quantity07.GramsPerHour, GramsPerHourTolerance);
             Assert.Equal(MassFlowUnit.GramPerHour, quantity07.Unit);
 
-            var quantity08 = MassFlow.From(1, MassFlowUnit.GramPerSecond);
+            var quantity08 = MassFlow<double>.From(1, MassFlowUnit.GramPerSecond);
             AssertEx.EqualTolerance(1, quantity08.GramsPerSecond, GramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.GramPerSecond, quantity08.Unit);
 
-            var quantity09 = MassFlow.From(1, MassFlowUnit.HectogramPerDay);
+            var quantity09 = MassFlow<double>.From(1, MassFlowUnit.HectogramPerDay);
             AssertEx.EqualTolerance(1, quantity09.HectogramsPerDay, HectogramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.HectogramPerDay, quantity09.Unit);
 
-            var quantity10 = MassFlow.From(1, MassFlowUnit.HectogramPerSecond);
+            var quantity10 = MassFlow<double>.From(1, MassFlowUnit.HectogramPerSecond);
             AssertEx.EqualTolerance(1, quantity10.HectogramsPerSecond, HectogramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.HectogramPerSecond, quantity10.Unit);
 
-            var quantity11 = MassFlow.From(1, MassFlowUnit.KilogramPerDay);
+            var quantity11 = MassFlow<double>.From(1, MassFlowUnit.KilogramPerDay);
             AssertEx.EqualTolerance(1, quantity11.KilogramsPerDay, KilogramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.KilogramPerDay, quantity11.Unit);
 
-            var quantity12 = MassFlow.From(1, MassFlowUnit.KilogramPerHour);
+            var quantity12 = MassFlow<double>.From(1, MassFlowUnit.KilogramPerHour);
             AssertEx.EqualTolerance(1, quantity12.KilogramsPerHour, KilogramsPerHourTolerance);
             Assert.Equal(MassFlowUnit.KilogramPerHour, quantity12.Unit);
 
-            var quantity13 = MassFlow.From(1, MassFlowUnit.KilogramPerMinute);
+            var quantity13 = MassFlow<double>.From(1, MassFlowUnit.KilogramPerMinute);
             AssertEx.EqualTolerance(1, quantity13.KilogramsPerMinute, KilogramsPerMinuteTolerance);
             Assert.Equal(MassFlowUnit.KilogramPerMinute, quantity13.Unit);
 
-            var quantity14 = MassFlow.From(1, MassFlowUnit.KilogramPerSecond);
+            var quantity14 = MassFlow<double>.From(1, MassFlowUnit.KilogramPerSecond);
             AssertEx.EqualTolerance(1, quantity14.KilogramsPerSecond, KilogramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.KilogramPerSecond, quantity14.Unit);
 
-            var quantity15 = MassFlow.From(1, MassFlowUnit.MegagramPerDay);
+            var quantity15 = MassFlow<double>.From(1, MassFlowUnit.MegagramPerDay);
             AssertEx.EqualTolerance(1, quantity15.MegagramsPerDay, MegagramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.MegagramPerDay, quantity15.Unit);
 
-            var quantity16 = MassFlow.From(1, MassFlowUnit.MegapoundPerDay);
+            var quantity16 = MassFlow<double>.From(1, MassFlowUnit.MegapoundPerDay);
             AssertEx.EqualTolerance(1, quantity16.MegapoundsPerDay, MegapoundsPerDayTolerance);
             Assert.Equal(MassFlowUnit.MegapoundPerDay, quantity16.Unit);
 
-            var quantity17 = MassFlow.From(1, MassFlowUnit.MegapoundPerHour);
+            var quantity17 = MassFlow<double>.From(1, MassFlowUnit.MegapoundPerHour);
             AssertEx.EqualTolerance(1, quantity17.MegapoundsPerHour, MegapoundsPerHourTolerance);
             Assert.Equal(MassFlowUnit.MegapoundPerHour, quantity17.Unit);
 
-            var quantity18 = MassFlow.From(1, MassFlowUnit.MegapoundPerMinute);
+            var quantity18 = MassFlow<double>.From(1, MassFlowUnit.MegapoundPerMinute);
             AssertEx.EqualTolerance(1, quantity18.MegapoundsPerMinute, MegapoundsPerMinuteTolerance);
             Assert.Equal(MassFlowUnit.MegapoundPerMinute, quantity18.Unit);
 
-            var quantity19 = MassFlow.From(1, MassFlowUnit.MegapoundPerSecond);
+            var quantity19 = MassFlow<double>.From(1, MassFlowUnit.MegapoundPerSecond);
             AssertEx.EqualTolerance(1, quantity19.MegapoundsPerSecond, MegapoundsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.MegapoundPerSecond, quantity19.Unit);
 
-            var quantity20 = MassFlow.From(1, MassFlowUnit.MicrogramPerDay);
+            var quantity20 = MassFlow<double>.From(1, MassFlowUnit.MicrogramPerDay);
             AssertEx.EqualTolerance(1, quantity20.MicrogramsPerDay, MicrogramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.MicrogramPerDay, quantity20.Unit);
 
-            var quantity21 = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond);
+            var quantity21 = MassFlow<double>.From(1, MassFlowUnit.MicrogramPerSecond);
             AssertEx.EqualTolerance(1, quantity21.MicrogramsPerSecond, MicrogramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.MicrogramPerSecond, quantity21.Unit);
 
-            var quantity22 = MassFlow.From(1, MassFlowUnit.MilligramPerDay);
+            var quantity22 = MassFlow<double>.From(1, MassFlowUnit.MilligramPerDay);
             AssertEx.EqualTolerance(1, quantity22.MilligramsPerDay, MilligramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.MilligramPerDay, quantity22.Unit);
 
-            var quantity23 = MassFlow.From(1, MassFlowUnit.MilligramPerSecond);
+            var quantity23 = MassFlow<double>.From(1, MassFlowUnit.MilligramPerSecond);
             AssertEx.EqualTolerance(1, quantity23.MilligramsPerSecond, MilligramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.MilligramPerSecond, quantity23.Unit);
 
-            var quantity24 = MassFlow.From(1, MassFlowUnit.NanogramPerDay);
+            var quantity24 = MassFlow<double>.From(1, MassFlowUnit.NanogramPerDay);
             AssertEx.EqualTolerance(1, quantity24.NanogramsPerDay, NanogramsPerDayTolerance);
             Assert.Equal(MassFlowUnit.NanogramPerDay, quantity24.Unit);
 
-            var quantity25 = MassFlow.From(1, MassFlowUnit.NanogramPerSecond);
+            var quantity25 = MassFlow<double>.From(1, MassFlowUnit.NanogramPerSecond);
             AssertEx.EqualTolerance(1, quantity25.NanogramsPerSecond, NanogramsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.NanogramPerSecond, quantity25.Unit);
 
-            var quantity26 = MassFlow.From(1, MassFlowUnit.PoundPerDay);
+            var quantity26 = MassFlow<double>.From(1, MassFlowUnit.PoundPerDay);
             AssertEx.EqualTolerance(1, quantity26.PoundsPerDay, PoundsPerDayTolerance);
             Assert.Equal(MassFlowUnit.PoundPerDay, quantity26.Unit);
 
-            var quantity27 = MassFlow.From(1, MassFlowUnit.PoundPerHour);
+            var quantity27 = MassFlow<double>.From(1, MassFlowUnit.PoundPerHour);
             AssertEx.EqualTolerance(1, quantity27.PoundsPerHour, PoundsPerHourTolerance);
             Assert.Equal(MassFlowUnit.PoundPerHour, quantity27.Unit);
 
-            var quantity28 = MassFlow.From(1, MassFlowUnit.PoundPerMinute);
+            var quantity28 = MassFlow<double>.From(1, MassFlowUnit.PoundPerMinute);
             AssertEx.EqualTolerance(1, quantity28.PoundsPerMinute, PoundsPerMinuteTolerance);
             Assert.Equal(MassFlowUnit.PoundPerMinute, quantity28.Unit);
 
-            var quantity29 = MassFlow.From(1, MassFlowUnit.PoundPerSecond);
+            var quantity29 = MassFlow<double>.From(1, MassFlowUnit.PoundPerSecond);
             AssertEx.EqualTolerance(1, quantity29.PoundsPerSecond, PoundsPerSecondTolerance);
             Assert.Equal(MassFlowUnit.PoundPerSecond, quantity29.Unit);
 
-            var quantity30 = MassFlow.From(1, MassFlowUnit.ShortTonPerHour);
+            var quantity30 = MassFlow<double>.From(1, MassFlowUnit.ShortTonPerHour);
             AssertEx.EqualTolerance(1, quantity30.ShortTonsPerHour, ShortTonsPerHourTolerance);
             Assert.Equal(MassFlowUnit.ShortTonPerHour, quantity30.Unit);
 
-            var quantity31 = MassFlow.From(1, MassFlowUnit.TonnePerDay);
+            var quantity31 = MassFlow<double>.From(1, MassFlowUnit.TonnePerDay);
             AssertEx.EqualTolerance(1, quantity31.TonnesPerDay, TonnesPerDayTolerance);
             Assert.Equal(MassFlowUnit.TonnePerDay, quantity31.Unit);
 
-            var quantity32 = MassFlow.From(1, MassFlowUnit.TonnePerHour);
+            var quantity32 = MassFlow<double>.From(1, MassFlowUnit.TonnePerHour);
             AssertEx.EqualTolerance(1, quantity32.TonnesPerHour, TonnesPerHourTolerance);
             Assert.Equal(MassFlowUnit.TonnePerHour, quantity32.Unit);
 
@@ -354,20 +354,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromGramsPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassFlow.FromGramsPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MassFlow.FromGramsPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MassFlow<double>.FromGramsPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MassFlow<double>.FromGramsPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromGramsPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassFlow.FromGramsPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => MassFlow<double>.FromGramsPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var grampersecond = MassFlow.FromGramsPerSecond(1);
+            var grampersecond = MassFlow<double>.FromGramsPerSecond(1);
             AssertEx.EqualTolerance(CentigramsPerDayInOneGramPerSecond, grampersecond.As(MassFlowUnit.CentigramPerDay), CentigramsPerDayTolerance);
             AssertEx.EqualTolerance(CentigramsPerSecondInOneGramPerSecond, grampersecond.As(MassFlowUnit.CentigramPerSecond), CentigramsPerSecondTolerance);
             AssertEx.EqualTolerance(DecagramsPerDayInOneGramPerSecond, grampersecond.As(MassFlowUnit.DecagramPerDay), DecagramsPerDayTolerance);
@@ -423,7 +423,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var grampersecond = MassFlow.FromGramsPerSecond(1);
+            var grampersecond = MassFlow<double>.FromGramsPerSecond(1);
 
             var centigramperdayQuantity = grampersecond.ToUnit(MassFlowUnit.CentigramPerDay);
             AssertEx.EqualTolerance(CentigramsPerDayInOneGramPerSecond, (double)centigramperdayQuantity.Value, CentigramsPerDayTolerance);
@@ -568,60 +568,60 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
-            AssertEx.EqualTolerance(1, MassFlow.FromCentigramsPerDay(grampersecond.CentigramsPerDay).GramsPerSecond, CentigramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromCentigramsPerSecond(grampersecond.CentigramsPerSecond).GramsPerSecond, CentigramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecagramsPerDay(grampersecond.DecagramsPerDay).GramsPerSecond, DecagramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecagramsPerSecond(grampersecond.DecagramsPerSecond).GramsPerSecond, DecagramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecigramsPerDay(grampersecond.DecigramsPerDay).GramsPerSecond, DecigramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecigramsPerSecond(grampersecond.DecigramsPerSecond).GramsPerSecond, DecigramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromGramsPerDay(grampersecond.GramsPerDay).GramsPerSecond, GramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromGramsPerHour(grampersecond.GramsPerHour).GramsPerSecond, GramsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromGramsPerSecond(grampersecond.GramsPerSecond).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromHectogramsPerDay(grampersecond.HectogramsPerDay).GramsPerSecond, HectogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromHectogramsPerSecond(grampersecond.HectogramsPerSecond).GramsPerSecond, HectogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerDay(grampersecond.KilogramsPerDay).GramsPerSecond, KilogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerHour(grampersecond.KilogramsPerHour).GramsPerSecond, KilogramsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerMinute(grampersecond.KilogramsPerMinute).GramsPerSecond, KilogramsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerSecond(grampersecond.KilogramsPerSecond).GramsPerSecond, KilogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegagramsPerDay(grampersecond.MegagramsPerDay).GramsPerSecond, MegagramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerDay(grampersecond.MegapoundsPerDay).GramsPerSecond, MegapoundsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerHour(grampersecond.MegapoundsPerHour).GramsPerSecond, MegapoundsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerMinute(grampersecond.MegapoundsPerMinute).GramsPerSecond, MegapoundsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerSecond(grampersecond.MegapoundsPerSecond).GramsPerSecond, MegapoundsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMicrogramsPerDay(grampersecond.MicrogramsPerDay).GramsPerSecond, MicrogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMicrogramsPerSecond(grampersecond.MicrogramsPerSecond).GramsPerSecond, MicrogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMilligramsPerDay(grampersecond.MilligramsPerDay).GramsPerSecond, MilligramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMilligramsPerSecond(grampersecond.MilligramsPerSecond).GramsPerSecond, MilligramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromNanogramsPerDay(grampersecond.NanogramsPerDay).GramsPerSecond, NanogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromNanogramsPerSecond(grampersecond.NanogramsPerSecond).GramsPerSecond, NanogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerDay(grampersecond.PoundsPerDay).GramsPerSecond, PoundsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerHour(grampersecond.PoundsPerHour).GramsPerSecond, PoundsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerMinute(grampersecond.PoundsPerMinute).GramsPerSecond, PoundsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerSecond(grampersecond.PoundsPerSecond).GramsPerSecond, PoundsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromShortTonsPerHour(grampersecond.ShortTonsPerHour).GramsPerSecond, ShortTonsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromTonnesPerDay(grampersecond.TonnesPerDay).GramsPerSecond, TonnesPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromTonnesPerHour(grampersecond.TonnesPerHour).GramsPerSecond, TonnesPerHourTolerance);
+            MassFlow<double> grampersecond = MassFlow<double>.FromGramsPerSecond(1);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromCentigramsPerDay(grampersecond.CentigramsPerDay).GramsPerSecond, CentigramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromCentigramsPerSecond(grampersecond.CentigramsPerSecond).GramsPerSecond, CentigramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromDecagramsPerDay(grampersecond.DecagramsPerDay).GramsPerSecond, DecagramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromDecagramsPerSecond(grampersecond.DecagramsPerSecond).GramsPerSecond, DecagramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromDecigramsPerDay(grampersecond.DecigramsPerDay).GramsPerSecond, DecigramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromDecigramsPerSecond(grampersecond.DecigramsPerSecond).GramsPerSecond, DecigramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromGramsPerDay(grampersecond.GramsPerDay).GramsPerSecond, GramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromGramsPerHour(grampersecond.GramsPerHour).GramsPerSecond, GramsPerHourTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromGramsPerSecond(grampersecond.GramsPerSecond).GramsPerSecond, GramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromHectogramsPerDay(grampersecond.HectogramsPerDay).GramsPerSecond, HectogramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromHectogramsPerSecond(grampersecond.HectogramsPerSecond).GramsPerSecond, HectogramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromKilogramsPerDay(grampersecond.KilogramsPerDay).GramsPerSecond, KilogramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromKilogramsPerHour(grampersecond.KilogramsPerHour).GramsPerSecond, KilogramsPerHourTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromKilogramsPerMinute(grampersecond.KilogramsPerMinute).GramsPerSecond, KilogramsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromKilogramsPerSecond(grampersecond.KilogramsPerSecond).GramsPerSecond, KilogramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMegagramsPerDay(grampersecond.MegagramsPerDay).GramsPerSecond, MegagramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMegapoundsPerDay(grampersecond.MegapoundsPerDay).GramsPerSecond, MegapoundsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMegapoundsPerHour(grampersecond.MegapoundsPerHour).GramsPerSecond, MegapoundsPerHourTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMegapoundsPerMinute(grampersecond.MegapoundsPerMinute).GramsPerSecond, MegapoundsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMegapoundsPerSecond(grampersecond.MegapoundsPerSecond).GramsPerSecond, MegapoundsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMicrogramsPerDay(grampersecond.MicrogramsPerDay).GramsPerSecond, MicrogramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMicrogramsPerSecond(grampersecond.MicrogramsPerSecond).GramsPerSecond, MicrogramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMilligramsPerDay(grampersecond.MilligramsPerDay).GramsPerSecond, MilligramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromMilligramsPerSecond(grampersecond.MilligramsPerSecond).GramsPerSecond, MilligramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromNanogramsPerDay(grampersecond.NanogramsPerDay).GramsPerSecond, NanogramsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromNanogramsPerSecond(grampersecond.NanogramsPerSecond).GramsPerSecond, NanogramsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromPoundsPerDay(grampersecond.PoundsPerDay).GramsPerSecond, PoundsPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromPoundsPerHour(grampersecond.PoundsPerHour).GramsPerSecond, PoundsPerHourTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromPoundsPerMinute(grampersecond.PoundsPerMinute).GramsPerSecond, PoundsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromPoundsPerSecond(grampersecond.PoundsPerSecond).GramsPerSecond, PoundsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromShortTonsPerHour(grampersecond.ShortTonsPerHour).GramsPerSecond, ShortTonsPerHourTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromTonnesPerDay(grampersecond.TonnesPerDay).GramsPerSecond, TonnesPerDayTolerance);
+            AssertEx.EqualTolerance(1, MassFlow<double>.FromTonnesPerHour(grampersecond.TonnesPerHour).GramsPerSecond, TonnesPerHourTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MassFlow v = MassFlow.FromGramsPerSecond(1);
+            MassFlow<double> v = MassFlow<double>.FromGramsPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (MassFlow.FromGramsPerSecond(3)-v).GramsPerSecond, GramsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (MassFlow<double>.FromGramsPerSecond(3)-v).GramsPerSecond, GramsPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).GramsPerSecond, GramsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).GramsPerSecond, GramsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (MassFlow.FromGramsPerSecond(10)/5).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, MassFlow.FromGramsPerSecond(10)/MassFlow.FromGramsPerSecond(5), GramsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (MassFlow<double>.FromGramsPerSecond(10)/5).GramsPerSecond, GramsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, MassFlow<double>.FromGramsPerSecond(10)/MassFlow<double>.FromGramsPerSecond(5), GramsPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MassFlow oneGramPerSecond = MassFlow.FromGramsPerSecond(1);
-            MassFlow twoGramsPerSecond = MassFlow.FromGramsPerSecond(2);
+            MassFlow<double> oneGramPerSecond = MassFlow<double>.FromGramsPerSecond(1);
+            MassFlow<double> twoGramsPerSecond = MassFlow<double>.FromGramsPerSecond(2);
 
             Assert.True(oneGramPerSecond < twoGramsPerSecond);
             Assert.True(oneGramPerSecond <= twoGramsPerSecond);
@@ -637,31 +637,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
+            MassFlow<double> grampersecond = MassFlow<double>.FromGramsPerSecond(1);
             Assert.Equal(0, grampersecond.CompareTo(grampersecond));
-            Assert.True(grampersecond.CompareTo(MassFlow.Zero) > 0);
-            Assert.True(MassFlow.Zero.CompareTo(grampersecond) < 0);
+            Assert.True(grampersecond.CompareTo(MassFlow<double>.Zero) > 0);
+            Assert.True(MassFlow<double>.Zero.CompareTo(grampersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
+            MassFlow<double> grampersecond = MassFlow<double>.FromGramsPerSecond(1);
             Assert.Throws<ArgumentException>(() => grampersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
+            MassFlow<double> grampersecond = MassFlow<double>.FromGramsPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => grampersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MassFlow.FromGramsPerSecond(1);
-            var b = MassFlow.FromGramsPerSecond(2);
+            var a = MassFlow<double>.FromGramsPerSecond(1);
+            var b = MassFlow<double>.FromGramsPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -680,8 +680,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MassFlow.FromGramsPerSecond(1);
-            var b = MassFlow.FromGramsPerSecond(2);
+            var a = MassFlow<double>.FromGramsPerSecond(1);
+            var b = MassFlow<double>.FromGramsPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -701,9 +701,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MassFlow.FromGramsPerSecond(1);
-            Assert.True(v.Equals(MassFlow.FromGramsPerSecond(1), GramsPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MassFlow.Zero, GramsPerSecondTolerance, ComparisonType.Relative));
+            var v = MassFlow<double>.FromGramsPerSecond(1);
+            Assert.True(v.Equals(MassFlow<double>.FromGramsPerSecond(1), GramsPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MassFlow<double>.Zero, GramsPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -716,21 +716,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
+            MassFlow<double> grampersecond = MassFlow<double>.FromGramsPerSecond(1);
             Assert.False(grampersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
+            MassFlow<double> grampersecond = MassFlow<double>.FromGramsPerSecond(1);
             Assert.False(grampersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MassFlowUnit.Undefined, MassFlow.Units);
+            Assert.DoesNotContain(MassFlowUnit.Undefined, MassFlow<double>.Units);
         }
 
         [Fact]
@@ -749,7 +749,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MassFlow.BaseDimensions is null);
+            Assert.False(MassFlow<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs
index ce2ec7301f..5b3ac0180f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs
@@ -68,7 +68,7 @@ public abstract partial class MassFluxTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFlux((double)0.0, MassFluxUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>((double)0.0, MassFluxUnit.Undefined));
         }
 
         [Fact]
@@ -83,14 +83,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFlux(double.PositiveInfinity, MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            Assert.Throws<ArgumentException>(() => new MassFlux(double.NegativeInfinity, MassFluxUnit.KilogramPerSecondPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>(double.PositiveInfinity, MassFluxUnit.KilogramPerSecondPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>(double.NegativeInfinity, MassFluxUnit.KilogramPerSecondPerSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFlux(double.NaN, MassFluxUnit.KilogramPerSecondPerSquareMeter));
+            Assert.Throws<ArgumentException>(() => new MassFlux<double>(double.NaN, MassFluxUnit.KilogramPerSecondPerSquareMeter));
         }
 
         [Fact]
@@ -136,7 +136,7 @@ public void MassFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void KilogramPerSecondPerSquareMeterToMassFluxUnits()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             AssertEx.EqualTolerance(GramsPerHourPerSquareCentimeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.GramsPerHourPerSquareCentimeter, GramsPerHourPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(GramsPerHourPerSquareMeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.GramsPerHourPerSquareMeter, GramsPerHourPerSquareMeterTolerance);
             AssertEx.EqualTolerance(GramsPerHourPerSquareMillimeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.GramsPerHourPerSquareMillimeter, GramsPerHourPerSquareMillimeterTolerance);
@@ -154,51 +154,51 @@ public void KilogramPerSecondPerSquareMeterToMassFluxUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MassFlux.From(1, MassFluxUnit.GramPerHourPerSquareCentimeter);
+            var quantity00 = MassFlux<double>.From(1, MassFluxUnit.GramPerHourPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity00.GramsPerHourPerSquareCentimeter, GramsPerHourPerSquareCentimeterTolerance);
             Assert.Equal(MassFluxUnit.GramPerHourPerSquareCentimeter, quantity00.Unit);
 
-            var quantity01 = MassFlux.From(1, MassFluxUnit.GramPerHourPerSquareMeter);
+            var quantity01 = MassFlux<double>.From(1, MassFluxUnit.GramPerHourPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity01.GramsPerHourPerSquareMeter, GramsPerHourPerSquareMeterTolerance);
             Assert.Equal(MassFluxUnit.GramPerHourPerSquareMeter, quantity01.Unit);
 
-            var quantity02 = MassFlux.From(1, MassFluxUnit.GramPerHourPerSquareMillimeter);
+            var quantity02 = MassFlux<double>.From(1, MassFluxUnit.GramPerHourPerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity02.GramsPerHourPerSquareMillimeter, GramsPerHourPerSquareMillimeterTolerance);
             Assert.Equal(MassFluxUnit.GramPerHourPerSquareMillimeter, quantity02.Unit);
 
-            var quantity03 = MassFlux.From(1, MassFluxUnit.GramPerSecondPerSquareCentimeter);
+            var quantity03 = MassFlux<double>.From(1, MassFluxUnit.GramPerSecondPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity03.GramsPerSecondPerSquareCentimeter, GramsPerSecondPerSquareCentimeterTolerance);
             Assert.Equal(MassFluxUnit.GramPerSecondPerSquareCentimeter, quantity03.Unit);
 
-            var quantity04 = MassFlux.From(1, MassFluxUnit.GramPerSecondPerSquareMeter);
+            var quantity04 = MassFlux<double>.From(1, MassFluxUnit.GramPerSecondPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity04.GramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMeterTolerance);
             Assert.Equal(MassFluxUnit.GramPerSecondPerSquareMeter, quantity04.Unit);
 
-            var quantity05 = MassFlux.From(1, MassFluxUnit.GramPerSecondPerSquareMillimeter);
+            var quantity05 = MassFlux<double>.From(1, MassFluxUnit.GramPerSecondPerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity05.GramsPerSecondPerSquareMillimeter, GramsPerSecondPerSquareMillimeterTolerance);
             Assert.Equal(MassFluxUnit.GramPerSecondPerSquareMillimeter, quantity05.Unit);
 
-            var quantity06 = MassFlux.From(1, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
+            var quantity06 = MassFlux<double>.From(1, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity06.KilogramsPerHourPerSquareCentimeter, KilogramsPerHourPerSquareCentimeterTolerance);
             Assert.Equal(MassFluxUnit.KilogramPerHourPerSquareCentimeter, quantity06.Unit);
 
-            var quantity07 = MassFlux.From(1, MassFluxUnit.KilogramPerHourPerSquareMeter);
+            var quantity07 = MassFlux<double>.From(1, MassFluxUnit.KilogramPerHourPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity07.KilogramsPerHourPerSquareMeter, KilogramsPerHourPerSquareMeterTolerance);
             Assert.Equal(MassFluxUnit.KilogramPerHourPerSquareMeter, quantity07.Unit);
 
-            var quantity08 = MassFlux.From(1, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
+            var quantity08 = MassFlux<double>.From(1, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity08.KilogramsPerHourPerSquareMillimeter, KilogramsPerHourPerSquareMillimeterTolerance);
             Assert.Equal(MassFluxUnit.KilogramPerHourPerSquareMillimeter, quantity08.Unit);
 
-            var quantity09 = MassFlux.From(1, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
+            var quantity09 = MassFlux<double>.From(1, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity09.KilogramsPerSecondPerSquareCentimeter, KilogramsPerSecondPerSquareCentimeterTolerance);
             Assert.Equal(MassFluxUnit.KilogramPerSecondPerSquareCentimeter, quantity09.Unit);
 
-            var quantity10 = MassFlux.From(1, MassFluxUnit.KilogramPerSecondPerSquareMeter);
+            var quantity10 = MassFlux<double>.From(1, MassFluxUnit.KilogramPerSecondPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity10.KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
             Assert.Equal(MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity10.Unit);
 
-            var quantity11 = MassFlux.From(1, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
+            var quantity11 = MassFlux<double>.From(1, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity11.KilogramsPerSecondPerSquareMillimeter, KilogramsPerSecondPerSquareMillimeterTolerance);
             Assert.Equal(MassFluxUnit.KilogramPerSecondPerSquareMillimeter, quantity11.Unit);
 
@@ -207,20 +207,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramsPerSecondPerSquareMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassFlux.FromKilogramsPerSecondPerSquareMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MassFlux.FromKilogramsPerSecondPerSquareMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramsPerSecondPerSquareMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassFlux.FromKilogramsPerSecondPerSquareMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            var kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             AssertEx.EqualTolerance(GramsPerHourPerSquareCentimeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.As(MassFluxUnit.GramPerHourPerSquareCentimeter), GramsPerHourPerSquareCentimeterTolerance);
             AssertEx.EqualTolerance(GramsPerHourPerSquareMeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.As(MassFluxUnit.GramPerHourPerSquareMeter), GramsPerHourPerSquareMeterTolerance);
             AssertEx.EqualTolerance(GramsPerHourPerSquareMillimeterInOneKilogramPerSecondPerSquareMeter, kilogrampersecondpersquaremeter.As(MassFluxUnit.GramPerHourPerSquareMillimeter), GramsPerHourPerSquareMillimeterTolerance);
@@ -255,7 +255,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            var kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
 
             var gramperhourpersquarecentimeterQuantity = kilogrampersecondpersquaremeter.ToUnit(MassFluxUnit.GramPerHourPerSquareCentimeter);
             AssertEx.EqualTolerance(GramsPerHourPerSquareCentimeterInOneKilogramPerSecondPerSquareMeter, (double)gramperhourpersquarecentimeterQuantity.Value, GramsPerHourPerSquareCentimeterTolerance);
@@ -316,39 +316,39 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMillimeterTolerance);
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromGramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromGramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromGramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromGramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromGramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromGramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromKilogramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromKilogramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromKilogramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromKilogramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, MassFlux<double>.FromKilogramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMillimeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MassFlux v = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> v = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             AssertEx.EqualTolerance(-1, -v.KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassFlux.FromKilogramsPerSecondPerSquareMeter(3)-v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(3)-v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassFlux.FromKilogramsPerSecondPerSquareMeter(10)/5).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, MassFlux.FromKilogramsPerSecondPerSquareMeter(10)/MassFlux.FromKilogramsPerSecondPerSquareMeter(5), KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, (MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(10)/5).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(2, MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(10)/MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(5), KilogramsPerSecondPerSquareMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MassFlux oneKilogramPerSecondPerSquareMeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
-            MassFlux twoKilogramsPerSecondPerSquareMeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(2);
+            MassFlux<double> oneKilogramPerSecondPerSquareMeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> twoKilogramsPerSecondPerSquareMeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
 
             Assert.True(oneKilogramPerSecondPerSquareMeter < twoKilogramsPerSecondPerSquareMeter);
             Assert.True(oneKilogramPerSecondPerSquareMeter <= twoKilogramsPerSecondPerSquareMeter);
@@ -364,31 +364,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             Assert.Equal(0, kilogrampersecondpersquaremeter.CompareTo(kilogrampersecondpersquaremeter));
-            Assert.True(kilogrampersecondpersquaremeter.CompareTo(MassFlux.Zero) > 0);
-            Assert.True(MassFlux.Zero.CompareTo(kilogrampersecondpersquaremeter) < 0);
+            Assert.True(kilogrampersecondpersquaremeter.CompareTo(MassFlux<double>.Zero) > 0);
+            Assert.True(MassFlux<double>.Zero.CompareTo(kilogrampersecondpersquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             Assert.Throws<ArgumentException>(() => kilogrampersecondpersquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             Assert.Throws<ArgumentNullException>(() => kilogrampersecondpersquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
-            var b = MassFlux.FromKilogramsPerSecondPerSquareMeter(2);
+            var a = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            var b = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -407,8 +407,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
-            var b = MassFlux.FromKilogramsPerSecondPerSquareMeter(2);
+            var a = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            var b = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -428,9 +428,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
-            Assert.True(v.Equals(MassFlux.FromKilogramsPerSecondPerSquareMeter(1), KilogramsPerSecondPerSquareMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MassFlux.Zero, KilogramsPerSecondPerSquareMeterTolerance, ComparisonType.Relative));
+            var v = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
+            Assert.True(v.Equals(MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1), KilogramsPerSecondPerSquareMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MassFlux<double>.Zero, KilogramsPerSecondPerSquareMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -443,21 +443,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             Assert.False(kilogrampersecondpersquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
+            MassFlux<double> kilogrampersecondpersquaremeter = MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1);
             Assert.False(kilogrampersecondpersquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MassFluxUnit.Undefined, MassFlux.Units);
+            Assert.DoesNotContain(MassFluxUnit.Undefined, MassFlux<double>.Units);
         }
 
         [Fact]
@@ -476,7 +476,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MassFlux.BaseDimensions is null);
+            Assert.False(MassFlux<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs
index 54fb4972ea..64f6edfd97 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs
@@ -92,7 +92,7 @@ public abstract partial class MassFractionTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFraction((double)0.0, MassFractionUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MassFraction<double>((double)0.0, MassFractionUnit.Undefined));
         }
 
         [Fact]
@@ -107,14 +107,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFraction(double.PositiveInfinity, MassFractionUnit.DecimalFraction));
-            Assert.Throws<ArgumentException>(() => new MassFraction(double.NegativeInfinity, MassFractionUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new MassFraction<double>(double.PositiveInfinity, MassFractionUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new MassFraction<double>(double.NegativeInfinity, MassFractionUnit.DecimalFraction));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassFraction(double.NaN, MassFractionUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new MassFraction<double>(double.NaN, MassFractionUnit.DecimalFraction));
         }
 
         [Fact]
@@ -160,7 +160,7 @@ public void MassFraction_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DecimalFractionToMassFractionUnits()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
+            MassFraction<double> decimalfraction = MassFraction<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(CentigramsPerGramInOneDecimalFraction, decimalfraction.CentigramsPerGram, CentigramsPerGramTolerance);
             AssertEx.EqualTolerance(CentigramsPerKilogramInOneDecimalFraction, decimalfraction.CentigramsPerKilogram, CentigramsPerKilogramTolerance);
             AssertEx.EqualTolerance(DecagramsPerGramInOneDecimalFraction, decimalfraction.DecagramsPerGram, DecagramsPerGramTolerance);
@@ -190,99 +190,99 @@ public void DecimalFractionToMassFractionUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MassFraction.From(1, MassFractionUnit.CentigramPerGram);
+            var quantity00 = MassFraction<double>.From(1, MassFractionUnit.CentigramPerGram);
             AssertEx.EqualTolerance(1, quantity00.CentigramsPerGram, CentigramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.CentigramPerGram, quantity00.Unit);
 
-            var quantity01 = MassFraction.From(1, MassFractionUnit.CentigramPerKilogram);
+            var quantity01 = MassFraction<double>.From(1, MassFractionUnit.CentigramPerKilogram);
             AssertEx.EqualTolerance(1, quantity01.CentigramsPerKilogram, CentigramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.CentigramPerKilogram, quantity01.Unit);
 
-            var quantity02 = MassFraction.From(1, MassFractionUnit.DecagramPerGram);
+            var quantity02 = MassFraction<double>.From(1, MassFractionUnit.DecagramPerGram);
             AssertEx.EqualTolerance(1, quantity02.DecagramsPerGram, DecagramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.DecagramPerGram, quantity02.Unit);
 
-            var quantity03 = MassFraction.From(1, MassFractionUnit.DecagramPerKilogram);
+            var quantity03 = MassFraction<double>.From(1, MassFractionUnit.DecagramPerKilogram);
             AssertEx.EqualTolerance(1, quantity03.DecagramsPerKilogram, DecagramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.DecagramPerKilogram, quantity03.Unit);
 
-            var quantity04 = MassFraction.From(1, MassFractionUnit.DecigramPerGram);
+            var quantity04 = MassFraction<double>.From(1, MassFractionUnit.DecigramPerGram);
             AssertEx.EqualTolerance(1, quantity04.DecigramsPerGram, DecigramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.DecigramPerGram, quantity04.Unit);
 
-            var quantity05 = MassFraction.From(1, MassFractionUnit.DecigramPerKilogram);
+            var quantity05 = MassFraction<double>.From(1, MassFractionUnit.DecigramPerKilogram);
             AssertEx.EqualTolerance(1, quantity05.DecigramsPerKilogram, DecigramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.DecigramPerKilogram, quantity05.Unit);
 
-            var quantity06 = MassFraction.From(1, MassFractionUnit.DecimalFraction);
+            var quantity06 = MassFraction<double>.From(1, MassFractionUnit.DecimalFraction);
             AssertEx.EqualTolerance(1, quantity06.DecimalFractions, DecimalFractionsTolerance);
             Assert.Equal(MassFractionUnit.DecimalFraction, quantity06.Unit);
 
-            var quantity07 = MassFraction.From(1, MassFractionUnit.GramPerGram);
+            var quantity07 = MassFraction<double>.From(1, MassFractionUnit.GramPerGram);
             AssertEx.EqualTolerance(1, quantity07.GramsPerGram, GramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.GramPerGram, quantity07.Unit);
 
-            var quantity08 = MassFraction.From(1, MassFractionUnit.GramPerKilogram);
+            var quantity08 = MassFraction<double>.From(1, MassFractionUnit.GramPerKilogram);
             AssertEx.EqualTolerance(1, quantity08.GramsPerKilogram, GramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.GramPerKilogram, quantity08.Unit);
 
-            var quantity09 = MassFraction.From(1, MassFractionUnit.HectogramPerGram);
+            var quantity09 = MassFraction<double>.From(1, MassFractionUnit.HectogramPerGram);
             AssertEx.EqualTolerance(1, quantity09.HectogramsPerGram, HectogramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.HectogramPerGram, quantity09.Unit);
 
-            var quantity10 = MassFraction.From(1, MassFractionUnit.HectogramPerKilogram);
+            var quantity10 = MassFraction<double>.From(1, MassFractionUnit.HectogramPerKilogram);
             AssertEx.EqualTolerance(1, quantity10.HectogramsPerKilogram, HectogramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.HectogramPerKilogram, quantity10.Unit);
 
-            var quantity11 = MassFraction.From(1, MassFractionUnit.KilogramPerGram);
+            var quantity11 = MassFraction<double>.From(1, MassFractionUnit.KilogramPerGram);
             AssertEx.EqualTolerance(1, quantity11.KilogramsPerGram, KilogramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.KilogramPerGram, quantity11.Unit);
 
-            var quantity12 = MassFraction.From(1, MassFractionUnit.KilogramPerKilogram);
+            var quantity12 = MassFraction<double>.From(1, MassFractionUnit.KilogramPerKilogram);
             AssertEx.EqualTolerance(1, quantity12.KilogramsPerKilogram, KilogramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.KilogramPerKilogram, quantity12.Unit);
 
-            var quantity13 = MassFraction.From(1, MassFractionUnit.MicrogramPerGram);
+            var quantity13 = MassFraction<double>.From(1, MassFractionUnit.MicrogramPerGram);
             AssertEx.EqualTolerance(1, quantity13.MicrogramsPerGram, MicrogramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.MicrogramPerGram, quantity13.Unit);
 
-            var quantity14 = MassFraction.From(1, MassFractionUnit.MicrogramPerKilogram);
+            var quantity14 = MassFraction<double>.From(1, MassFractionUnit.MicrogramPerKilogram);
             AssertEx.EqualTolerance(1, quantity14.MicrogramsPerKilogram, MicrogramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.MicrogramPerKilogram, quantity14.Unit);
 
-            var quantity15 = MassFraction.From(1, MassFractionUnit.MilligramPerGram);
+            var quantity15 = MassFraction<double>.From(1, MassFractionUnit.MilligramPerGram);
             AssertEx.EqualTolerance(1, quantity15.MilligramsPerGram, MilligramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.MilligramPerGram, quantity15.Unit);
 
-            var quantity16 = MassFraction.From(1, MassFractionUnit.MilligramPerKilogram);
+            var quantity16 = MassFraction<double>.From(1, MassFractionUnit.MilligramPerKilogram);
             AssertEx.EqualTolerance(1, quantity16.MilligramsPerKilogram, MilligramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.MilligramPerKilogram, quantity16.Unit);
 
-            var quantity17 = MassFraction.From(1, MassFractionUnit.NanogramPerGram);
+            var quantity17 = MassFraction<double>.From(1, MassFractionUnit.NanogramPerGram);
             AssertEx.EqualTolerance(1, quantity17.NanogramsPerGram, NanogramsPerGramTolerance);
             Assert.Equal(MassFractionUnit.NanogramPerGram, quantity17.Unit);
 
-            var quantity18 = MassFraction.From(1, MassFractionUnit.NanogramPerKilogram);
+            var quantity18 = MassFraction<double>.From(1, MassFractionUnit.NanogramPerKilogram);
             AssertEx.EqualTolerance(1, quantity18.NanogramsPerKilogram, NanogramsPerKilogramTolerance);
             Assert.Equal(MassFractionUnit.NanogramPerKilogram, quantity18.Unit);
 
-            var quantity19 = MassFraction.From(1, MassFractionUnit.PartPerBillion);
+            var quantity19 = MassFraction<double>.From(1, MassFractionUnit.PartPerBillion);
             AssertEx.EqualTolerance(1, quantity19.PartsPerBillion, PartsPerBillionTolerance);
             Assert.Equal(MassFractionUnit.PartPerBillion, quantity19.Unit);
 
-            var quantity20 = MassFraction.From(1, MassFractionUnit.PartPerMillion);
+            var quantity20 = MassFraction<double>.From(1, MassFractionUnit.PartPerMillion);
             AssertEx.EqualTolerance(1, quantity20.PartsPerMillion, PartsPerMillionTolerance);
             Assert.Equal(MassFractionUnit.PartPerMillion, quantity20.Unit);
 
-            var quantity21 = MassFraction.From(1, MassFractionUnit.PartPerThousand);
+            var quantity21 = MassFraction<double>.From(1, MassFractionUnit.PartPerThousand);
             AssertEx.EqualTolerance(1, quantity21.PartsPerThousand, PartsPerThousandTolerance);
             Assert.Equal(MassFractionUnit.PartPerThousand, quantity21.Unit);
 
-            var quantity22 = MassFraction.From(1, MassFractionUnit.PartPerTrillion);
+            var quantity22 = MassFraction<double>.From(1, MassFractionUnit.PartPerTrillion);
             AssertEx.EqualTolerance(1, quantity22.PartsPerTrillion, PartsPerTrillionTolerance);
             Assert.Equal(MassFractionUnit.PartPerTrillion, quantity22.Unit);
 
-            var quantity23 = MassFraction.From(1, MassFractionUnit.Percent);
+            var quantity23 = MassFraction<double>.From(1, MassFractionUnit.Percent);
             AssertEx.EqualTolerance(1, quantity23.Percent, PercentTolerance);
             Assert.Equal(MassFractionUnit.Percent, quantity23.Unit);
 
@@ -291,20 +291,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDecimalFractions_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassFraction.FromDecimalFractions(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MassFraction.FromDecimalFractions(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MassFraction<double>.FromDecimalFractions(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MassFraction<double>.FromDecimalFractions(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDecimalFractions_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassFraction.FromDecimalFractions(double.NaN));
+            Assert.Throws<ArgumentException>(() => MassFraction<double>.FromDecimalFractions(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var decimalfraction = MassFraction.FromDecimalFractions(1);
+            var decimalfraction = MassFraction<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(CentigramsPerGramInOneDecimalFraction, decimalfraction.As(MassFractionUnit.CentigramPerGram), CentigramsPerGramTolerance);
             AssertEx.EqualTolerance(CentigramsPerKilogramInOneDecimalFraction, decimalfraction.As(MassFractionUnit.CentigramPerKilogram), CentigramsPerKilogramTolerance);
             AssertEx.EqualTolerance(DecagramsPerGramInOneDecimalFraction, decimalfraction.As(MassFractionUnit.DecagramPerGram), DecagramsPerGramTolerance);
@@ -351,7 +351,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var decimalfraction = MassFraction.FromDecimalFractions(1);
+            var decimalfraction = MassFraction<double>.FromDecimalFractions(1);
 
             var centigrampergramQuantity = decimalfraction.ToUnit(MassFractionUnit.CentigramPerGram);
             AssertEx.EqualTolerance(CentigramsPerGramInOneDecimalFraction, (double)centigrampergramQuantity.Value, CentigramsPerGramTolerance);
@@ -460,51 +460,51 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(1, MassFraction.FromCentigramsPerGram(decimalfraction.CentigramsPerGram).DecimalFractions, CentigramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromCentigramsPerKilogram(decimalfraction.CentigramsPerKilogram).DecimalFractions, CentigramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecagramsPerGram(decimalfraction.DecagramsPerGram).DecimalFractions, DecagramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecagramsPerKilogram(decimalfraction.DecagramsPerKilogram).DecimalFractions, DecagramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecigramsPerGram(decimalfraction.DecigramsPerGram).DecimalFractions, DecigramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecigramsPerKilogram(decimalfraction.DecigramsPerKilogram).DecimalFractions, DecigramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromGramsPerGram(decimalfraction.GramsPerGram).DecimalFractions, GramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromGramsPerKilogram(decimalfraction.GramsPerKilogram).DecimalFractions, GramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromHectogramsPerGram(decimalfraction.HectogramsPerGram).DecimalFractions, HectogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromHectogramsPerKilogram(decimalfraction.HectogramsPerKilogram).DecimalFractions, HectogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromKilogramsPerGram(decimalfraction.KilogramsPerGram).DecimalFractions, KilogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromKilogramsPerKilogram(decimalfraction.KilogramsPerKilogram).DecimalFractions, KilogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMicrogramsPerGram(decimalfraction.MicrogramsPerGram).DecimalFractions, MicrogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMicrogramsPerKilogram(decimalfraction.MicrogramsPerKilogram).DecimalFractions, MicrogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMilligramsPerGram(decimalfraction.MilligramsPerGram).DecimalFractions, MilligramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMilligramsPerKilogram(decimalfraction.MilligramsPerKilogram).DecimalFractions, MilligramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromNanogramsPerGram(decimalfraction.NanogramsPerGram).DecimalFractions, NanogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromNanogramsPerKilogram(decimalfraction.NanogramsPerKilogram).DecimalFractions, NanogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
+            MassFraction<double> decimalfraction = MassFraction<double>.FromDecimalFractions(1);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromCentigramsPerGram(decimalfraction.CentigramsPerGram).DecimalFractions, CentigramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromCentigramsPerKilogram(decimalfraction.CentigramsPerKilogram).DecimalFractions, CentigramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromDecagramsPerGram(decimalfraction.DecagramsPerGram).DecimalFractions, DecagramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromDecagramsPerKilogram(decimalfraction.DecagramsPerKilogram).DecimalFractions, DecagramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromDecigramsPerGram(decimalfraction.DecigramsPerGram).DecimalFractions, DecigramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromDecigramsPerKilogram(decimalfraction.DecigramsPerKilogram).DecimalFractions, DecigramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromGramsPerGram(decimalfraction.GramsPerGram).DecimalFractions, GramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromGramsPerKilogram(decimalfraction.GramsPerKilogram).DecimalFractions, GramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromHectogramsPerGram(decimalfraction.HectogramsPerGram).DecimalFractions, HectogramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromHectogramsPerKilogram(decimalfraction.HectogramsPerKilogram).DecimalFractions, HectogramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromKilogramsPerGram(decimalfraction.KilogramsPerGram).DecimalFractions, KilogramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromKilogramsPerKilogram(decimalfraction.KilogramsPerKilogram).DecimalFractions, KilogramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromMicrogramsPerGram(decimalfraction.MicrogramsPerGram).DecimalFractions, MicrogramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromMicrogramsPerKilogram(decimalfraction.MicrogramsPerKilogram).DecimalFractions, MicrogramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromMilligramsPerGram(decimalfraction.MilligramsPerGram).DecimalFractions, MilligramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromMilligramsPerKilogram(decimalfraction.MilligramsPerKilogram).DecimalFractions, MilligramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromNanogramsPerGram(decimalfraction.NanogramsPerGram).DecimalFractions, NanogramsPerGramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromNanogramsPerKilogram(decimalfraction.NanogramsPerKilogram).DecimalFractions, NanogramsPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
+            AssertEx.EqualTolerance(1, MassFraction<double>.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MassFraction v = MassFraction.FromDecimalFractions(1);
+            MassFraction<double> v = MassFraction<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (MassFraction.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (MassFraction<double>.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(10, (v*10).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(10, (10*v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (MassFraction.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, MassFraction.FromDecimalFractions(10)/MassFraction.FromDecimalFractions(5), DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (MassFraction<double>.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, MassFraction<double>.FromDecimalFractions(10)/MassFraction<double>.FromDecimalFractions(5), DecimalFractionsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MassFraction oneDecimalFraction = MassFraction.FromDecimalFractions(1);
-            MassFraction twoDecimalFractions = MassFraction.FromDecimalFractions(2);
+            MassFraction<double> oneDecimalFraction = MassFraction<double>.FromDecimalFractions(1);
+            MassFraction<double> twoDecimalFractions = MassFraction<double>.FromDecimalFractions(2);
 
             Assert.True(oneDecimalFraction < twoDecimalFractions);
             Assert.True(oneDecimalFraction <= twoDecimalFractions);
@@ -520,31 +520,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
+            MassFraction<double> decimalfraction = MassFraction<double>.FromDecimalFractions(1);
             Assert.Equal(0, decimalfraction.CompareTo(decimalfraction));
-            Assert.True(decimalfraction.CompareTo(MassFraction.Zero) > 0);
-            Assert.True(MassFraction.Zero.CompareTo(decimalfraction) < 0);
+            Assert.True(decimalfraction.CompareTo(MassFraction<double>.Zero) > 0);
+            Assert.True(MassFraction<double>.Zero.CompareTo(decimalfraction) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
+            MassFraction<double> decimalfraction = MassFraction<double>.FromDecimalFractions(1);
             Assert.Throws<ArgumentException>(() => decimalfraction.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
+            MassFraction<double> decimalfraction = MassFraction<double>.FromDecimalFractions(1);
             Assert.Throws<ArgumentNullException>(() => decimalfraction.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MassFraction.FromDecimalFractions(1);
-            var b = MassFraction.FromDecimalFractions(2);
+            var a = MassFraction<double>.FromDecimalFractions(1);
+            var b = MassFraction<double>.FromDecimalFractions(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -563,8 +563,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MassFraction.FromDecimalFractions(1);
-            var b = MassFraction.FromDecimalFractions(2);
+            var a = MassFraction<double>.FromDecimalFractions(1);
+            var b = MassFraction<double>.FromDecimalFractions(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -584,9 +584,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MassFraction.FromDecimalFractions(1);
-            Assert.True(v.Equals(MassFraction.FromDecimalFractions(1), DecimalFractionsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MassFraction.Zero, DecimalFractionsTolerance, ComparisonType.Relative));
+            var v = MassFraction<double>.FromDecimalFractions(1);
+            Assert.True(v.Equals(MassFraction<double>.FromDecimalFractions(1), DecimalFractionsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MassFraction<double>.Zero, DecimalFractionsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -599,21 +599,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
+            MassFraction<double> decimalfraction = MassFraction<double>.FromDecimalFractions(1);
             Assert.False(decimalfraction.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
+            MassFraction<double> decimalfraction = MassFraction<double>.FromDecimalFractions(1);
             Assert.False(decimalfraction.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MassFractionUnit.Undefined, MassFraction.Units);
+            Assert.DoesNotContain(MassFractionUnit.Undefined, MassFraction<double>.Units);
         }
 
         [Fact]
@@ -632,7 +632,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MassFraction.BaseDimensions is null);
+            Assert.False(MassFraction<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs
index b2423f226e..c78da6e2ed 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs
@@ -100,7 +100,7 @@ public abstract partial class MassMomentOfInertiaTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia((double)0.0, MassMomentOfInertiaUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia<double>((double)0.0, MassMomentOfInertiaUnit.Undefined));
         }
 
         [Fact]
@@ -115,14 +115,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia(double.PositiveInfinity, MassMomentOfInertiaUnit.KilogramSquareMeter));
-            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia(double.NegativeInfinity, MassMomentOfInertiaUnit.KilogramSquareMeter));
+            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia<double>(double.PositiveInfinity, MassMomentOfInertiaUnit.KilogramSquareMeter));
+            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia<double>(double.NegativeInfinity, MassMomentOfInertiaUnit.KilogramSquareMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia(double.NaN, MassMomentOfInertiaUnit.KilogramSquareMeter));
+            Assert.Throws<ArgumentException>(() => new MassMomentOfInertia<double>(double.NaN, MassMomentOfInertiaUnit.KilogramSquareMeter));
         }
 
         [Fact]
@@ -168,7 +168,7 @@ public void MassMomentOfInertia_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void KilogramSquareMeterToMassMomentOfInertiaUnits()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             AssertEx.EqualTolerance(GramSquareCentimetersInOneKilogramSquareMeter, kilogramsquaremeter.GramSquareCentimeters, GramSquareCentimetersTolerance);
             AssertEx.EqualTolerance(GramSquareDecimetersInOneKilogramSquareMeter, kilogramsquaremeter.GramSquareDecimeters, GramSquareDecimetersTolerance);
             AssertEx.EqualTolerance(GramSquareMetersInOneKilogramSquareMeter, kilogramsquaremeter.GramSquareMeters, GramSquareMetersTolerance);
@@ -202,115 +202,115 @@ public void KilogramSquareMeterToMassMomentOfInertiaUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.GramSquareCentimeter);
+            var quantity00 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.GramSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity00.GramSquareCentimeters, GramSquareCentimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.GramSquareCentimeter, quantity00.Unit);
 
-            var quantity01 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.GramSquareDecimeter);
+            var quantity01 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.GramSquareDecimeter);
             AssertEx.EqualTolerance(1, quantity01.GramSquareDecimeters, GramSquareDecimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.GramSquareDecimeter, quantity01.Unit);
 
-            var quantity02 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.GramSquareMeter);
+            var quantity02 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.GramSquareMeter);
             AssertEx.EqualTolerance(1, quantity02.GramSquareMeters, GramSquareMetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.GramSquareMeter, quantity02.Unit);
 
-            var quantity03 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.GramSquareMillimeter);
+            var quantity03 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.GramSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity03.GramSquareMillimeters, GramSquareMillimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.GramSquareMillimeter, quantity03.Unit);
 
-            var quantity04 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
+            var quantity04 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity04.KilogramSquareCentimeters, KilogramSquareCentimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareCentimeter, quantity04.Unit);
 
-            var quantity05 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
+            var quantity05 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
             AssertEx.EqualTolerance(1, quantity05.KilogramSquareDecimeters, KilogramSquareDecimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareDecimeter, quantity05.Unit);
 
-            var quantity06 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilogramSquareMeter);
+            var quantity06 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilogramSquareMeter);
             AssertEx.EqualTolerance(1, quantity06.KilogramSquareMeters, KilogramSquareMetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareMeter, quantity06.Unit);
 
-            var quantity07 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
+            var quantity07 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity07.KilogramSquareMillimeters, KilogramSquareMillimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareMillimeter, quantity07.Unit);
 
-            var quantity08 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
+            var quantity08 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity08.KilotonneSquareCentimeters, KilotonneSquareCentimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, quantity08.Unit);
 
-            var quantity09 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
+            var quantity09 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
             AssertEx.EqualTolerance(1, quantity09.KilotonneSquareDecimeters, KilotonneSquareDecimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, quantity09.Unit);
 
-            var quantity10 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilotonneSquareMeter);
+            var quantity10 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilotonneSquareMeter);
             AssertEx.EqualTolerance(1, quantity10.KilotonneSquareMeters, KilotonneSquareMetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareMeter, quantity10.Unit);
 
-            var quantity11 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
+            var quantity11 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
             AssertEx.EqualTolerance(1, quantity11.KilotonneSquareMilimeters, KilotonneSquareMilimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, quantity11.Unit);
 
-            var quantity12 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
+            var quantity12 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity12.MegatonneSquareCentimeters, MegatonneSquareCentimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, quantity12.Unit);
 
-            var quantity13 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
+            var quantity13 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
             AssertEx.EqualTolerance(1, quantity13.MegatonneSquareDecimeters, MegatonneSquareDecimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, quantity13.Unit);
 
-            var quantity14 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MegatonneSquareMeter);
+            var quantity14 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MegatonneSquareMeter);
             AssertEx.EqualTolerance(1, quantity14.MegatonneSquareMeters, MegatonneSquareMetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareMeter, quantity14.Unit);
 
-            var quantity15 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
+            var quantity15 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
             AssertEx.EqualTolerance(1, quantity15.MegatonneSquareMilimeters, MegatonneSquareMilimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, quantity15.Unit);
 
-            var quantity16 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
+            var quantity16 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity16.MilligramSquareCentimeters, MilligramSquareCentimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareCentimeter, quantity16.Unit);
 
-            var quantity17 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
+            var quantity17 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
             AssertEx.EqualTolerance(1, quantity17.MilligramSquareDecimeters, MilligramSquareDecimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareDecimeter, quantity17.Unit);
 
-            var quantity18 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MilligramSquareMeter);
+            var quantity18 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MilligramSquareMeter);
             AssertEx.EqualTolerance(1, quantity18.MilligramSquareMeters, MilligramSquareMetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareMeter, quantity18.Unit);
 
-            var quantity19 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
+            var quantity19 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity19.MilligramSquareMillimeters, MilligramSquareMillimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareMillimeter, quantity19.Unit);
 
-            var quantity20 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.PoundSquareFoot);
+            var quantity20 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.PoundSquareFoot);
             AssertEx.EqualTolerance(1, quantity20.PoundSquareFeet, PoundSquareFeetTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.PoundSquareFoot, quantity20.Unit);
 
-            var quantity21 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.PoundSquareInch);
+            var quantity21 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.PoundSquareInch);
             AssertEx.EqualTolerance(1, quantity21.PoundSquareInches, PoundSquareInchesTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.PoundSquareInch, quantity21.Unit);
 
-            var quantity22 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.SlugSquareFoot);
+            var quantity22 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.SlugSquareFoot);
             AssertEx.EqualTolerance(1, quantity22.SlugSquareFeet, SlugSquareFeetTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.SlugSquareFoot, quantity22.Unit);
 
-            var quantity23 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.SlugSquareInch);
+            var quantity23 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.SlugSquareInch);
             AssertEx.EqualTolerance(1, quantity23.SlugSquareInches, SlugSquareInchesTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.SlugSquareInch, quantity23.Unit);
 
-            var quantity24 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.TonneSquareCentimeter);
+            var quantity24 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.TonneSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity24.TonneSquareCentimeters, TonneSquareCentimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.TonneSquareCentimeter, quantity24.Unit);
 
-            var quantity25 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.TonneSquareDecimeter);
+            var quantity25 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.TonneSquareDecimeter);
             AssertEx.EqualTolerance(1, quantity25.TonneSquareDecimeters, TonneSquareDecimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.TonneSquareDecimeter, quantity25.Unit);
 
-            var quantity26 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.TonneSquareMeter);
+            var quantity26 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.TonneSquareMeter);
             AssertEx.EqualTolerance(1, quantity26.TonneSquareMeters, TonneSquareMetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.TonneSquareMeter, quantity26.Unit);
 
-            var quantity27 = MassMomentOfInertia.From(1, MassMomentOfInertiaUnit.TonneSquareMilimeter);
+            var quantity27 = MassMomentOfInertia<double>.From(1, MassMomentOfInertiaUnit.TonneSquareMilimeter);
             AssertEx.EqualTolerance(1, quantity27.TonneSquareMilimeters, TonneSquareMilimetersTolerance);
             Assert.Equal(MassMomentOfInertiaUnit.TonneSquareMilimeter, quantity27.Unit);
 
@@ -319,20 +319,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramSquareMeters_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassMomentOfInertia.FromKilogramSquareMeters(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MassMomentOfInertia.FromKilogramSquareMeters(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MassMomentOfInertia<double>.FromKilogramSquareMeters(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MassMomentOfInertia<double>.FromKilogramSquareMeters(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramSquareMeters_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MassMomentOfInertia.FromKilogramSquareMeters(double.NaN));
+            Assert.Throws<ArgumentException>(() => MassMomentOfInertia<double>.FromKilogramSquareMeters(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            var kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             AssertEx.EqualTolerance(GramSquareCentimetersInOneKilogramSquareMeter, kilogramsquaremeter.As(MassMomentOfInertiaUnit.GramSquareCentimeter), GramSquareCentimetersTolerance);
             AssertEx.EqualTolerance(GramSquareDecimetersInOneKilogramSquareMeter, kilogramsquaremeter.As(MassMomentOfInertiaUnit.GramSquareDecimeter), GramSquareDecimetersTolerance);
             AssertEx.EqualTolerance(GramSquareMetersInOneKilogramSquareMeter, kilogramsquaremeter.As(MassMomentOfInertiaUnit.GramSquareMeter), GramSquareMetersTolerance);
@@ -383,7 +383,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            var kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
 
             var gramsquarecentimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter);
             AssertEx.EqualTolerance(GramSquareCentimetersInOneKilogramSquareMeter, (double)gramsquarecentimeterQuantity.Value, GramSquareCentimetersTolerance);
@@ -508,55 +508,55 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareCentimeters(kilogramsquaremeter.GramSquareCentimeters).KilogramSquareMeters, GramSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareDecimeters(kilogramsquaremeter.GramSquareDecimeters).KilogramSquareMeters, GramSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareMeters(kilogramsquaremeter.GramSquareMeters).KilogramSquareMeters, GramSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareMillimeters(kilogramsquaremeter.GramSquareMillimeters).KilogramSquareMeters, GramSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareCentimeters(kilogramsquaremeter.KilogramSquareCentimeters).KilogramSquareMeters, KilogramSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareDecimeters(kilogramsquaremeter.KilogramSquareDecimeters).KilogramSquareMeters, KilogramSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareMeters(kilogramsquaremeter.KilogramSquareMeters).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareMillimeters(kilogramsquaremeter.KilogramSquareMillimeters).KilogramSquareMeters, KilogramSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareCentimeters(kilogramsquaremeter.KilotonneSquareCentimeters).KilogramSquareMeters, KilotonneSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareDecimeters(kilogramsquaremeter.KilotonneSquareDecimeters).KilogramSquareMeters, KilotonneSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareMeters(kilogramsquaremeter.KilotonneSquareMeters).KilogramSquareMeters, KilotonneSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareMilimeters(kilogramsquaremeter.KilotonneSquareMilimeters).KilogramSquareMeters, KilotonneSquareMilimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareCentimeters(kilogramsquaremeter.MegatonneSquareCentimeters).KilogramSquareMeters, MegatonneSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareDecimeters(kilogramsquaremeter.MegatonneSquareDecimeters).KilogramSquareMeters, MegatonneSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareMeters(kilogramsquaremeter.MegatonneSquareMeters).KilogramSquareMeters, MegatonneSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareMilimeters(kilogramsquaremeter.MegatonneSquareMilimeters).KilogramSquareMeters, MegatonneSquareMilimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareCentimeters(kilogramsquaremeter.MilligramSquareCentimeters).KilogramSquareMeters, MilligramSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareDecimeters(kilogramsquaremeter.MilligramSquareDecimeters).KilogramSquareMeters, MilligramSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareMeters(kilogramsquaremeter.MilligramSquareMeters).KilogramSquareMeters, MilligramSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareMillimeters(kilogramsquaremeter.MilligramSquareMillimeters).KilogramSquareMeters, MilligramSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromPoundSquareFeet(kilogramsquaremeter.PoundSquareFeet).KilogramSquareMeters, PoundSquareFeetTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromPoundSquareInches(kilogramsquaremeter.PoundSquareInches).KilogramSquareMeters, PoundSquareInchesTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromSlugSquareFeet(kilogramsquaremeter.SlugSquareFeet).KilogramSquareMeters, SlugSquareFeetTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromSlugSquareInches(kilogramsquaremeter.SlugSquareInches).KilogramSquareMeters, SlugSquareInchesTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareCentimeters(kilogramsquaremeter.TonneSquareCentimeters).KilogramSquareMeters, TonneSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareDecimeters(kilogramsquaremeter.TonneSquareDecimeters).KilogramSquareMeters, TonneSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareMeters(kilogramsquaremeter.TonneSquareMeters).KilogramSquareMeters, TonneSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareMilimeters(kilogramsquaremeter.TonneSquareMilimeters).KilogramSquareMeters, TonneSquareMilimetersTolerance);
+            MassMomentOfInertia<double> kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromGramSquareCentimeters(kilogramsquaremeter.GramSquareCentimeters).KilogramSquareMeters, GramSquareCentimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromGramSquareDecimeters(kilogramsquaremeter.GramSquareDecimeters).KilogramSquareMeters, GramSquareDecimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromGramSquareMeters(kilogramsquaremeter.GramSquareMeters).KilogramSquareMeters, GramSquareMetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromGramSquareMillimeters(kilogramsquaremeter.GramSquareMillimeters).KilogramSquareMeters, GramSquareMillimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilogramSquareCentimeters(kilogramsquaremeter.KilogramSquareCentimeters).KilogramSquareMeters, KilogramSquareCentimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilogramSquareDecimeters(kilogramsquaremeter.KilogramSquareDecimeters).KilogramSquareMeters, KilogramSquareDecimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilogramSquareMeters(kilogramsquaremeter.KilogramSquareMeters).KilogramSquareMeters, KilogramSquareMetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilogramSquareMillimeters(kilogramsquaremeter.KilogramSquareMillimeters).KilogramSquareMeters, KilogramSquareMillimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilotonneSquareCentimeters(kilogramsquaremeter.KilotonneSquareCentimeters).KilogramSquareMeters, KilotonneSquareCentimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilotonneSquareDecimeters(kilogramsquaremeter.KilotonneSquareDecimeters).KilogramSquareMeters, KilotonneSquareDecimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilotonneSquareMeters(kilogramsquaremeter.KilotonneSquareMeters).KilogramSquareMeters, KilotonneSquareMetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromKilotonneSquareMilimeters(kilogramsquaremeter.KilotonneSquareMilimeters).KilogramSquareMeters, KilotonneSquareMilimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMegatonneSquareCentimeters(kilogramsquaremeter.MegatonneSquareCentimeters).KilogramSquareMeters, MegatonneSquareCentimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMegatonneSquareDecimeters(kilogramsquaremeter.MegatonneSquareDecimeters).KilogramSquareMeters, MegatonneSquareDecimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMegatonneSquareMeters(kilogramsquaremeter.MegatonneSquareMeters).KilogramSquareMeters, MegatonneSquareMetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMegatonneSquareMilimeters(kilogramsquaremeter.MegatonneSquareMilimeters).KilogramSquareMeters, MegatonneSquareMilimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMilligramSquareCentimeters(kilogramsquaremeter.MilligramSquareCentimeters).KilogramSquareMeters, MilligramSquareCentimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMilligramSquareDecimeters(kilogramsquaremeter.MilligramSquareDecimeters).KilogramSquareMeters, MilligramSquareDecimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMilligramSquareMeters(kilogramsquaremeter.MilligramSquareMeters).KilogramSquareMeters, MilligramSquareMetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromMilligramSquareMillimeters(kilogramsquaremeter.MilligramSquareMillimeters).KilogramSquareMeters, MilligramSquareMillimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromPoundSquareFeet(kilogramsquaremeter.PoundSquareFeet).KilogramSquareMeters, PoundSquareFeetTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromPoundSquareInches(kilogramsquaremeter.PoundSquareInches).KilogramSquareMeters, PoundSquareInchesTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromSlugSquareFeet(kilogramsquaremeter.SlugSquareFeet).KilogramSquareMeters, SlugSquareFeetTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromSlugSquareInches(kilogramsquaremeter.SlugSquareInches).KilogramSquareMeters, SlugSquareInchesTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromTonneSquareCentimeters(kilogramsquaremeter.TonneSquareCentimeters).KilogramSquareMeters, TonneSquareCentimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromTonneSquareDecimeters(kilogramsquaremeter.TonneSquareDecimeters).KilogramSquareMeters, TonneSquareDecimetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromTonneSquareMeters(kilogramsquaremeter.TonneSquareMeters).KilogramSquareMeters, TonneSquareMetersTolerance);
+            AssertEx.EqualTolerance(1, MassMomentOfInertia<double>.FromTonneSquareMilimeters(kilogramsquaremeter.TonneSquareMilimeters).KilogramSquareMeters, TonneSquareMilimetersTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MassMomentOfInertia v = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> v = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             AssertEx.EqualTolerance(-1, -v.KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (MassMomentOfInertia.FromKilogramSquareMeters(3)-v).KilogramSquareMeters, KilogramSquareMetersTolerance);
+            AssertEx.EqualTolerance(2, (MassMomentOfInertia<double>.FromKilogramSquareMeters(3)-v).KilogramSquareMeters, KilogramSquareMetersTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramSquareMeters, KilogramSquareMetersTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramSquareMeters, KilogramSquareMetersTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (MassMomentOfInertia.FromKilogramSquareMeters(10)/5).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, MassMomentOfInertia.FromKilogramSquareMeters(10)/MassMomentOfInertia.FromKilogramSquareMeters(5), KilogramSquareMetersTolerance);
+            AssertEx.EqualTolerance(2, (MassMomentOfInertia<double>.FromKilogramSquareMeters(10)/5).KilogramSquareMeters, KilogramSquareMetersTolerance);
+            AssertEx.EqualTolerance(2, MassMomentOfInertia<double>.FromKilogramSquareMeters(10)/MassMomentOfInertia<double>.FromKilogramSquareMeters(5), KilogramSquareMetersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MassMomentOfInertia oneKilogramSquareMeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            MassMomentOfInertia twoKilogramSquareMeters = MassMomentOfInertia.FromKilogramSquareMeters(2);
+            MassMomentOfInertia<double> oneKilogramSquareMeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> twoKilogramSquareMeters = MassMomentOfInertia<double>.FromKilogramSquareMeters(2);
 
             Assert.True(oneKilogramSquareMeter < twoKilogramSquareMeters);
             Assert.True(oneKilogramSquareMeter <= twoKilogramSquareMeters);
@@ -572,31 +572,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             Assert.Equal(0, kilogramsquaremeter.CompareTo(kilogramsquaremeter));
-            Assert.True(kilogramsquaremeter.CompareTo(MassMomentOfInertia.Zero) > 0);
-            Assert.True(MassMomentOfInertia.Zero.CompareTo(kilogramsquaremeter) < 0);
+            Assert.True(kilogramsquaremeter.CompareTo(MassMomentOfInertia<double>.Zero) > 0);
+            Assert.True(MassMomentOfInertia<double>.Zero.CompareTo(kilogramsquaremeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             Assert.Throws<ArgumentException>(() => kilogramsquaremeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             Assert.Throws<ArgumentNullException>(() => kilogramsquaremeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            var b = MassMomentOfInertia.FromKilogramSquareMeters(2);
+            var a = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
+            var b = MassMomentOfInertia<double>.FromKilogramSquareMeters(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -615,8 +615,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            var b = MassMomentOfInertia.FromKilogramSquareMeters(2);
+            var a = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
+            var b = MassMomentOfInertia<double>.FromKilogramSquareMeters(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -636,9 +636,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            Assert.True(v.Equals(MassMomentOfInertia.FromKilogramSquareMeters(1), KilogramSquareMetersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MassMomentOfInertia.Zero, KilogramSquareMetersTolerance, ComparisonType.Relative));
+            var v = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
+            Assert.True(v.Equals(MassMomentOfInertia<double>.FromKilogramSquareMeters(1), KilogramSquareMetersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MassMomentOfInertia<double>.Zero, KilogramSquareMetersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -651,21 +651,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             Assert.False(kilogramsquaremeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
+            MassMomentOfInertia<double> kilogramsquaremeter = MassMomentOfInertia<double>.FromKilogramSquareMeters(1);
             Assert.False(kilogramsquaremeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MassMomentOfInertiaUnit.Undefined, MassMomentOfInertia.Units);
+            Assert.DoesNotContain(MassMomentOfInertiaUnit.Undefined, MassMomentOfInertia<double>.Units);
         }
 
         [Fact]
@@ -684,7 +684,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MassMomentOfInertia.BaseDimensions is null);
+            Assert.False(MassMomentOfInertia<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs
index e020aebb33..b2c999d4f2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs
@@ -94,7 +94,7 @@ public abstract partial class MassTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Mass((double)0.0, MassUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Mass<double>((double)0.0, MassUnit.Undefined));
         }
 
         [Fact]
@@ -109,14 +109,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Mass(double.PositiveInfinity, MassUnit.Kilogram));
-            Assert.Throws<ArgumentException>(() => new Mass(double.NegativeInfinity, MassUnit.Kilogram));
+            Assert.Throws<ArgumentException>(() => new Mass<double>(double.PositiveInfinity, MassUnit.Kilogram));
+            Assert.Throws<ArgumentException>(() => new Mass<double>(double.NegativeInfinity, MassUnit.Kilogram));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Mass(double.NaN, MassUnit.Kilogram));
+            Assert.Throws<ArgumentException>(() => new Mass<double>(double.NaN, MassUnit.Kilogram));
         }
 
         [Fact]
@@ -162,7 +162,7 @@ public void Mass_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void KilogramToMassUnits()
         {
-            Mass kilogram = Mass.FromKilograms(1);
+            Mass<double> kilogram = Mass<double>.FromKilograms(1);
             AssertEx.EqualTolerance(CentigramsInOneKilogram, kilogram.Centigrams, CentigramsTolerance);
             AssertEx.EqualTolerance(DecagramsInOneKilogram, kilogram.Decagrams, DecagramsTolerance);
             AssertEx.EqualTolerance(DecigramsInOneKilogram, kilogram.Decigrams, DecigramsTolerance);
@@ -193,103 +193,103 @@ public void KilogramToMassUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Mass.From(1, MassUnit.Centigram);
+            var quantity00 = Mass<double>.From(1, MassUnit.Centigram);
             AssertEx.EqualTolerance(1, quantity00.Centigrams, CentigramsTolerance);
             Assert.Equal(MassUnit.Centigram, quantity00.Unit);
 
-            var quantity01 = Mass.From(1, MassUnit.Decagram);
+            var quantity01 = Mass<double>.From(1, MassUnit.Decagram);
             AssertEx.EqualTolerance(1, quantity01.Decagrams, DecagramsTolerance);
             Assert.Equal(MassUnit.Decagram, quantity01.Unit);
 
-            var quantity02 = Mass.From(1, MassUnit.Decigram);
+            var quantity02 = Mass<double>.From(1, MassUnit.Decigram);
             AssertEx.EqualTolerance(1, quantity02.Decigrams, DecigramsTolerance);
             Assert.Equal(MassUnit.Decigram, quantity02.Unit);
 
-            var quantity03 = Mass.From(1, MassUnit.EarthMass);
+            var quantity03 = Mass<double>.From(1, MassUnit.EarthMass);
             AssertEx.EqualTolerance(1, quantity03.EarthMasses, EarthMassesTolerance);
             Assert.Equal(MassUnit.EarthMass, quantity03.Unit);
 
-            var quantity04 = Mass.From(1, MassUnit.Grain);
+            var quantity04 = Mass<double>.From(1, MassUnit.Grain);
             AssertEx.EqualTolerance(1, quantity04.Grains, GrainsTolerance);
             Assert.Equal(MassUnit.Grain, quantity04.Unit);
 
-            var quantity05 = Mass.From(1, MassUnit.Gram);
+            var quantity05 = Mass<double>.From(1, MassUnit.Gram);
             AssertEx.EqualTolerance(1, quantity05.Grams, GramsTolerance);
             Assert.Equal(MassUnit.Gram, quantity05.Unit);
 
-            var quantity06 = Mass.From(1, MassUnit.Hectogram);
+            var quantity06 = Mass<double>.From(1, MassUnit.Hectogram);
             AssertEx.EqualTolerance(1, quantity06.Hectograms, HectogramsTolerance);
             Assert.Equal(MassUnit.Hectogram, quantity06.Unit);
 
-            var quantity07 = Mass.From(1, MassUnit.Kilogram);
+            var quantity07 = Mass<double>.From(1, MassUnit.Kilogram);
             AssertEx.EqualTolerance(1, quantity07.Kilograms, KilogramsTolerance);
             Assert.Equal(MassUnit.Kilogram, quantity07.Unit);
 
-            var quantity08 = Mass.From(1, MassUnit.Kilopound);
+            var quantity08 = Mass<double>.From(1, MassUnit.Kilopound);
             AssertEx.EqualTolerance(1, quantity08.Kilopounds, KilopoundsTolerance);
             Assert.Equal(MassUnit.Kilopound, quantity08.Unit);
 
-            var quantity09 = Mass.From(1, MassUnit.Kilotonne);
+            var quantity09 = Mass<double>.From(1, MassUnit.Kilotonne);
             AssertEx.EqualTolerance(1, quantity09.Kilotonnes, KilotonnesTolerance);
             Assert.Equal(MassUnit.Kilotonne, quantity09.Unit);
 
-            var quantity10 = Mass.From(1, MassUnit.LongHundredweight);
+            var quantity10 = Mass<double>.From(1, MassUnit.LongHundredweight);
             AssertEx.EqualTolerance(1, quantity10.LongHundredweight, LongHundredweightTolerance);
             Assert.Equal(MassUnit.LongHundredweight, quantity10.Unit);
 
-            var quantity11 = Mass.From(1, MassUnit.LongTon);
+            var quantity11 = Mass<double>.From(1, MassUnit.LongTon);
             AssertEx.EqualTolerance(1, quantity11.LongTons, LongTonsTolerance);
             Assert.Equal(MassUnit.LongTon, quantity11.Unit);
 
-            var quantity12 = Mass.From(1, MassUnit.Megapound);
+            var quantity12 = Mass<double>.From(1, MassUnit.Megapound);
             AssertEx.EqualTolerance(1, quantity12.Megapounds, MegapoundsTolerance);
             Assert.Equal(MassUnit.Megapound, quantity12.Unit);
 
-            var quantity13 = Mass.From(1, MassUnit.Megatonne);
+            var quantity13 = Mass<double>.From(1, MassUnit.Megatonne);
             AssertEx.EqualTolerance(1, quantity13.Megatonnes, MegatonnesTolerance);
             Assert.Equal(MassUnit.Megatonne, quantity13.Unit);
 
-            var quantity14 = Mass.From(1, MassUnit.Microgram);
+            var quantity14 = Mass<double>.From(1, MassUnit.Microgram);
             AssertEx.EqualTolerance(1, quantity14.Micrograms, MicrogramsTolerance);
             Assert.Equal(MassUnit.Microgram, quantity14.Unit);
 
-            var quantity15 = Mass.From(1, MassUnit.Milligram);
+            var quantity15 = Mass<double>.From(1, MassUnit.Milligram);
             AssertEx.EqualTolerance(1, quantity15.Milligrams, MilligramsTolerance);
             Assert.Equal(MassUnit.Milligram, quantity15.Unit);
 
-            var quantity16 = Mass.From(1, MassUnit.Nanogram);
+            var quantity16 = Mass<double>.From(1, MassUnit.Nanogram);
             AssertEx.EqualTolerance(1, quantity16.Nanograms, NanogramsTolerance);
             Assert.Equal(MassUnit.Nanogram, quantity16.Unit);
 
-            var quantity17 = Mass.From(1, MassUnit.Ounce);
+            var quantity17 = Mass<double>.From(1, MassUnit.Ounce);
             AssertEx.EqualTolerance(1, quantity17.Ounces, OuncesTolerance);
             Assert.Equal(MassUnit.Ounce, quantity17.Unit);
 
-            var quantity18 = Mass.From(1, MassUnit.Pound);
+            var quantity18 = Mass<double>.From(1, MassUnit.Pound);
             AssertEx.EqualTolerance(1, quantity18.Pounds, PoundsTolerance);
             Assert.Equal(MassUnit.Pound, quantity18.Unit);
 
-            var quantity19 = Mass.From(1, MassUnit.ShortHundredweight);
+            var quantity19 = Mass<double>.From(1, MassUnit.ShortHundredweight);
             AssertEx.EqualTolerance(1, quantity19.ShortHundredweight, ShortHundredweightTolerance);
             Assert.Equal(MassUnit.ShortHundredweight, quantity19.Unit);
 
-            var quantity20 = Mass.From(1, MassUnit.ShortTon);
+            var quantity20 = Mass<double>.From(1, MassUnit.ShortTon);
             AssertEx.EqualTolerance(1, quantity20.ShortTons, ShortTonsTolerance);
             Assert.Equal(MassUnit.ShortTon, quantity20.Unit);
 
-            var quantity21 = Mass.From(1, MassUnit.Slug);
+            var quantity21 = Mass<double>.From(1, MassUnit.Slug);
             AssertEx.EqualTolerance(1, quantity21.Slugs, SlugsTolerance);
             Assert.Equal(MassUnit.Slug, quantity21.Unit);
 
-            var quantity22 = Mass.From(1, MassUnit.SolarMass);
+            var quantity22 = Mass<double>.From(1, MassUnit.SolarMass);
             AssertEx.EqualTolerance(1, quantity22.SolarMasses, SolarMassesTolerance);
             Assert.Equal(MassUnit.SolarMass, quantity22.Unit);
 
-            var quantity23 = Mass.From(1, MassUnit.Stone);
+            var quantity23 = Mass<double>.From(1, MassUnit.Stone);
             AssertEx.EqualTolerance(1, quantity23.Stone, StoneTolerance);
             Assert.Equal(MassUnit.Stone, quantity23.Unit);
 
-            var quantity24 = Mass.From(1, MassUnit.Tonne);
+            var quantity24 = Mass<double>.From(1, MassUnit.Tonne);
             AssertEx.EqualTolerance(1, quantity24.Tonnes, TonnesTolerance);
             Assert.Equal(MassUnit.Tonne, quantity24.Unit);
 
@@ -298,20 +298,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilograms_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Mass.FromKilograms(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Mass.FromKilograms(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Mass<double>.FromKilograms(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Mass<double>.FromKilograms(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilograms_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Mass.FromKilograms(double.NaN));
+            Assert.Throws<ArgumentException>(() => Mass<double>.FromKilograms(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogram = Mass.FromKilograms(1);
+            var kilogram = Mass<double>.FromKilograms(1);
             AssertEx.EqualTolerance(CentigramsInOneKilogram, kilogram.As(MassUnit.Centigram), CentigramsTolerance);
             AssertEx.EqualTolerance(DecagramsInOneKilogram, kilogram.As(MassUnit.Decagram), DecagramsTolerance);
             AssertEx.EqualTolerance(DecigramsInOneKilogram, kilogram.As(MassUnit.Decigram), DecigramsTolerance);
@@ -359,7 +359,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogram = Mass.FromKilograms(1);
+            var kilogram = Mass<double>.FromKilograms(1);
 
             var centigramQuantity = kilogram.ToUnit(MassUnit.Centigram);
             AssertEx.EqualTolerance(CentigramsInOneKilogram, (double)centigramQuantity.Value, CentigramsTolerance);
@@ -472,52 +472,52 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Mass kilogram = Mass.FromKilograms(1);
-            AssertEx.EqualTolerance(1, Mass.FromCentigrams(kilogram.Centigrams).Kilograms, CentigramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromDecagrams(kilogram.Decagrams).Kilograms, DecagramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromDecigrams(kilogram.Decigrams).Kilograms, DecigramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromEarthMasses(kilogram.EarthMasses).Kilograms, EarthMassesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromGrains(kilogram.Grains).Kilograms, GrainsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromGrams(kilogram.Grams).Kilograms, GramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromHectograms(kilogram.Hectograms).Kilograms, HectogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromKilograms(kilogram.Kilograms).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromKilopounds(kilogram.Kilopounds).Kilograms, KilopoundsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromKilotonnes(kilogram.Kilotonnes).Kilograms, KilotonnesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromLongHundredweight(kilogram.LongHundredweight).Kilograms, LongHundredweightTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromLongTons(kilogram.LongTons).Kilograms, LongTonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMegapounds(kilogram.Megapounds).Kilograms, MegapoundsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMegatonnes(kilogram.Megatonnes).Kilograms, MegatonnesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMicrograms(kilogram.Micrograms).Kilograms, MicrogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMilligrams(kilogram.Milligrams).Kilograms, MilligramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromNanograms(kilogram.Nanograms).Kilograms, NanogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromOunces(kilogram.Ounces).Kilograms, OuncesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromPounds(kilogram.Pounds).Kilograms, PoundsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromShortHundredweight(kilogram.ShortHundredweight).Kilograms, ShortHundredweightTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromShortTons(kilogram.ShortTons).Kilograms, ShortTonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromSlugs(kilogram.Slugs).Kilograms, SlugsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromSolarMasses(kilogram.SolarMasses).Kilograms, SolarMassesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromStone(kilogram.Stone).Kilograms, StoneTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromTonnes(kilogram.Tonnes).Kilograms, TonnesTolerance);
+            Mass<double> kilogram = Mass<double>.FromKilograms(1);
+            AssertEx.EqualTolerance(1, Mass<double>.FromCentigrams(kilogram.Centigrams).Kilograms, CentigramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromDecagrams(kilogram.Decagrams).Kilograms, DecagramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromDecigrams(kilogram.Decigrams).Kilograms, DecigramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromEarthMasses(kilogram.EarthMasses).Kilograms, EarthMassesTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromGrains(kilogram.Grains).Kilograms, GrainsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromGrams(kilogram.Grams).Kilograms, GramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromHectograms(kilogram.Hectograms).Kilograms, HectogramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromKilograms(kilogram.Kilograms).Kilograms, KilogramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromKilopounds(kilogram.Kilopounds).Kilograms, KilopoundsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromKilotonnes(kilogram.Kilotonnes).Kilograms, KilotonnesTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromLongHundredweight(kilogram.LongHundredweight).Kilograms, LongHundredweightTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromLongTons(kilogram.LongTons).Kilograms, LongTonsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromMegapounds(kilogram.Megapounds).Kilograms, MegapoundsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromMegatonnes(kilogram.Megatonnes).Kilograms, MegatonnesTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromMicrograms(kilogram.Micrograms).Kilograms, MicrogramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromMilligrams(kilogram.Milligrams).Kilograms, MilligramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromNanograms(kilogram.Nanograms).Kilograms, NanogramsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromOunces(kilogram.Ounces).Kilograms, OuncesTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromPounds(kilogram.Pounds).Kilograms, PoundsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromShortHundredweight(kilogram.ShortHundredweight).Kilograms, ShortHundredweightTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromShortTons(kilogram.ShortTons).Kilograms, ShortTonsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromSlugs(kilogram.Slugs).Kilograms, SlugsTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromSolarMasses(kilogram.SolarMasses).Kilograms, SolarMassesTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromStone(kilogram.Stone).Kilograms, StoneTolerance);
+            AssertEx.EqualTolerance(1, Mass<double>.FromTonnes(kilogram.Tonnes).Kilograms, TonnesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Mass v = Mass.FromKilograms(1);
+            Mass<double> v = Mass<double>.FromKilograms(1);
             AssertEx.EqualTolerance(-1, -v.Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(2, (Mass.FromKilograms(3)-v).Kilograms, KilogramsTolerance);
+            AssertEx.EqualTolerance(2, (Mass<double>.FromKilograms(3)-v).Kilograms, KilogramsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Kilograms, KilogramsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Kilograms, KilogramsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(2, (Mass.FromKilograms(10)/5).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(2, Mass.FromKilograms(10)/Mass.FromKilograms(5), KilogramsTolerance);
+            AssertEx.EqualTolerance(2, (Mass<double>.FromKilograms(10)/5).Kilograms, KilogramsTolerance);
+            AssertEx.EqualTolerance(2, Mass<double>.FromKilograms(10)/Mass<double>.FromKilograms(5), KilogramsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Mass oneKilogram = Mass.FromKilograms(1);
-            Mass twoKilograms = Mass.FromKilograms(2);
+            Mass<double> oneKilogram = Mass<double>.FromKilograms(1);
+            Mass<double> twoKilograms = Mass<double>.FromKilograms(2);
 
             Assert.True(oneKilogram < twoKilograms);
             Assert.True(oneKilogram <= twoKilograms);
@@ -533,31 +533,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Mass kilogram = Mass.FromKilograms(1);
+            Mass<double> kilogram = Mass<double>.FromKilograms(1);
             Assert.Equal(0, kilogram.CompareTo(kilogram));
-            Assert.True(kilogram.CompareTo(Mass.Zero) > 0);
-            Assert.True(Mass.Zero.CompareTo(kilogram) < 0);
+            Assert.True(kilogram.CompareTo(Mass<double>.Zero) > 0);
+            Assert.True(Mass<double>.Zero.CompareTo(kilogram) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Mass kilogram = Mass.FromKilograms(1);
+            Mass<double> kilogram = Mass<double>.FromKilograms(1);
             Assert.Throws<ArgumentException>(() => kilogram.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Mass kilogram = Mass.FromKilograms(1);
+            Mass<double> kilogram = Mass<double>.FromKilograms(1);
             Assert.Throws<ArgumentNullException>(() => kilogram.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Mass.FromKilograms(1);
-            var b = Mass.FromKilograms(2);
+            var a = Mass<double>.FromKilograms(1);
+            var b = Mass<double>.FromKilograms(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -576,8 +576,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Mass.FromKilograms(1);
-            var b = Mass.FromKilograms(2);
+            var a = Mass<double>.FromKilograms(1);
+            var b = Mass<double>.FromKilograms(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -597,9 +597,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Mass.FromKilograms(1);
-            Assert.True(v.Equals(Mass.FromKilograms(1), KilogramsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Mass.Zero, KilogramsTolerance, ComparisonType.Relative));
+            var v = Mass<double>.FromKilograms(1);
+            Assert.True(v.Equals(Mass<double>.FromKilograms(1), KilogramsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Mass<double>.Zero, KilogramsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -612,21 +612,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Mass kilogram = Mass.FromKilograms(1);
+            Mass<double> kilogram = Mass<double>.FromKilograms(1);
             Assert.False(kilogram.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Mass kilogram = Mass.FromKilograms(1);
+            Mass<double> kilogram = Mass<double>.FromKilograms(1);
             Assert.False(kilogram.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MassUnit.Undefined, Mass.Units);
+            Assert.DoesNotContain(MassUnit.Undefined, Mass<double>.Units);
         }
 
         [Fact]
@@ -645,7 +645,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Mass.BaseDimensions is null);
+            Assert.False(Mass<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs
index 3130b4b64f..17eb5c51f1 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class MolarEnergyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarEnergy((double)0.0, MolarEnergyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>((double)0.0, MolarEnergyUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarEnergy(double.PositiveInfinity, MolarEnergyUnit.JoulePerMole));
-            Assert.Throws<ArgumentException>(() => new MolarEnergy(double.NegativeInfinity, MolarEnergyUnit.JoulePerMole));
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>(double.PositiveInfinity, MolarEnergyUnit.JoulePerMole));
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>(double.NegativeInfinity, MolarEnergyUnit.JoulePerMole));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarEnergy(double.NaN, MolarEnergyUnit.JoulePerMole));
+            Assert.Throws<ArgumentException>(() => new MolarEnergy<double>(double.NaN, MolarEnergyUnit.JoulePerMole));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void MolarEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void JoulePerMoleToMolarEnergyUnits()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
             AssertEx.EqualTolerance(JoulesPerMoleInOneJoulePerMole, joulepermole.JoulesPerMole, JoulesPerMoleTolerance);
             AssertEx.EqualTolerance(KilojoulesPerMoleInOneJoulePerMole, joulepermole.KilojoulesPerMole, KilojoulesPerMoleTolerance);
             AssertEx.EqualTolerance(MegajoulesPerMoleInOneJoulePerMole, joulepermole.MegajoulesPerMole, MegajoulesPerMoleTolerance);
@@ -127,15 +127,15 @@ public void JoulePerMoleToMolarEnergyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MolarEnergy.From(1, MolarEnergyUnit.JoulePerMole);
+            var quantity00 = MolarEnergy<double>.From(1, MolarEnergyUnit.JoulePerMole);
             AssertEx.EqualTolerance(1, quantity00.JoulesPerMole, JoulesPerMoleTolerance);
             Assert.Equal(MolarEnergyUnit.JoulePerMole, quantity00.Unit);
 
-            var quantity01 = MolarEnergy.From(1, MolarEnergyUnit.KilojoulePerMole);
+            var quantity01 = MolarEnergy<double>.From(1, MolarEnergyUnit.KilojoulePerMole);
             AssertEx.EqualTolerance(1, quantity01.KilojoulesPerMole, KilojoulesPerMoleTolerance);
             Assert.Equal(MolarEnergyUnit.KilojoulePerMole, quantity01.Unit);
 
-            var quantity02 = MolarEnergy.From(1, MolarEnergyUnit.MegajoulePerMole);
+            var quantity02 = MolarEnergy<double>.From(1, MolarEnergyUnit.MegajoulePerMole);
             AssertEx.EqualTolerance(1, quantity02.MegajoulesPerMole, MegajoulesPerMoleTolerance);
             Assert.Equal(MolarEnergyUnit.MegajoulePerMole, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromJoulesPerMole_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MolarEnergy.FromJoulesPerMole(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MolarEnergy.FromJoulesPerMole(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MolarEnergy<double>.FromJoulesPerMole(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MolarEnergy<double>.FromJoulesPerMole(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromJoulesPerMole_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MolarEnergy.FromJoulesPerMole(double.NaN));
+            Assert.Throws<ArgumentException>(() => MolarEnergy<double>.FromJoulesPerMole(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            var joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
             AssertEx.EqualTolerance(JoulesPerMoleInOneJoulePerMole, joulepermole.As(MolarEnergyUnit.JoulePerMole), JoulesPerMoleTolerance);
             AssertEx.EqualTolerance(KilojoulesPerMoleInOneJoulePerMole, joulepermole.As(MolarEnergyUnit.KilojoulePerMole), KilojoulesPerMoleTolerance);
             AssertEx.EqualTolerance(MegajoulesPerMoleInOneJoulePerMole, joulepermole.As(MolarEnergyUnit.MegajoulePerMole), MegajoulesPerMoleTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            var joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
 
             var joulepermoleQuantity = joulepermole.ToUnit(MolarEnergyUnit.JoulePerMole);
             AssertEx.EqualTolerance(JoulesPerMoleInOneJoulePerMole, (double)joulepermoleQuantity.Value, JoulesPerMoleTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
-            AssertEx.EqualTolerance(1, MolarEnergy.FromJoulesPerMole(joulepermole.JoulesPerMole).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarEnergy.FromKilojoulesPerMole(joulepermole.KilojoulesPerMole).JoulesPerMole, KilojoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarEnergy.FromMegajoulesPerMole(joulepermole.MegajoulesPerMole).JoulesPerMole, MegajoulesPerMoleTolerance);
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.FromJoulesPerMole(joulepermole.JoulesPerMole).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.FromKilojoulesPerMole(joulepermole.KilojoulesPerMole).JoulesPerMole, KilojoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarEnergy<double>.FromMegajoulesPerMole(joulepermole.MegajoulesPerMole).JoulesPerMole, MegajoulesPerMoleTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MolarEnergy v = MolarEnergy.FromJoulesPerMole(1);
+            MolarEnergy<double> v = MolarEnergy<double>.FromJoulesPerMole(1);
             AssertEx.EqualTolerance(-1, -v.JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarEnergy.FromJoulesPerMole(3)-v).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(2, (MolarEnergy<double>.FromJoulesPerMole(3)-v).JoulesPerMole, JoulesPerMoleTolerance);
             AssertEx.EqualTolerance(2, (v + v).JoulesPerMole, JoulesPerMoleTolerance);
             AssertEx.EqualTolerance(10, (v*10).JoulesPerMole, JoulesPerMoleTolerance);
             AssertEx.EqualTolerance(10, (10*v).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarEnergy.FromJoulesPerMole(10)/5).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(2, MolarEnergy.FromJoulesPerMole(10)/MolarEnergy.FromJoulesPerMole(5), JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(2, (MolarEnergy<double>.FromJoulesPerMole(10)/5).JoulesPerMole, JoulesPerMoleTolerance);
+            AssertEx.EqualTolerance(2, MolarEnergy<double>.FromJoulesPerMole(10)/MolarEnergy<double>.FromJoulesPerMole(5), JoulesPerMoleTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MolarEnergy oneJoulePerMole = MolarEnergy.FromJoulesPerMole(1);
-            MolarEnergy twoJoulesPerMole = MolarEnergy.FromJoulesPerMole(2);
+            MolarEnergy<double> oneJoulePerMole = MolarEnergy<double>.FromJoulesPerMole(1);
+            MolarEnergy<double> twoJoulesPerMole = MolarEnergy<double>.FromJoulesPerMole(2);
 
             Assert.True(oneJoulePerMole < twoJoulesPerMole);
             Assert.True(oneJoulePerMole <= twoJoulesPerMole);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
             Assert.Equal(0, joulepermole.CompareTo(joulepermole));
-            Assert.True(joulepermole.CompareTo(MolarEnergy.Zero) > 0);
-            Assert.True(MolarEnergy.Zero.CompareTo(joulepermole) < 0);
+            Assert.True(joulepermole.CompareTo(MolarEnergy<double>.Zero) > 0);
+            Assert.True(MolarEnergy<double>.Zero.CompareTo(joulepermole) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
             Assert.Throws<ArgumentException>(() => joulepermole.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
             Assert.Throws<ArgumentNullException>(() => joulepermole.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MolarEnergy.FromJoulesPerMole(1);
-            var b = MolarEnergy.FromJoulesPerMole(2);
+            var a = MolarEnergy<double>.FromJoulesPerMole(1);
+            var b = MolarEnergy<double>.FromJoulesPerMole(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MolarEnergy.FromJoulesPerMole(1);
-            var b = MolarEnergy.FromJoulesPerMole(2);
+            var a = MolarEnergy<double>.FromJoulesPerMole(1);
+            var b = MolarEnergy<double>.FromJoulesPerMole(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MolarEnergy.FromJoulesPerMole(1);
-            Assert.True(v.Equals(MolarEnergy.FromJoulesPerMole(1), JoulesPerMoleTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MolarEnergy.Zero, JoulesPerMoleTolerance, ComparisonType.Relative));
+            var v = MolarEnergy<double>.FromJoulesPerMole(1);
+            Assert.True(v.Equals(MolarEnergy<double>.FromJoulesPerMole(1), JoulesPerMoleTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MolarEnergy<double>.Zero, JoulesPerMoleTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
             Assert.False(joulepermole.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
+            MolarEnergy<double> joulepermole = MolarEnergy<double>.FromJoulesPerMole(1);
             Assert.False(joulepermole.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MolarEnergyUnit.Undefined, MolarEnergy.Units);
+            Assert.DoesNotContain(MolarEnergyUnit.Undefined, MolarEnergy<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MolarEnergy.BaseDimensions is null);
+            Assert.False(MolarEnergy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs
index c0d260dd18..52a750df57 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class MolarEntropyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarEntropy((double)0.0, MolarEntropyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>((double)0.0, MolarEntropyUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarEntropy(double.PositiveInfinity, MolarEntropyUnit.JoulePerMoleKelvin));
-            Assert.Throws<ArgumentException>(() => new MolarEntropy(double.NegativeInfinity, MolarEntropyUnit.JoulePerMoleKelvin));
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>(double.PositiveInfinity, MolarEntropyUnit.JoulePerMoleKelvin));
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>(double.NegativeInfinity, MolarEntropyUnit.JoulePerMoleKelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarEntropy(double.NaN, MolarEntropyUnit.JoulePerMoleKelvin));
+            Assert.Throws<ArgumentException>(() => new MolarEntropy<double>(double.NaN, MolarEntropyUnit.JoulePerMoleKelvin));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void MolarEntropy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void JoulePerMoleKelvinToMolarEntropyUnits()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             AssertEx.EqualTolerance(JoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
             AssertEx.EqualTolerance(KilojoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.KilojoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
             AssertEx.EqualTolerance(MegajoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.MegajoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
@@ -127,15 +127,15 @@ public void JoulePerMoleKelvinToMolarEntropyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MolarEntropy.From(1, MolarEntropyUnit.JoulePerMoleKelvin);
+            var quantity00 = MolarEntropy<double>.From(1, MolarEntropyUnit.JoulePerMoleKelvin);
             AssertEx.EqualTolerance(1, quantity00.JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
             Assert.Equal(MolarEntropyUnit.JoulePerMoleKelvin, quantity00.Unit);
 
-            var quantity01 = MolarEntropy.From(1, MolarEntropyUnit.KilojoulePerMoleKelvin);
+            var quantity01 = MolarEntropy<double>.From(1, MolarEntropyUnit.KilojoulePerMoleKelvin);
             AssertEx.EqualTolerance(1, quantity01.KilojoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
             Assert.Equal(MolarEntropyUnit.KilojoulePerMoleKelvin, quantity01.Unit);
 
-            var quantity02 = MolarEntropy.From(1, MolarEntropyUnit.MegajoulePerMoleKelvin);
+            var quantity02 = MolarEntropy<double>.From(1, MolarEntropyUnit.MegajoulePerMoleKelvin);
             AssertEx.EqualTolerance(1, quantity02.MegajoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
             Assert.Equal(MolarEntropyUnit.MegajoulePerMoleKelvin, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromJoulesPerMoleKelvin_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MolarEntropy.FromJoulesPerMoleKelvin(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MolarEntropy.FromJoulesPerMoleKelvin(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MolarEntropy<double>.FromJoulesPerMoleKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MolarEntropy<double>.FromJoulesPerMoleKelvin(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromJoulesPerMoleKelvin_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MolarEntropy.FromJoulesPerMoleKelvin(double.NaN));
+            Assert.Throws<ArgumentException>(() => MolarEntropy<double>.FromJoulesPerMoleKelvin(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            var joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             AssertEx.EqualTolerance(JoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.As(MolarEntropyUnit.JoulePerMoleKelvin), JoulesPerMoleKelvinTolerance);
             AssertEx.EqualTolerance(KilojoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.As(MolarEntropyUnit.KilojoulePerMoleKelvin), KilojoulesPerMoleKelvinTolerance);
             AssertEx.EqualTolerance(MegajoulesPerMoleKelvinInOneJoulePerMoleKelvin, joulepermolekelvin.As(MolarEntropyUnit.MegajoulePerMoleKelvin), MegajoulesPerMoleKelvinTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            var joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
 
             var joulepermolekelvinQuantity = joulepermolekelvin.ToUnit(MolarEntropyUnit.JoulePerMoleKelvin);
             AssertEx.EqualTolerance(JoulesPerMoleKelvinInOneJoulePerMoleKelvin, (double)joulepermolekelvinQuantity.Value, JoulesPerMoleKelvinTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            AssertEx.EqualTolerance(1, MolarEntropy.FromJoulesPerMoleKelvin(joulepermolekelvin.JoulesPerMoleKelvin).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(1, MolarEntropy.FromKilojoulesPerMoleKelvin(joulepermolekelvin.KilojoulesPerMoleKelvin).JoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(1, MolarEntropy.FromMegajoulesPerMoleKelvin(joulepermolekelvin.MegajoulesPerMoleKelvin).JoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.FromJoulesPerMoleKelvin(joulepermolekelvin.JoulesPerMoleKelvin).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.FromKilojoulesPerMoleKelvin(joulepermolekelvin.KilojoulesPerMoleKelvin).JoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(1, MolarEntropy<double>.FromMegajoulesPerMoleKelvin(joulepermolekelvin.MegajoulesPerMoleKelvin).JoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MolarEntropy v = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> v = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             AssertEx.EqualTolerance(-1, -v.JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(2, (MolarEntropy.FromJoulesPerMoleKelvin(3)-v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(2, (MolarEntropy<double>.FromJoulesPerMoleKelvin(3)-v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
             AssertEx.EqualTolerance(2, (v + v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
             AssertEx.EqualTolerance(10, (v*10).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
             AssertEx.EqualTolerance(10, (10*v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(2, (MolarEntropy.FromJoulesPerMoleKelvin(10)/5).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(2, MolarEntropy.FromJoulesPerMoleKelvin(10)/MolarEntropy.FromJoulesPerMoleKelvin(5), JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(2, (MolarEntropy<double>.FromJoulesPerMoleKelvin(10)/5).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
+            AssertEx.EqualTolerance(2, MolarEntropy<double>.FromJoulesPerMoleKelvin(10)/MolarEntropy<double>.FromJoulesPerMoleKelvin(5), JoulesPerMoleKelvinTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MolarEntropy oneJoulePerMoleKelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            MolarEntropy twoJoulesPerMoleKelvin = MolarEntropy.FromJoulesPerMoleKelvin(2);
+            MolarEntropy<double> oneJoulePerMoleKelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> twoJoulesPerMoleKelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(2);
 
             Assert.True(oneJoulePerMoleKelvin < twoJoulesPerMoleKelvin);
             Assert.True(oneJoulePerMoleKelvin <= twoJoulesPerMoleKelvin);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             Assert.Equal(0, joulepermolekelvin.CompareTo(joulepermolekelvin));
-            Assert.True(joulepermolekelvin.CompareTo(MolarEntropy.Zero) > 0);
-            Assert.True(MolarEntropy.Zero.CompareTo(joulepermolekelvin) < 0);
+            Assert.True(joulepermolekelvin.CompareTo(MolarEntropy<double>.Zero) > 0);
+            Assert.True(MolarEntropy<double>.Zero.CompareTo(joulepermolekelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             Assert.Throws<ArgumentException>(() => joulepermolekelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             Assert.Throws<ArgumentNullException>(() => joulepermolekelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            var b = MolarEntropy.FromJoulesPerMoleKelvin(2);
+            var a = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            var b = MolarEntropy<double>.FromJoulesPerMoleKelvin(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            var b = MolarEntropy.FromJoulesPerMoleKelvin(2);
+            var a = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            var b = MolarEntropy<double>.FromJoulesPerMoleKelvin(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            Assert.True(v.Equals(MolarEntropy.FromJoulesPerMoleKelvin(1), JoulesPerMoleKelvinTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MolarEntropy.Zero, JoulesPerMoleKelvinTolerance, ComparisonType.Relative));
+            var v = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
+            Assert.True(v.Equals(MolarEntropy<double>.FromJoulesPerMoleKelvin(1), JoulesPerMoleKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MolarEntropy<double>.Zero, JoulesPerMoleKelvinTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             Assert.False(joulepermolekelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
+            MolarEntropy<double> joulepermolekelvin = MolarEntropy<double>.FromJoulesPerMoleKelvin(1);
             Assert.False(joulepermolekelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MolarEntropyUnit.Undefined, MolarEntropy.Units);
+            Assert.DoesNotContain(MolarEntropyUnit.Undefined, MolarEntropy<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MolarEntropy.BaseDimensions is null);
+            Assert.False(MolarEntropy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs
index 69f50b23f5..bb6a57686d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs
@@ -68,7 +68,7 @@ public abstract partial class MolarMassTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarMass((double)0.0, MolarMassUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new MolarMass<double>((double)0.0, MolarMassUnit.Undefined));
         }
 
         [Fact]
@@ -83,14 +83,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarMass(double.PositiveInfinity, MolarMassUnit.KilogramPerMole));
-            Assert.Throws<ArgumentException>(() => new MolarMass(double.NegativeInfinity, MolarMassUnit.KilogramPerMole));
+            Assert.Throws<ArgumentException>(() => new MolarMass<double>(double.PositiveInfinity, MolarMassUnit.KilogramPerMole));
+            Assert.Throws<ArgumentException>(() => new MolarMass<double>(double.NegativeInfinity, MolarMassUnit.KilogramPerMole));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new MolarMass(double.NaN, MolarMassUnit.KilogramPerMole));
+            Assert.Throws<ArgumentException>(() => new MolarMass<double>(double.NaN, MolarMassUnit.KilogramPerMole));
         }
 
         [Fact]
@@ -136,7 +136,7 @@ public void MolarMass_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void KilogramPerMoleToMolarMassUnits()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            MolarMass<double> kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
             AssertEx.EqualTolerance(CentigramsPerMoleInOneKilogramPerMole, kilogrampermole.CentigramsPerMole, CentigramsPerMoleTolerance);
             AssertEx.EqualTolerance(DecagramsPerMoleInOneKilogramPerMole, kilogrampermole.DecagramsPerMole, DecagramsPerMoleTolerance);
             AssertEx.EqualTolerance(DecigramsPerMoleInOneKilogramPerMole, kilogrampermole.DecigramsPerMole, DecigramsPerMoleTolerance);
@@ -154,51 +154,51 @@ public void KilogramPerMoleToMolarMassUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = MolarMass.From(1, MolarMassUnit.CentigramPerMole);
+            var quantity00 = MolarMass<double>.From(1, MolarMassUnit.CentigramPerMole);
             AssertEx.EqualTolerance(1, quantity00.CentigramsPerMole, CentigramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.CentigramPerMole, quantity00.Unit);
 
-            var quantity01 = MolarMass.From(1, MolarMassUnit.DecagramPerMole);
+            var quantity01 = MolarMass<double>.From(1, MolarMassUnit.DecagramPerMole);
             AssertEx.EqualTolerance(1, quantity01.DecagramsPerMole, DecagramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.DecagramPerMole, quantity01.Unit);
 
-            var quantity02 = MolarMass.From(1, MolarMassUnit.DecigramPerMole);
+            var quantity02 = MolarMass<double>.From(1, MolarMassUnit.DecigramPerMole);
             AssertEx.EqualTolerance(1, quantity02.DecigramsPerMole, DecigramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.DecigramPerMole, quantity02.Unit);
 
-            var quantity03 = MolarMass.From(1, MolarMassUnit.GramPerMole);
+            var quantity03 = MolarMass<double>.From(1, MolarMassUnit.GramPerMole);
             AssertEx.EqualTolerance(1, quantity03.GramsPerMole, GramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.GramPerMole, quantity03.Unit);
 
-            var quantity04 = MolarMass.From(1, MolarMassUnit.HectogramPerMole);
+            var quantity04 = MolarMass<double>.From(1, MolarMassUnit.HectogramPerMole);
             AssertEx.EqualTolerance(1, quantity04.HectogramsPerMole, HectogramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.HectogramPerMole, quantity04.Unit);
 
-            var quantity05 = MolarMass.From(1, MolarMassUnit.KilogramPerMole);
+            var quantity05 = MolarMass<double>.From(1, MolarMassUnit.KilogramPerMole);
             AssertEx.EqualTolerance(1, quantity05.KilogramsPerMole, KilogramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.KilogramPerMole, quantity05.Unit);
 
-            var quantity06 = MolarMass.From(1, MolarMassUnit.KilopoundPerMole);
+            var quantity06 = MolarMass<double>.From(1, MolarMassUnit.KilopoundPerMole);
             AssertEx.EqualTolerance(1, quantity06.KilopoundsPerMole, KilopoundsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.KilopoundPerMole, quantity06.Unit);
 
-            var quantity07 = MolarMass.From(1, MolarMassUnit.MegapoundPerMole);
+            var quantity07 = MolarMass<double>.From(1, MolarMassUnit.MegapoundPerMole);
             AssertEx.EqualTolerance(1, quantity07.MegapoundsPerMole, MegapoundsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.MegapoundPerMole, quantity07.Unit);
 
-            var quantity08 = MolarMass.From(1, MolarMassUnit.MicrogramPerMole);
+            var quantity08 = MolarMass<double>.From(1, MolarMassUnit.MicrogramPerMole);
             AssertEx.EqualTolerance(1, quantity08.MicrogramsPerMole, MicrogramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.MicrogramPerMole, quantity08.Unit);
 
-            var quantity09 = MolarMass.From(1, MolarMassUnit.MilligramPerMole);
+            var quantity09 = MolarMass<double>.From(1, MolarMassUnit.MilligramPerMole);
             AssertEx.EqualTolerance(1, quantity09.MilligramsPerMole, MilligramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.MilligramPerMole, quantity09.Unit);
 
-            var quantity10 = MolarMass.From(1, MolarMassUnit.NanogramPerMole);
+            var quantity10 = MolarMass<double>.From(1, MolarMassUnit.NanogramPerMole);
             AssertEx.EqualTolerance(1, quantity10.NanogramsPerMole, NanogramsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.NanogramPerMole, quantity10.Unit);
 
-            var quantity11 = MolarMass.From(1, MolarMassUnit.PoundPerMole);
+            var quantity11 = MolarMass<double>.From(1, MolarMassUnit.PoundPerMole);
             AssertEx.EqualTolerance(1, quantity11.PoundsPerMole, PoundsPerMoleTolerance);
             Assert.Equal(MolarMassUnit.PoundPerMole, quantity11.Unit);
 
@@ -207,20 +207,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKilogramsPerMole_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MolarMass.FromKilogramsPerMole(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => MolarMass.FromKilogramsPerMole(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => MolarMass<double>.FromKilogramsPerMole(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => MolarMass<double>.FromKilogramsPerMole(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKilogramsPerMole_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => MolarMass.FromKilogramsPerMole(double.NaN));
+            Assert.Throws<ArgumentException>(() => MolarMass<double>.FromKilogramsPerMole(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            var kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
             AssertEx.EqualTolerance(CentigramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.CentigramPerMole), CentigramsPerMoleTolerance);
             AssertEx.EqualTolerance(DecagramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecagramPerMole), DecagramsPerMoleTolerance);
             AssertEx.EqualTolerance(DecigramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecigramPerMole), DecigramsPerMoleTolerance);
@@ -255,7 +255,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            var kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
 
             var centigrampermoleQuantity = kilogrampermole.ToUnit(MolarMassUnit.CentigramPerMole);
             AssertEx.EqualTolerance(CentigramsPerMoleInOneKilogramPerMole, (double)centigrampermoleQuantity.Value, CentigramsPerMoleTolerance);
@@ -316,39 +316,39 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
-            AssertEx.EqualTolerance(1, MolarMass.FromCentigramsPerMole(kilogrampermole.CentigramsPerMole).KilogramsPerMole, CentigramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromDecagramsPerMole(kilogrampermole.DecagramsPerMole).KilogramsPerMole, DecagramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromDecigramsPerMole(kilogrampermole.DecigramsPerMole).KilogramsPerMole, DecigramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromGramsPerMole(kilogrampermole.GramsPerMole).KilogramsPerMole, GramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromHectogramsPerMole(kilogrampermole.HectogramsPerMole).KilogramsPerMole, HectogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromKilogramsPerMole(kilogrampermole.KilogramsPerMole).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromKilopoundsPerMole(kilogrampermole.KilopoundsPerMole).KilogramsPerMole, KilopoundsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromMegapoundsPerMole(kilogrampermole.MegapoundsPerMole).KilogramsPerMole, MegapoundsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromMicrogramsPerMole(kilogrampermole.MicrogramsPerMole).KilogramsPerMole, MicrogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromMilligramsPerMole(kilogrampermole.MilligramsPerMole).KilogramsPerMole, MilligramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromNanogramsPerMole(kilogrampermole.NanogramsPerMole).KilogramsPerMole, NanogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromPoundsPerMole(kilogrampermole.PoundsPerMole).KilogramsPerMole, PoundsPerMoleTolerance);
+            MolarMass<double> kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromCentigramsPerMole(kilogrampermole.CentigramsPerMole).KilogramsPerMole, CentigramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromDecagramsPerMole(kilogrampermole.DecagramsPerMole).KilogramsPerMole, DecagramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromDecigramsPerMole(kilogrampermole.DecigramsPerMole).KilogramsPerMole, DecigramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromGramsPerMole(kilogrampermole.GramsPerMole).KilogramsPerMole, GramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromHectogramsPerMole(kilogrampermole.HectogramsPerMole).KilogramsPerMole, HectogramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromKilogramsPerMole(kilogrampermole.KilogramsPerMole).KilogramsPerMole, KilogramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromKilopoundsPerMole(kilogrampermole.KilopoundsPerMole).KilogramsPerMole, KilopoundsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromMegapoundsPerMole(kilogrampermole.MegapoundsPerMole).KilogramsPerMole, MegapoundsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromMicrogramsPerMole(kilogrampermole.MicrogramsPerMole).KilogramsPerMole, MicrogramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromMilligramsPerMole(kilogrampermole.MilligramsPerMole).KilogramsPerMole, MilligramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromNanogramsPerMole(kilogrampermole.NanogramsPerMole).KilogramsPerMole, NanogramsPerMoleTolerance);
+            AssertEx.EqualTolerance(1, MolarMass<double>.FromPoundsPerMole(kilogrampermole.PoundsPerMole).KilogramsPerMole, PoundsPerMoleTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            MolarMass v = MolarMass.FromKilogramsPerMole(1);
+            MolarMass<double> v = MolarMass<double>.FromKilogramsPerMole(1);
             AssertEx.EqualTolerance(-1, -v.KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMole(3)-v).KilogramsPerMole, KilogramsPerMoleTolerance);
+            AssertEx.EqualTolerance(2, (MolarMass<double>.FromKilogramsPerMole(3)-v).KilogramsPerMole, KilogramsPerMoleTolerance);
             AssertEx.EqualTolerance(2, (v + v).KilogramsPerMole, KilogramsPerMoleTolerance);
             AssertEx.EqualTolerance(10, (v*10).KilogramsPerMole, KilogramsPerMoleTolerance);
             AssertEx.EqualTolerance(10, (10*v).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMole(10)/5).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(2, MolarMass.FromKilogramsPerMole(10)/MolarMass.FromKilogramsPerMole(5), KilogramsPerMoleTolerance);
+            AssertEx.EqualTolerance(2, (MolarMass<double>.FromKilogramsPerMole(10)/5).KilogramsPerMole, KilogramsPerMoleTolerance);
+            AssertEx.EqualTolerance(2, MolarMass<double>.FromKilogramsPerMole(10)/MolarMass<double>.FromKilogramsPerMole(5), KilogramsPerMoleTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            MolarMass oneKilogramPerMole = MolarMass.FromKilogramsPerMole(1);
-            MolarMass twoKilogramsPerMole = MolarMass.FromKilogramsPerMole(2);
+            MolarMass<double> oneKilogramPerMole = MolarMass<double>.FromKilogramsPerMole(1);
+            MolarMass<double> twoKilogramsPerMole = MolarMass<double>.FromKilogramsPerMole(2);
 
             Assert.True(oneKilogramPerMole < twoKilogramsPerMole);
             Assert.True(oneKilogramPerMole <= twoKilogramsPerMole);
@@ -364,31 +364,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            MolarMass<double> kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
             Assert.Equal(0, kilogrampermole.CompareTo(kilogrampermole));
-            Assert.True(kilogrampermole.CompareTo(MolarMass.Zero) > 0);
-            Assert.True(MolarMass.Zero.CompareTo(kilogrampermole) < 0);
+            Assert.True(kilogrampermole.CompareTo(MolarMass<double>.Zero) > 0);
+            Assert.True(MolarMass<double>.Zero.CompareTo(kilogrampermole) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            MolarMass<double> kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
             Assert.Throws<ArgumentException>(() => kilogrampermole.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            MolarMass<double> kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
             Assert.Throws<ArgumentNullException>(() => kilogrampermole.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = MolarMass.FromKilogramsPerMole(1);
-            var b = MolarMass.FromKilogramsPerMole(2);
+            var a = MolarMass<double>.FromKilogramsPerMole(1);
+            var b = MolarMass<double>.FromKilogramsPerMole(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -407,8 +407,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = MolarMass.FromKilogramsPerMole(1);
-            var b = MolarMass.FromKilogramsPerMole(2);
+            var a = MolarMass<double>.FromKilogramsPerMole(1);
+            var b = MolarMass<double>.FromKilogramsPerMole(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -428,9 +428,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = MolarMass.FromKilogramsPerMole(1);
-            Assert.True(v.Equals(MolarMass.FromKilogramsPerMole(1), KilogramsPerMoleTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(MolarMass.Zero, KilogramsPerMoleTolerance, ComparisonType.Relative));
+            var v = MolarMass<double>.FromKilogramsPerMole(1);
+            Assert.True(v.Equals(MolarMass<double>.FromKilogramsPerMole(1), KilogramsPerMoleTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(MolarMass<double>.Zero, KilogramsPerMoleTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -443,21 +443,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            MolarMass<double> kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
             Assert.False(kilogrampermole.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
+            MolarMass<double> kilogrampermole = MolarMass<double>.FromKilogramsPerMole(1);
             Assert.False(kilogrampermole.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MolarMassUnit.Undefined, MolarMass.Units);
+            Assert.DoesNotContain(MolarMassUnit.Undefined, MolarMass<double>.Units);
         }
 
         [Fact]
@@ -476,7 +476,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(MolarMass.BaseDimensions is null);
+            Assert.False(MolarMass<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs
index 38096bde5c..74c832430e 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs
@@ -60,7 +60,7 @@ public abstract partial class MolarityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Molarity((double)0.0, MolarityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Molarity<double>((double)0.0, MolarityUnit.Undefined));
         }
 
         [Fact]
@@ -75,14 +75,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Molarity(double.PositiveInfinity, MolarityUnit.MolesPerCubicMeter));
-            Assert.Throws<ArgumentException>(() => new Molarity(double.NegativeInfinity, MolarityUnit.MolesPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new Molarity<double>(double.PositiveInfinity, MolarityUnit.MolesPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new Molarity<double>(double.NegativeInfinity, MolarityUnit.MolesPerCubicMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Molarity(double.NaN, MolarityUnit.MolesPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new Molarity<double>(double.NaN, MolarityUnit.MolesPerCubicMeter));
         }
 
         [Fact]
@@ -128,7 +128,7 @@ public void Molarity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void MolesPerCubicMeterToMolarityUnits()
         {
-            Molarity molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
             AssertEx.EqualTolerance(CentimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.CentimolesPerLiter, CentimolesPerLiterTolerance);
             AssertEx.EqualTolerance(DecimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.DecimolesPerLiter, DecimolesPerLiterTolerance);
             AssertEx.EqualTolerance(MicromolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.MicromolesPerLiter, MicromolesPerLiterTolerance);
@@ -142,35 +142,35 @@ public void MolesPerCubicMeterToMolarityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Molarity.From(1, MolarityUnit.CentimolesPerLiter);
+            var quantity00 = Molarity<double>.From(1, MolarityUnit.CentimolesPerLiter);
             AssertEx.EqualTolerance(1, quantity00.CentimolesPerLiter, CentimolesPerLiterTolerance);
             Assert.Equal(MolarityUnit.CentimolesPerLiter, quantity00.Unit);
 
-            var quantity01 = Molarity.From(1, MolarityUnit.DecimolesPerLiter);
+            var quantity01 = Molarity<double>.From(1, MolarityUnit.DecimolesPerLiter);
             AssertEx.EqualTolerance(1, quantity01.DecimolesPerLiter, DecimolesPerLiterTolerance);
             Assert.Equal(MolarityUnit.DecimolesPerLiter, quantity01.Unit);
 
-            var quantity02 = Molarity.From(1, MolarityUnit.MicromolesPerLiter);
+            var quantity02 = Molarity<double>.From(1, MolarityUnit.MicromolesPerLiter);
             AssertEx.EqualTolerance(1, quantity02.MicromolesPerLiter, MicromolesPerLiterTolerance);
             Assert.Equal(MolarityUnit.MicromolesPerLiter, quantity02.Unit);
 
-            var quantity03 = Molarity.From(1, MolarityUnit.MillimolesPerLiter);
+            var quantity03 = Molarity<double>.From(1, MolarityUnit.MillimolesPerLiter);
             AssertEx.EqualTolerance(1, quantity03.MillimolesPerLiter, MillimolesPerLiterTolerance);
             Assert.Equal(MolarityUnit.MillimolesPerLiter, quantity03.Unit);
 
-            var quantity04 = Molarity.From(1, MolarityUnit.MolesPerCubicMeter);
+            var quantity04 = Molarity<double>.From(1, MolarityUnit.MolesPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity04.MolesPerCubicMeter, MolesPerCubicMeterTolerance);
             Assert.Equal(MolarityUnit.MolesPerCubicMeter, quantity04.Unit);
 
-            var quantity05 = Molarity.From(1, MolarityUnit.MolesPerLiter);
+            var quantity05 = Molarity<double>.From(1, MolarityUnit.MolesPerLiter);
             AssertEx.EqualTolerance(1, quantity05.MolesPerLiter, MolesPerLiterTolerance);
             Assert.Equal(MolarityUnit.MolesPerLiter, quantity05.Unit);
 
-            var quantity06 = Molarity.From(1, MolarityUnit.NanomolesPerLiter);
+            var quantity06 = Molarity<double>.From(1, MolarityUnit.NanomolesPerLiter);
             AssertEx.EqualTolerance(1, quantity06.NanomolesPerLiter, NanomolesPerLiterTolerance);
             Assert.Equal(MolarityUnit.NanomolesPerLiter, quantity06.Unit);
 
-            var quantity07 = Molarity.From(1, MolarityUnit.PicomolesPerLiter);
+            var quantity07 = Molarity<double>.From(1, MolarityUnit.PicomolesPerLiter);
             AssertEx.EqualTolerance(1, quantity07.PicomolesPerLiter, PicomolesPerLiterTolerance);
             Assert.Equal(MolarityUnit.PicomolesPerLiter, quantity07.Unit);
 
@@ -179,20 +179,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromMolesPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Molarity.FromMolesPerCubicMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Molarity.FromMolesPerCubicMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Molarity<double>.FromMolesPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Molarity<double>.FromMolesPerCubicMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromMolesPerCubicMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Molarity.FromMolesPerCubicMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => Molarity<double>.FromMolesPerCubicMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            var molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
             AssertEx.EqualTolerance(CentimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.CentimolesPerLiter), CentimolesPerLiterTolerance);
             AssertEx.EqualTolerance(DecimolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.DecimolesPerLiter), DecimolesPerLiterTolerance);
             AssertEx.EqualTolerance(MicromolesPerLiterInOneMolesPerCubicMeter, molespercubicmeter.As(MolarityUnit.MicromolesPerLiter), MicromolesPerLiterTolerance);
@@ -223,7 +223,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            var molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
 
             var centimolesperliterQuantity = molespercubicmeter.ToUnit(MolarityUnit.CentimolesPerLiter);
             AssertEx.EqualTolerance(CentimolesPerLiterInOneMolesPerCubicMeter, (double)centimolesperliterQuantity.Value, CentimolesPerLiterTolerance);
@@ -268,35 +268,35 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Molarity molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, Molarity.FromCentimolesPerLiter(molespercubicmeter.CentimolesPerLiter).MolesPerCubicMeter, CentimolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromDecimolesPerLiter(molespercubicmeter.DecimolesPerLiter).MolesPerCubicMeter, DecimolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMicromolesPerLiter(molespercubicmeter.MicromolesPerLiter).MolesPerCubicMeter, MicromolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMillimolesPerLiter(molespercubicmeter.MillimolesPerLiter).MolesPerCubicMeter, MillimolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMolesPerCubicMeter(molespercubicmeter.MolesPerCubicMeter).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMolesPerLiter(molespercubicmeter.MolesPerLiter).MolesPerCubicMeter, MolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromNanomolesPerLiter(molespercubicmeter.NanomolesPerLiter).MolesPerCubicMeter, NanomolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromPicomolesPerLiter(molespercubicmeter.PicomolesPerLiter).MolesPerCubicMeter, PicomolesPerLiterTolerance);
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromCentimolesPerLiter(molespercubicmeter.CentimolesPerLiter).MolesPerCubicMeter, CentimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromDecimolesPerLiter(molespercubicmeter.DecimolesPerLiter).MolesPerCubicMeter, DecimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMicromolesPerLiter(molespercubicmeter.MicromolesPerLiter).MolesPerCubicMeter, MicromolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMillimolesPerLiter(molespercubicmeter.MillimolesPerLiter).MolesPerCubicMeter, MillimolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMolesPerCubicMeter(molespercubicmeter.MolesPerCubicMeter).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromMolesPerLiter(molespercubicmeter.MolesPerLiter).MolesPerCubicMeter, MolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromNanomolesPerLiter(molespercubicmeter.NanomolesPerLiter).MolesPerCubicMeter, NanomolesPerLiterTolerance);
+            AssertEx.EqualTolerance(1, Molarity<double>.FromPicomolesPerLiter(molespercubicmeter.PicomolesPerLiter).MolesPerCubicMeter, PicomolesPerLiterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Molarity v = Molarity.FromMolesPerCubicMeter(1);
+            Molarity<double> v = Molarity<double>.FromMolesPerCubicMeter(1);
             AssertEx.EqualTolerance(-1, -v.MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Molarity.FromMolesPerCubicMeter(3)-v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (Molarity<double>.FromMolesPerCubicMeter(3)-v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Molarity.FromMolesPerCubicMeter(10)/5).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, Molarity.FromMolesPerCubicMeter(10)/Molarity.FromMolesPerCubicMeter(5), MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (Molarity<double>.FromMolesPerCubicMeter(10)/5).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, Molarity<double>.FromMolesPerCubicMeter(10)/Molarity<double>.FromMolesPerCubicMeter(5), MolesPerCubicMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Molarity oneMolesPerCubicMeter = Molarity.FromMolesPerCubicMeter(1);
-            Molarity twoMolesPerCubicMeter = Molarity.FromMolesPerCubicMeter(2);
+            Molarity<double> oneMolesPerCubicMeter = Molarity<double>.FromMolesPerCubicMeter(1);
+            Molarity<double> twoMolesPerCubicMeter = Molarity<double>.FromMolesPerCubicMeter(2);
 
             Assert.True(oneMolesPerCubicMeter < twoMolesPerCubicMeter);
             Assert.True(oneMolesPerCubicMeter <= twoMolesPerCubicMeter);
@@ -312,31 +312,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Molarity molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
             Assert.Equal(0, molespercubicmeter.CompareTo(molespercubicmeter));
-            Assert.True(molespercubicmeter.CompareTo(Molarity.Zero) > 0);
-            Assert.True(Molarity.Zero.CompareTo(molespercubicmeter) < 0);
+            Assert.True(molespercubicmeter.CompareTo(Molarity<double>.Zero) > 0);
+            Assert.True(Molarity<double>.Zero.CompareTo(molespercubicmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Molarity molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
             Assert.Throws<ArgumentException>(() => molespercubicmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Molarity molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
             Assert.Throws<ArgumentNullException>(() => molespercubicmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Molarity.FromMolesPerCubicMeter(1);
-            var b = Molarity.FromMolesPerCubicMeter(2);
+            var a = Molarity<double>.FromMolesPerCubicMeter(1);
+            var b = Molarity<double>.FromMolesPerCubicMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -355,8 +355,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Molarity.FromMolesPerCubicMeter(1);
-            var b = Molarity.FromMolesPerCubicMeter(2);
+            var a = Molarity<double>.FromMolesPerCubicMeter(1);
+            var b = Molarity<double>.FromMolesPerCubicMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -376,9 +376,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Molarity.FromMolesPerCubicMeter(1);
-            Assert.True(v.Equals(Molarity.FromMolesPerCubicMeter(1), MolesPerCubicMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Molarity.Zero, MolesPerCubicMeterTolerance, ComparisonType.Relative));
+            var v = Molarity<double>.FromMolesPerCubicMeter(1);
+            Assert.True(v.Equals(Molarity<double>.FromMolesPerCubicMeter(1), MolesPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Molarity<double>.Zero, MolesPerCubicMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -391,21 +391,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Molarity molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
             Assert.False(molespercubicmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Molarity molespercubicmeter = Molarity.FromMolesPerCubicMeter(1);
+            Molarity<double> molespercubicmeter = Molarity<double>.FromMolesPerCubicMeter(1);
             Assert.False(molespercubicmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(MolarityUnit.Undefined, Molarity.Units);
+            Assert.DoesNotContain(MolarityUnit.Undefined, Molarity<double>.Units);
         }
 
         [Fact]
@@ -424,7 +424,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Molarity.BaseDimensions is null);
+            Assert.False(Molarity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs
index 364757c8d3..198dacadd6 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class PermeabilityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Permeability((double)0.0, PermeabilityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Permeability<double>((double)0.0, PermeabilityUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Permeability(double.PositiveInfinity, PermeabilityUnit.HenryPerMeter));
-            Assert.Throws<ArgumentException>(() => new Permeability(double.NegativeInfinity, PermeabilityUnit.HenryPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permeability<double>(double.PositiveInfinity, PermeabilityUnit.HenryPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permeability<double>(double.NegativeInfinity, PermeabilityUnit.HenryPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Permeability(double.NaN, PermeabilityUnit.HenryPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permeability<double>(double.NaN, PermeabilityUnit.HenryPerMeter));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void Permeability_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void HenryPerMeterToPermeabilityUnits()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
             AssertEx.EqualTolerance(HenriesPerMeterInOneHenryPerMeter, henrypermeter.HenriesPerMeter, HenriesPerMeterTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Permeability.From(1, PermeabilityUnit.HenryPerMeter);
+            var quantity00 = Permeability<double>.From(1, PermeabilityUnit.HenryPerMeter);
             AssertEx.EqualTolerance(1, quantity00.HenriesPerMeter, HenriesPerMeterTolerance);
             Assert.Equal(PermeabilityUnit.HenryPerMeter, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromHenriesPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Permeability.FromHenriesPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Permeability.FromHenriesPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Permeability<double>.FromHenriesPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Permeability<double>.FromHenriesPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromHenriesPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Permeability.FromHenriesPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => Permeability<double>.FromHenriesPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var henrypermeter = Permeability.FromHenriesPerMeter(1);
+            var henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
             AssertEx.EqualTolerance(HenriesPerMeterInOneHenryPerMeter, henrypermeter.As(PermeabilityUnit.HenryPerMeter), HenriesPerMeterTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var henrypermeter = Permeability.FromHenriesPerMeter(1);
+            var henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
 
             var henrypermeterQuantity = henrypermeter.ToUnit(PermeabilityUnit.HenryPerMeter);
             AssertEx.EqualTolerance(HenriesPerMeterInOneHenryPerMeter, (double)henrypermeterQuantity.Value, HenriesPerMeterTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
-            AssertEx.EqualTolerance(1, Permeability.FromHenriesPerMeter(henrypermeter.HenriesPerMeter).HenriesPerMeter, HenriesPerMeterTolerance);
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
+            AssertEx.EqualTolerance(1, Permeability<double>.FromHenriesPerMeter(henrypermeter.HenriesPerMeter).HenriesPerMeter, HenriesPerMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Permeability v = Permeability.FromHenriesPerMeter(1);
+            Permeability<double> v = Permeability<double>.FromHenriesPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permeability.FromHenriesPerMeter(3)-v).HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permeability<double>.FromHenriesPerMeter(3)-v).HenriesPerMeter, HenriesPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).HenriesPerMeter, HenriesPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).HenriesPerMeter, HenriesPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permeability.FromHenriesPerMeter(10)/5).HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, Permeability.FromHenriesPerMeter(10)/Permeability.FromHenriesPerMeter(5), HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permeability<double>.FromHenriesPerMeter(10)/5).HenriesPerMeter, HenriesPerMeterTolerance);
+            AssertEx.EqualTolerance(2, Permeability<double>.FromHenriesPerMeter(10)/Permeability<double>.FromHenriesPerMeter(5), HenriesPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Permeability oneHenryPerMeter = Permeability.FromHenriesPerMeter(1);
-            Permeability twoHenriesPerMeter = Permeability.FromHenriesPerMeter(2);
+            Permeability<double> oneHenryPerMeter = Permeability<double>.FromHenriesPerMeter(1);
+            Permeability<double> twoHenriesPerMeter = Permeability<double>.FromHenriesPerMeter(2);
 
             Assert.True(oneHenryPerMeter < twoHenriesPerMeter);
             Assert.True(oneHenryPerMeter <= twoHenriesPerMeter);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
             Assert.Equal(0, henrypermeter.CompareTo(henrypermeter));
-            Assert.True(henrypermeter.CompareTo(Permeability.Zero) > 0);
-            Assert.True(Permeability.Zero.CompareTo(henrypermeter) < 0);
+            Assert.True(henrypermeter.CompareTo(Permeability<double>.Zero) > 0);
+            Assert.True(Permeability<double>.Zero.CompareTo(henrypermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
             Assert.Throws<ArgumentException>(() => henrypermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => henrypermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Permeability.FromHenriesPerMeter(1);
-            var b = Permeability.FromHenriesPerMeter(2);
+            var a = Permeability<double>.FromHenriesPerMeter(1);
+            var b = Permeability<double>.FromHenriesPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Permeability.FromHenriesPerMeter(1);
-            var b = Permeability.FromHenriesPerMeter(2);
+            var a = Permeability<double>.FromHenriesPerMeter(1);
+            var b = Permeability<double>.FromHenriesPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Permeability.FromHenriesPerMeter(1);
-            Assert.True(v.Equals(Permeability.FromHenriesPerMeter(1), HenriesPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Permeability.Zero, HenriesPerMeterTolerance, ComparisonType.Relative));
+            var v = Permeability<double>.FromHenriesPerMeter(1);
+            Assert.True(v.Equals(Permeability<double>.FromHenriesPerMeter(1), HenriesPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Permeability<double>.Zero, HenriesPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
             Assert.False(henrypermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
+            Permeability<double> henrypermeter = Permeability<double>.FromHenriesPerMeter(1);
             Assert.False(henrypermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(PermeabilityUnit.Undefined, Permeability.Units);
+            Assert.DoesNotContain(PermeabilityUnit.Undefined, Permeability<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Permeability.BaseDimensions is null);
+            Assert.False(Permeability<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs
index 68e9002427..fe7ef92fac 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class PermittivityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Permittivity((double)0.0, PermittivityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>((double)0.0, PermittivityUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Permittivity(double.PositiveInfinity, PermittivityUnit.FaradPerMeter));
-            Assert.Throws<ArgumentException>(() => new Permittivity(double.NegativeInfinity, PermittivityUnit.FaradPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>(double.PositiveInfinity, PermittivityUnit.FaradPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>(double.NegativeInfinity, PermittivityUnit.FaradPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Permittivity(double.NaN, PermittivityUnit.FaradPerMeter));
+            Assert.Throws<ArgumentException>(() => new Permittivity<double>(double.NaN, PermittivityUnit.FaradPerMeter));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void Permittivity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void FaradPerMeterToPermittivityUnits()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
             AssertEx.EqualTolerance(FaradsPerMeterInOneFaradPerMeter, faradpermeter.FaradsPerMeter, FaradsPerMeterTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Permittivity.From(1, PermittivityUnit.FaradPerMeter);
+            var quantity00 = Permittivity<double>.From(1, PermittivityUnit.FaradPerMeter);
             AssertEx.EqualTolerance(1, quantity00.FaradsPerMeter, FaradsPerMeterTolerance);
             Assert.Equal(PermittivityUnit.FaradPerMeter, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromFaradsPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Permittivity.FromFaradsPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Permittivity.FromFaradsPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Permittivity<double>.FromFaradsPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Permittivity<double>.FromFaradsPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromFaradsPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Permittivity.FromFaradsPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => Permittivity<double>.FromFaradsPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            var faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
             AssertEx.EqualTolerance(FaradsPerMeterInOneFaradPerMeter, faradpermeter.As(PermittivityUnit.FaradPerMeter), FaradsPerMeterTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            var faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
 
             var faradpermeterQuantity = faradpermeter.ToUnit(PermittivityUnit.FaradPerMeter);
             AssertEx.EqualTolerance(FaradsPerMeterInOneFaradPerMeter, (double)faradpermeterQuantity.Value, FaradsPerMeterTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
-            AssertEx.EqualTolerance(1, Permittivity.FromFaradsPerMeter(faradpermeter.FaradsPerMeter).FaradsPerMeter, FaradsPerMeterTolerance);
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
+            AssertEx.EqualTolerance(1, Permittivity<double>.FromFaradsPerMeter(faradpermeter.FaradsPerMeter).FaradsPerMeter, FaradsPerMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Permittivity v = Permittivity.FromFaradsPerMeter(1);
+            Permittivity<double> v = Permittivity<double>.FromFaradsPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permittivity.FromFaradsPerMeter(3)-v).FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permittivity<double>.FromFaradsPerMeter(3)-v).FaradsPerMeter, FaradsPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).FaradsPerMeter, FaradsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).FaradsPerMeter, FaradsPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permittivity.FromFaradsPerMeter(10)/5).FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, Permittivity.FromFaradsPerMeter(10)/Permittivity.FromFaradsPerMeter(5), FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (Permittivity<double>.FromFaradsPerMeter(10)/5).FaradsPerMeter, FaradsPerMeterTolerance);
+            AssertEx.EqualTolerance(2, Permittivity<double>.FromFaradsPerMeter(10)/Permittivity<double>.FromFaradsPerMeter(5), FaradsPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Permittivity oneFaradPerMeter = Permittivity.FromFaradsPerMeter(1);
-            Permittivity twoFaradsPerMeter = Permittivity.FromFaradsPerMeter(2);
+            Permittivity<double> oneFaradPerMeter = Permittivity<double>.FromFaradsPerMeter(1);
+            Permittivity<double> twoFaradsPerMeter = Permittivity<double>.FromFaradsPerMeter(2);
 
             Assert.True(oneFaradPerMeter < twoFaradsPerMeter);
             Assert.True(oneFaradPerMeter <= twoFaradsPerMeter);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
             Assert.Equal(0, faradpermeter.CompareTo(faradpermeter));
-            Assert.True(faradpermeter.CompareTo(Permittivity.Zero) > 0);
-            Assert.True(Permittivity.Zero.CompareTo(faradpermeter) < 0);
+            Assert.True(faradpermeter.CompareTo(Permittivity<double>.Zero) > 0);
+            Assert.True(Permittivity<double>.Zero.CompareTo(faradpermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
             Assert.Throws<ArgumentException>(() => faradpermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => faradpermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Permittivity.FromFaradsPerMeter(1);
-            var b = Permittivity.FromFaradsPerMeter(2);
+            var a = Permittivity<double>.FromFaradsPerMeter(1);
+            var b = Permittivity<double>.FromFaradsPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Permittivity.FromFaradsPerMeter(1);
-            var b = Permittivity.FromFaradsPerMeter(2);
+            var a = Permittivity<double>.FromFaradsPerMeter(1);
+            var b = Permittivity<double>.FromFaradsPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Permittivity.FromFaradsPerMeter(1);
-            Assert.True(v.Equals(Permittivity.FromFaradsPerMeter(1), FaradsPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Permittivity.Zero, FaradsPerMeterTolerance, ComparisonType.Relative));
+            var v = Permittivity<double>.FromFaradsPerMeter(1);
+            Assert.True(v.Equals(Permittivity<double>.FromFaradsPerMeter(1), FaradsPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Permittivity<double>.Zero, FaradsPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
             Assert.False(faradpermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
+            Permittivity<double> faradpermeter = Permittivity<double>.FromFaradsPerMeter(1);
             Assert.False(faradpermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(PermittivityUnit.Undefined, Permittivity.Units);
+            Assert.DoesNotContain(PermittivityUnit.Undefined, Permittivity<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Permittivity.BaseDimensions is null);
+            Assert.False(Permittivity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs
index 7854a934e3..2e229127b1 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs
@@ -132,7 +132,7 @@ public abstract partial class PowerDensityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PowerDensity((double)0.0, PowerDensityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new PowerDensity<double>((double)0.0, PowerDensityUnit.Undefined));
         }
 
         [Fact]
@@ -147,14 +147,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PowerDensity(double.PositiveInfinity, PowerDensityUnit.WattPerCubicMeter));
-            Assert.Throws<ArgumentException>(() => new PowerDensity(double.NegativeInfinity, PowerDensityUnit.WattPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new PowerDensity<double>(double.PositiveInfinity, PowerDensityUnit.WattPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new PowerDensity<double>(double.NegativeInfinity, PowerDensityUnit.WattPerCubicMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PowerDensity(double.NaN, PowerDensityUnit.WattPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new PowerDensity<double>(double.NaN, PowerDensityUnit.WattPerCubicMeter));
         }
 
         [Fact]
@@ -200,7 +200,7 @@ public void PowerDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void WattPerCubicMeterToPowerDensityUnits()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            PowerDensity<double> wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
             AssertEx.EqualTolerance(DecawattsPerCubicFootInOneWattPerCubicMeter, wattpercubicmeter.DecawattsPerCubicFoot, DecawattsPerCubicFootTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicInchInOneWattPerCubicMeter, wattpercubicmeter.DecawattsPerCubicInch, DecawattsPerCubicInchTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicMeterInOneWattPerCubicMeter, wattpercubicmeter.DecawattsPerCubicMeter, DecawattsPerCubicMeterTolerance);
@@ -250,179 +250,179 @@ public void WattPerCubicMeterToPowerDensityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = PowerDensity.From(1, PowerDensityUnit.DecawattPerCubicFoot);
+            var quantity00 = PowerDensity<double>.From(1, PowerDensityUnit.DecawattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity00.DecawattsPerCubicFoot, DecawattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.DecawattPerCubicFoot, quantity00.Unit);
 
-            var quantity01 = PowerDensity.From(1, PowerDensityUnit.DecawattPerCubicInch);
+            var quantity01 = PowerDensity<double>.From(1, PowerDensityUnit.DecawattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity01.DecawattsPerCubicInch, DecawattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.DecawattPerCubicInch, quantity01.Unit);
 
-            var quantity02 = PowerDensity.From(1, PowerDensityUnit.DecawattPerCubicMeter);
+            var quantity02 = PowerDensity<double>.From(1, PowerDensityUnit.DecawattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity02.DecawattsPerCubicMeter, DecawattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.DecawattPerCubicMeter, quantity02.Unit);
 
-            var quantity03 = PowerDensity.From(1, PowerDensityUnit.DecawattPerLiter);
+            var quantity03 = PowerDensity<double>.From(1, PowerDensityUnit.DecawattPerLiter);
             AssertEx.EqualTolerance(1, quantity03.DecawattsPerLiter, DecawattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.DecawattPerLiter, quantity03.Unit);
 
-            var quantity04 = PowerDensity.From(1, PowerDensityUnit.DeciwattPerCubicFoot);
+            var quantity04 = PowerDensity<double>.From(1, PowerDensityUnit.DeciwattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity04.DeciwattsPerCubicFoot, DeciwattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.DeciwattPerCubicFoot, quantity04.Unit);
 
-            var quantity05 = PowerDensity.From(1, PowerDensityUnit.DeciwattPerCubicInch);
+            var quantity05 = PowerDensity<double>.From(1, PowerDensityUnit.DeciwattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity05.DeciwattsPerCubicInch, DeciwattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.DeciwattPerCubicInch, quantity05.Unit);
 
-            var quantity06 = PowerDensity.From(1, PowerDensityUnit.DeciwattPerCubicMeter);
+            var quantity06 = PowerDensity<double>.From(1, PowerDensityUnit.DeciwattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity06.DeciwattsPerCubicMeter, DeciwattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.DeciwattPerCubicMeter, quantity06.Unit);
 
-            var quantity07 = PowerDensity.From(1, PowerDensityUnit.DeciwattPerLiter);
+            var quantity07 = PowerDensity<double>.From(1, PowerDensityUnit.DeciwattPerLiter);
             AssertEx.EqualTolerance(1, quantity07.DeciwattsPerLiter, DeciwattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.DeciwattPerLiter, quantity07.Unit);
 
-            var quantity08 = PowerDensity.From(1, PowerDensityUnit.GigawattPerCubicFoot);
+            var quantity08 = PowerDensity<double>.From(1, PowerDensityUnit.GigawattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity08.GigawattsPerCubicFoot, GigawattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.GigawattPerCubicFoot, quantity08.Unit);
 
-            var quantity09 = PowerDensity.From(1, PowerDensityUnit.GigawattPerCubicInch);
+            var quantity09 = PowerDensity<double>.From(1, PowerDensityUnit.GigawattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity09.GigawattsPerCubicInch, GigawattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.GigawattPerCubicInch, quantity09.Unit);
 
-            var quantity10 = PowerDensity.From(1, PowerDensityUnit.GigawattPerCubicMeter);
+            var quantity10 = PowerDensity<double>.From(1, PowerDensityUnit.GigawattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity10.GigawattsPerCubicMeter, GigawattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.GigawattPerCubicMeter, quantity10.Unit);
 
-            var quantity11 = PowerDensity.From(1, PowerDensityUnit.GigawattPerLiter);
+            var quantity11 = PowerDensity<double>.From(1, PowerDensityUnit.GigawattPerLiter);
             AssertEx.EqualTolerance(1, quantity11.GigawattsPerLiter, GigawattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.GigawattPerLiter, quantity11.Unit);
 
-            var quantity12 = PowerDensity.From(1, PowerDensityUnit.KilowattPerCubicFoot);
+            var quantity12 = PowerDensity<double>.From(1, PowerDensityUnit.KilowattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity12.KilowattsPerCubicFoot, KilowattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.KilowattPerCubicFoot, quantity12.Unit);
 
-            var quantity13 = PowerDensity.From(1, PowerDensityUnit.KilowattPerCubicInch);
+            var quantity13 = PowerDensity<double>.From(1, PowerDensityUnit.KilowattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity13.KilowattsPerCubicInch, KilowattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.KilowattPerCubicInch, quantity13.Unit);
 
-            var quantity14 = PowerDensity.From(1, PowerDensityUnit.KilowattPerCubicMeter);
+            var quantity14 = PowerDensity<double>.From(1, PowerDensityUnit.KilowattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity14.KilowattsPerCubicMeter, KilowattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.KilowattPerCubicMeter, quantity14.Unit);
 
-            var quantity15 = PowerDensity.From(1, PowerDensityUnit.KilowattPerLiter);
+            var quantity15 = PowerDensity<double>.From(1, PowerDensityUnit.KilowattPerLiter);
             AssertEx.EqualTolerance(1, quantity15.KilowattsPerLiter, KilowattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.KilowattPerLiter, quantity15.Unit);
 
-            var quantity16 = PowerDensity.From(1, PowerDensityUnit.MegawattPerCubicFoot);
+            var quantity16 = PowerDensity<double>.From(1, PowerDensityUnit.MegawattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity16.MegawattsPerCubicFoot, MegawattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.MegawattPerCubicFoot, quantity16.Unit);
 
-            var quantity17 = PowerDensity.From(1, PowerDensityUnit.MegawattPerCubicInch);
+            var quantity17 = PowerDensity<double>.From(1, PowerDensityUnit.MegawattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity17.MegawattsPerCubicInch, MegawattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.MegawattPerCubicInch, quantity17.Unit);
 
-            var quantity18 = PowerDensity.From(1, PowerDensityUnit.MegawattPerCubicMeter);
+            var quantity18 = PowerDensity<double>.From(1, PowerDensityUnit.MegawattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity18.MegawattsPerCubicMeter, MegawattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.MegawattPerCubicMeter, quantity18.Unit);
 
-            var quantity19 = PowerDensity.From(1, PowerDensityUnit.MegawattPerLiter);
+            var quantity19 = PowerDensity<double>.From(1, PowerDensityUnit.MegawattPerLiter);
             AssertEx.EqualTolerance(1, quantity19.MegawattsPerLiter, MegawattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.MegawattPerLiter, quantity19.Unit);
 
-            var quantity20 = PowerDensity.From(1, PowerDensityUnit.MicrowattPerCubicFoot);
+            var quantity20 = PowerDensity<double>.From(1, PowerDensityUnit.MicrowattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity20.MicrowattsPerCubicFoot, MicrowattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.MicrowattPerCubicFoot, quantity20.Unit);
 
-            var quantity21 = PowerDensity.From(1, PowerDensityUnit.MicrowattPerCubicInch);
+            var quantity21 = PowerDensity<double>.From(1, PowerDensityUnit.MicrowattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity21.MicrowattsPerCubicInch, MicrowattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.MicrowattPerCubicInch, quantity21.Unit);
 
-            var quantity22 = PowerDensity.From(1, PowerDensityUnit.MicrowattPerCubicMeter);
+            var quantity22 = PowerDensity<double>.From(1, PowerDensityUnit.MicrowattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity22.MicrowattsPerCubicMeter, MicrowattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.MicrowattPerCubicMeter, quantity22.Unit);
 
-            var quantity23 = PowerDensity.From(1, PowerDensityUnit.MicrowattPerLiter);
+            var quantity23 = PowerDensity<double>.From(1, PowerDensityUnit.MicrowattPerLiter);
             AssertEx.EqualTolerance(1, quantity23.MicrowattsPerLiter, MicrowattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.MicrowattPerLiter, quantity23.Unit);
 
-            var quantity24 = PowerDensity.From(1, PowerDensityUnit.MilliwattPerCubicFoot);
+            var quantity24 = PowerDensity<double>.From(1, PowerDensityUnit.MilliwattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity24.MilliwattsPerCubicFoot, MilliwattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.MilliwattPerCubicFoot, quantity24.Unit);
 
-            var quantity25 = PowerDensity.From(1, PowerDensityUnit.MilliwattPerCubicInch);
+            var quantity25 = PowerDensity<double>.From(1, PowerDensityUnit.MilliwattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity25.MilliwattsPerCubicInch, MilliwattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.MilliwattPerCubicInch, quantity25.Unit);
 
-            var quantity26 = PowerDensity.From(1, PowerDensityUnit.MilliwattPerCubicMeter);
+            var quantity26 = PowerDensity<double>.From(1, PowerDensityUnit.MilliwattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity26.MilliwattsPerCubicMeter, MilliwattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.MilliwattPerCubicMeter, quantity26.Unit);
 
-            var quantity27 = PowerDensity.From(1, PowerDensityUnit.MilliwattPerLiter);
+            var quantity27 = PowerDensity<double>.From(1, PowerDensityUnit.MilliwattPerLiter);
             AssertEx.EqualTolerance(1, quantity27.MilliwattsPerLiter, MilliwattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.MilliwattPerLiter, quantity27.Unit);
 
-            var quantity28 = PowerDensity.From(1, PowerDensityUnit.NanowattPerCubicFoot);
+            var quantity28 = PowerDensity<double>.From(1, PowerDensityUnit.NanowattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity28.NanowattsPerCubicFoot, NanowattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.NanowattPerCubicFoot, quantity28.Unit);
 
-            var quantity29 = PowerDensity.From(1, PowerDensityUnit.NanowattPerCubicInch);
+            var quantity29 = PowerDensity<double>.From(1, PowerDensityUnit.NanowattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity29.NanowattsPerCubicInch, NanowattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.NanowattPerCubicInch, quantity29.Unit);
 
-            var quantity30 = PowerDensity.From(1, PowerDensityUnit.NanowattPerCubicMeter);
+            var quantity30 = PowerDensity<double>.From(1, PowerDensityUnit.NanowattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity30.NanowattsPerCubicMeter, NanowattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.NanowattPerCubicMeter, quantity30.Unit);
 
-            var quantity31 = PowerDensity.From(1, PowerDensityUnit.NanowattPerLiter);
+            var quantity31 = PowerDensity<double>.From(1, PowerDensityUnit.NanowattPerLiter);
             AssertEx.EqualTolerance(1, quantity31.NanowattsPerLiter, NanowattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.NanowattPerLiter, quantity31.Unit);
 
-            var quantity32 = PowerDensity.From(1, PowerDensityUnit.PicowattPerCubicFoot);
+            var quantity32 = PowerDensity<double>.From(1, PowerDensityUnit.PicowattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity32.PicowattsPerCubicFoot, PicowattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.PicowattPerCubicFoot, quantity32.Unit);
 
-            var quantity33 = PowerDensity.From(1, PowerDensityUnit.PicowattPerCubicInch);
+            var quantity33 = PowerDensity<double>.From(1, PowerDensityUnit.PicowattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity33.PicowattsPerCubicInch, PicowattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.PicowattPerCubicInch, quantity33.Unit);
 
-            var quantity34 = PowerDensity.From(1, PowerDensityUnit.PicowattPerCubicMeter);
+            var quantity34 = PowerDensity<double>.From(1, PowerDensityUnit.PicowattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity34.PicowattsPerCubicMeter, PicowattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.PicowattPerCubicMeter, quantity34.Unit);
 
-            var quantity35 = PowerDensity.From(1, PowerDensityUnit.PicowattPerLiter);
+            var quantity35 = PowerDensity<double>.From(1, PowerDensityUnit.PicowattPerLiter);
             AssertEx.EqualTolerance(1, quantity35.PicowattsPerLiter, PicowattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.PicowattPerLiter, quantity35.Unit);
 
-            var quantity36 = PowerDensity.From(1, PowerDensityUnit.TerawattPerCubicFoot);
+            var quantity36 = PowerDensity<double>.From(1, PowerDensityUnit.TerawattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity36.TerawattsPerCubicFoot, TerawattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.TerawattPerCubicFoot, quantity36.Unit);
 
-            var quantity37 = PowerDensity.From(1, PowerDensityUnit.TerawattPerCubicInch);
+            var quantity37 = PowerDensity<double>.From(1, PowerDensityUnit.TerawattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity37.TerawattsPerCubicInch, TerawattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.TerawattPerCubicInch, quantity37.Unit);
 
-            var quantity38 = PowerDensity.From(1, PowerDensityUnit.TerawattPerCubicMeter);
+            var quantity38 = PowerDensity<double>.From(1, PowerDensityUnit.TerawattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity38.TerawattsPerCubicMeter, TerawattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.TerawattPerCubicMeter, quantity38.Unit);
 
-            var quantity39 = PowerDensity.From(1, PowerDensityUnit.TerawattPerLiter);
+            var quantity39 = PowerDensity<double>.From(1, PowerDensityUnit.TerawattPerLiter);
             AssertEx.EqualTolerance(1, quantity39.TerawattsPerLiter, TerawattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.TerawattPerLiter, quantity39.Unit);
 
-            var quantity40 = PowerDensity.From(1, PowerDensityUnit.WattPerCubicFoot);
+            var quantity40 = PowerDensity<double>.From(1, PowerDensityUnit.WattPerCubicFoot);
             AssertEx.EqualTolerance(1, quantity40.WattsPerCubicFoot, WattsPerCubicFootTolerance);
             Assert.Equal(PowerDensityUnit.WattPerCubicFoot, quantity40.Unit);
 
-            var quantity41 = PowerDensity.From(1, PowerDensityUnit.WattPerCubicInch);
+            var quantity41 = PowerDensity<double>.From(1, PowerDensityUnit.WattPerCubicInch);
             AssertEx.EqualTolerance(1, quantity41.WattsPerCubicInch, WattsPerCubicInchTolerance);
             Assert.Equal(PowerDensityUnit.WattPerCubicInch, quantity41.Unit);
 
-            var quantity42 = PowerDensity.From(1, PowerDensityUnit.WattPerCubicMeter);
+            var quantity42 = PowerDensity<double>.From(1, PowerDensityUnit.WattPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity42.WattsPerCubicMeter, WattsPerCubicMeterTolerance);
             Assert.Equal(PowerDensityUnit.WattPerCubicMeter, quantity42.Unit);
 
-            var quantity43 = PowerDensity.From(1, PowerDensityUnit.WattPerLiter);
+            var quantity43 = PowerDensity<double>.From(1, PowerDensityUnit.WattPerLiter);
             AssertEx.EqualTolerance(1, quantity43.WattsPerLiter, WattsPerLiterTolerance);
             Assert.Equal(PowerDensityUnit.WattPerLiter, quantity43.Unit);
 
@@ -431,20 +431,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWattsPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => PowerDensity.FromWattsPerCubicMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => PowerDensity.FromWattsPerCubicMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => PowerDensity<double>.FromWattsPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => PowerDensity<double>.FromWattsPerCubicMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWattsPerCubicMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => PowerDensity.FromWattsPerCubicMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => PowerDensity<double>.FromWattsPerCubicMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            var wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
             AssertEx.EqualTolerance(DecawattsPerCubicFootInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.DecawattPerCubicFoot), DecawattsPerCubicFootTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicInchInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.DecawattPerCubicInch), DecawattsPerCubicInchTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicMeterInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.DecawattPerCubicMeter), DecawattsPerCubicMeterTolerance);
@@ -511,7 +511,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            var wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
 
             var decawattpercubicfootQuantity = wattpercubicmeter.ToUnit(PowerDensityUnit.DecawattPerCubicFoot);
             AssertEx.EqualTolerance(DecawattsPerCubicFootInOneWattPerCubicMeter, (double)decawattpercubicfootQuantity.Value, DecawattsPerCubicFootTolerance);
@@ -700,71 +700,71 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerCubicFoot(wattpercubicmeter.DecawattsPerCubicFoot).WattsPerCubicMeter, DecawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerCubicInch(wattpercubicmeter.DecawattsPerCubicInch).WattsPerCubicMeter, DecawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerCubicMeter(wattpercubicmeter.DecawattsPerCubicMeter).WattsPerCubicMeter, DecawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerLiter(wattpercubicmeter.DecawattsPerLiter).WattsPerCubicMeter, DecawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerCubicFoot(wattpercubicmeter.DeciwattsPerCubicFoot).WattsPerCubicMeter, DeciwattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerCubicInch(wattpercubicmeter.DeciwattsPerCubicInch).WattsPerCubicMeter, DeciwattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerCubicMeter(wattpercubicmeter.DeciwattsPerCubicMeter).WattsPerCubicMeter, DeciwattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerLiter(wattpercubicmeter.DeciwattsPerLiter).WattsPerCubicMeter, DeciwattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerCubicFoot(wattpercubicmeter.GigawattsPerCubicFoot).WattsPerCubicMeter, GigawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerCubicInch(wattpercubicmeter.GigawattsPerCubicInch).WattsPerCubicMeter, GigawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerCubicMeter(wattpercubicmeter.GigawattsPerCubicMeter).WattsPerCubicMeter, GigawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerLiter(wattpercubicmeter.GigawattsPerLiter).WattsPerCubicMeter, GigawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerCubicFoot(wattpercubicmeter.KilowattsPerCubicFoot).WattsPerCubicMeter, KilowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerCubicInch(wattpercubicmeter.KilowattsPerCubicInch).WattsPerCubicMeter, KilowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerCubicMeter(wattpercubicmeter.KilowattsPerCubicMeter).WattsPerCubicMeter, KilowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerLiter(wattpercubicmeter.KilowattsPerLiter).WattsPerCubicMeter, KilowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerCubicFoot(wattpercubicmeter.MegawattsPerCubicFoot).WattsPerCubicMeter, MegawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerCubicInch(wattpercubicmeter.MegawattsPerCubicInch).WattsPerCubicMeter, MegawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerCubicMeter(wattpercubicmeter.MegawattsPerCubicMeter).WattsPerCubicMeter, MegawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerLiter(wattpercubicmeter.MegawattsPerLiter).WattsPerCubicMeter, MegawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerCubicFoot(wattpercubicmeter.MicrowattsPerCubicFoot).WattsPerCubicMeter, MicrowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerCubicInch(wattpercubicmeter.MicrowattsPerCubicInch).WattsPerCubicMeter, MicrowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerCubicMeter(wattpercubicmeter.MicrowattsPerCubicMeter).WattsPerCubicMeter, MicrowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerLiter(wattpercubicmeter.MicrowattsPerLiter).WattsPerCubicMeter, MicrowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerCubicFoot(wattpercubicmeter.MilliwattsPerCubicFoot).WattsPerCubicMeter, MilliwattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerCubicInch(wattpercubicmeter.MilliwattsPerCubicInch).WattsPerCubicMeter, MilliwattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerCubicMeter(wattpercubicmeter.MilliwattsPerCubicMeter).WattsPerCubicMeter, MilliwattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerLiter(wattpercubicmeter.MilliwattsPerLiter).WattsPerCubicMeter, MilliwattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerCubicFoot(wattpercubicmeter.NanowattsPerCubicFoot).WattsPerCubicMeter, NanowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerCubicInch(wattpercubicmeter.NanowattsPerCubicInch).WattsPerCubicMeter, NanowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerCubicMeter(wattpercubicmeter.NanowattsPerCubicMeter).WattsPerCubicMeter, NanowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerLiter(wattpercubicmeter.NanowattsPerLiter).WattsPerCubicMeter, NanowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerCubicFoot(wattpercubicmeter.PicowattsPerCubicFoot).WattsPerCubicMeter, PicowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerCubicInch(wattpercubicmeter.PicowattsPerCubicInch).WattsPerCubicMeter, PicowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerCubicMeter(wattpercubicmeter.PicowattsPerCubicMeter).WattsPerCubicMeter, PicowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerLiter(wattpercubicmeter.PicowattsPerLiter).WattsPerCubicMeter, PicowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerCubicFoot(wattpercubicmeter.TerawattsPerCubicFoot).WattsPerCubicMeter, TerawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerCubicInch(wattpercubicmeter.TerawattsPerCubicInch).WattsPerCubicMeter, TerawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerCubicMeter(wattpercubicmeter.TerawattsPerCubicMeter).WattsPerCubicMeter, TerawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerLiter(wattpercubicmeter.TerawattsPerLiter).WattsPerCubicMeter, TerawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerCubicFoot(wattpercubicmeter.WattsPerCubicFoot).WattsPerCubicMeter, WattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerCubicInch(wattpercubicmeter.WattsPerCubicInch).WattsPerCubicMeter, WattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerCubicMeter(wattpercubicmeter.WattsPerCubicMeter).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerLiter(wattpercubicmeter.WattsPerLiter).WattsPerCubicMeter, WattsPerLiterTolerance);
+            PowerDensity<double> wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDecawattsPerCubicFoot(wattpercubicmeter.DecawattsPerCubicFoot).WattsPerCubicMeter, DecawattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDecawattsPerCubicInch(wattpercubicmeter.DecawattsPerCubicInch).WattsPerCubicMeter, DecawattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDecawattsPerCubicMeter(wattpercubicmeter.DecawattsPerCubicMeter).WattsPerCubicMeter, DecawattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDecawattsPerLiter(wattpercubicmeter.DecawattsPerLiter).WattsPerCubicMeter, DecawattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDeciwattsPerCubicFoot(wattpercubicmeter.DeciwattsPerCubicFoot).WattsPerCubicMeter, DeciwattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDeciwattsPerCubicInch(wattpercubicmeter.DeciwattsPerCubicInch).WattsPerCubicMeter, DeciwattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDeciwattsPerCubicMeter(wattpercubicmeter.DeciwattsPerCubicMeter).WattsPerCubicMeter, DeciwattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromDeciwattsPerLiter(wattpercubicmeter.DeciwattsPerLiter).WattsPerCubicMeter, DeciwattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromGigawattsPerCubicFoot(wattpercubicmeter.GigawattsPerCubicFoot).WattsPerCubicMeter, GigawattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromGigawattsPerCubicInch(wattpercubicmeter.GigawattsPerCubicInch).WattsPerCubicMeter, GigawattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromGigawattsPerCubicMeter(wattpercubicmeter.GigawattsPerCubicMeter).WattsPerCubicMeter, GigawattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromGigawattsPerLiter(wattpercubicmeter.GigawattsPerLiter).WattsPerCubicMeter, GigawattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromKilowattsPerCubicFoot(wattpercubicmeter.KilowattsPerCubicFoot).WattsPerCubicMeter, KilowattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromKilowattsPerCubicInch(wattpercubicmeter.KilowattsPerCubicInch).WattsPerCubicMeter, KilowattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromKilowattsPerCubicMeter(wattpercubicmeter.KilowattsPerCubicMeter).WattsPerCubicMeter, KilowattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromKilowattsPerLiter(wattpercubicmeter.KilowattsPerLiter).WattsPerCubicMeter, KilowattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMegawattsPerCubicFoot(wattpercubicmeter.MegawattsPerCubicFoot).WattsPerCubicMeter, MegawattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMegawattsPerCubicInch(wattpercubicmeter.MegawattsPerCubicInch).WattsPerCubicMeter, MegawattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMegawattsPerCubicMeter(wattpercubicmeter.MegawattsPerCubicMeter).WattsPerCubicMeter, MegawattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMegawattsPerLiter(wattpercubicmeter.MegawattsPerLiter).WattsPerCubicMeter, MegawattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMicrowattsPerCubicFoot(wattpercubicmeter.MicrowattsPerCubicFoot).WattsPerCubicMeter, MicrowattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMicrowattsPerCubicInch(wattpercubicmeter.MicrowattsPerCubicInch).WattsPerCubicMeter, MicrowattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMicrowattsPerCubicMeter(wattpercubicmeter.MicrowattsPerCubicMeter).WattsPerCubicMeter, MicrowattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMicrowattsPerLiter(wattpercubicmeter.MicrowattsPerLiter).WattsPerCubicMeter, MicrowattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMilliwattsPerCubicFoot(wattpercubicmeter.MilliwattsPerCubicFoot).WattsPerCubicMeter, MilliwattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMilliwattsPerCubicInch(wattpercubicmeter.MilliwattsPerCubicInch).WattsPerCubicMeter, MilliwattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMilliwattsPerCubicMeter(wattpercubicmeter.MilliwattsPerCubicMeter).WattsPerCubicMeter, MilliwattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromMilliwattsPerLiter(wattpercubicmeter.MilliwattsPerLiter).WattsPerCubicMeter, MilliwattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromNanowattsPerCubicFoot(wattpercubicmeter.NanowattsPerCubicFoot).WattsPerCubicMeter, NanowattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromNanowattsPerCubicInch(wattpercubicmeter.NanowattsPerCubicInch).WattsPerCubicMeter, NanowattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromNanowattsPerCubicMeter(wattpercubicmeter.NanowattsPerCubicMeter).WattsPerCubicMeter, NanowattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromNanowattsPerLiter(wattpercubicmeter.NanowattsPerLiter).WattsPerCubicMeter, NanowattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromPicowattsPerCubicFoot(wattpercubicmeter.PicowattsPerCubicFoot).WattsPerCubicMeter, PicowattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromPicowattsPerCubicInch(wattpercubicmeter.PicowattsPerCubicInch).WattsPerCubicMeter, PicowattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromPicowattsPerCubicMeter(wattpercubicmeter.PicowattsPerCubicMeter).WattsPerCubicMeter, PicowattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromPicowattsPerLiter(wattpercubicmeter.PicowattsPerLiter).WattsPerCubicMeter, PicowattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromTerawattsPerCubicFoot(wattpercubicmeter.TerawattsPerCubicFoot).WattsPerCubicMeter, TerawattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromTerawattsPerCubicInch(wattpercubicmeter.TerawattsPerCubicInch).WattsPerCubicMeter, TerawattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromTerawattsPerCubicMeter(wattpercubicmeter.TerawattsPerCubicMeter).WattsPerCubicMeter, TerawattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromTerawattsPerLiter(wattpercubicmeter.TerawattsPerLiter).WattsPerCubicMeter, TerawattsPerLiterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromWattsPerCubicFoot(wattpercubicmeter.WattsPerCubicFoot).WattsPerCubicMeter, WattsPerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromWattsPerCubicInch(wattpercubicmeter.WattsPerCubicInch).WattsPerCubicMeter, WattsPerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromWattsPerCubicMeter(wattpercubicmeter.WattsPerCubicMeter).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, PowerDensity<double>.FromWattsPerLiter(wattpercubicmeter.WattsPerLiter).WattsPerCubicMeter, WattsPerLiterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            PowerDensity v = PowerDensity.FromWattsPerCubicMeter(1);
+            PowerDensity<double> v = PowerDensity<double>.FromWattsPerCubicMeter(1);
             AssertEx.EqualTolerance(-1, -v.WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (PowerDensity.FromWattsPerCubicMeter(3)-v).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (PowerDensity<double>.FromWattsPerCubicMeter(3)-v).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (PowerDensity.FromWattsPerCubicMeter(10)/5).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, PowerDensity.FromWattsPerCubicMeter(10)/PowerDensity.FromWattsPerCubicMeter(5), WattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (PowerDensity<double>.FromWattsPerCubicMeter(10)/5).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, PowerDensity<double>.FromWattsPerCubicMeter(10)/PowerDensity<double>.FromWattsPerCubicMeter(5), WattsPerCubicMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            PowerDensity oneWattPerCubicMeter = PowerDensity.FromWattsPerCubicMeter(1);
-            PowerDensity twoWattsPerCubicMeter = PowerDensity.FromWattsPerCubicMeter(2);
+            PowerDensity<double> oneWattPerCubicMeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
+            PowerDensity<double> twoWattsPerCubicMeter = PowerDensity<double>.FromWattsPerCubicMeter(2);
 
             Assert.True(oneWattPerCubicMeter < twoWattsPerCubicMeter);
             Assert.True(oneWattPerCubicMeter <= twoWattsPerCubicMeter);
@@ -780,31 +780,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            PowerDensity<double> wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
             Assert.Equal(0, wattpercubicmeter.CompareTo(wattpercubicmeter));
-            Assert.True(wattpercubicmeter.CompareTo(PowerDensity.Zero) > 0);
-            Assert.True(PowerDensity.Zero.CompareTo(wattpercubicmeter) < 0);
+            Assert.True(wattpercubicmeter.CompareTo(PowerDensity<double>.Zero) > 0);
+            Assert.True(PowerDensity<double>.Zero.CompareTo(wattpercubicmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            PowerDensity<double> wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
             Assert.Throws<ArgumentException>(() => wattpercubicmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            PowerDensity<double> wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
             Assert.Throws<ArgumentNullException>(() => wattpercubicmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = PowerDensity.FromWattsPerCubicMeter(1);
-            var b = PowerDensity.FromWattsPerCubicMeter(2);
+            var a = PowerDensity<double>.FromWattsPerCubicMeter(1);
+            var b = PowerDensity<double>.FromWattsPerCubicMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -823,8 +823,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = PowerDensity.FromWattsPerCubicMeter(1);
-            var b = PowerDensity.FromWattsPerCubicMeter(2);
+            var a = PowerDensity<double>.FromWattsPerCubicMeter(1);
+            var b = PowerDensity<double>.FromWattsPerCubicMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -844,9 +844,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = PowerDensity.FromWattsPerCubicMeter(1);
-            Assert.True(v.Equals(PowerDensity.FromWattsPerCubicMeter(1), WattsPerCubicMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(PowerDensity.Zero, WattsPerCubicMeterTolerance, ComparisonType.Relative));
+            var v = PowerDensity<double>.FromWattsPerCubicMeter(1);
+            Assert.True(v.Equals(PowerDensity<double>.FromWattsPerCubicMeter(1), WattsPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(PowerDensity<double>.Zero, WattsPerCubicMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -859,21 +859,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            PowerDensity<double> wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
             Assert.False(wattpercubicmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            PowerDensity<double> wattpercubicmeter = PowerDensity<double>.FromWattsPerCubicMeter(1);
             Assert.False(wattpercubicmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(PowerDensityUnit.Undefined, PowerDensity.Units);
+            Assert.DoesNotContain(PowerDensityUnit.Undefined, PowerDensity<double>.Units);
         }
 
         [Fact]
@@ -892,7 +892,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(PowerDensity.BaseDimensions is null);
+            Assert.False(PowerDensity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs
index 15c4a9e82d..94c66313d6 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs
@@ -48,7 +48,7 @@ public abstract partial class PowerRatioTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PowerRatio((double)0.0, PowerRatioUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>((double)0.0, PowerRatioUnit.Undefined));
         }
 
         [Fact]
@@ -63,14 +63,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PowerRatio(double.PositiveInfinity, PowerRatioUnit.DecibelWatt));
-            Assert.Throws<ArgumentException>(() => new PowerRatio(double.NegativeInfinity, PowerRatioUnit.DecibelWatt));
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>(double.PositiveInfinity, PowerRatioUnit.DecibelWatt));
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>(double.NegativeInfinity, PowerRatioUnit.DecibelWatt));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PowerRatio(double.NaN, PowerRatioUnit.DecibelWatt));
+            Assert.Throws<ArgumentException>(() => new PowerRatio<double>(double.NaN, PowerRatioUnit.DecibelWatt));
         }
 
         [Fact]
@@ -116,7 +116,7 @@ public void PowerRatio_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DecibelWattToPowerRatioUnits()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
             AssertEx.EqualTolerance(DecibelMilliwattsInOneDecibelWatt, decibelwatt.DecibelMilliwatts, DecibelMilliwattsTolerance);
             AssertEx.EqualTolerance(DecibelWattsInOneDecibelWatt, decibelwatt.DecibelWatts, DecibelWattsTolerance);
         }
@@ -124,11 +124,11 @@ public void DecibelWattToPowerRatioUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt);
+            var quantity00 = PowerRatio<double>.From(1, PowerRatioUnit.DecibelMilliwatt);
             AssertEx.EqualTolerance(1, quantity00.DecibelMilliwatts, DecibelMilliwattsTolerance);
             Assert.Equal(PowerRatioUnit.DecibelMilliwatt, quantity00.Unit);
 
-            var quantity01 = PowerRatio.From(1, PowerRatioUnit.DecibelWatt);
+            var quantity01 = PowerRatio<double>.From(1, PowerRatioUnit.DecibelWatt);
             AssertEx.EqualTolerance(1, quantity01.DecibelWatts, DecibelWattsTolerance);
             Assert.Equal(PowerRatioUnit.DecibelWatt, quantity01.Unit);
 
@@ -137,20 +137,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDecibelWatts_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => PowerRatio.FromDecibelWatts(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => PowerRatio.FromDecibelWatts(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => PowerRatio<double>.FromDecibelWatts(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => PowerRatio<double>.FromDecibelWatts(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDecibelWatts_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => PowerRatio.FromDecibelWatts(double.NaN));
+            Assert.Throws<ArgumentException>(() => PowerRatio<double>.FromDecibelWatts(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var decibelwatt = PowerRatio.FromDecibelWatts(1);
+            var decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
             AssertEx.EqualTolerance(DecibelMilliwattsInOneDecibelWatt, decibelwatt.As(PowerRatioUnit.DecibelMilliwatt), DecibelMilliwattsTolerance);
             AssertEx.EqualTolerance(DecibelWattsInOneDecibelWatt, decibelwatt.As(PowerRatioUnit.DecibelWatt), DecibelWattsTolerance);
         }
@@ -175,7 +175,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var decibelwatt = PowerRatio.FromDecibelWatts(1);
+            var decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
 
             var decibelmilliwattQuantity = decibelwatt.ToUnit(PowerRatioUnit.DecibelMilliwatt);
             AssertEx.EqualTolerance(DecibelMilliwattsInOneDecibelWatt, (double)decibelmilliwattQuantity.Value, DecibelMilliwattsTolerance);
@@ -196,22 +196,22 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
-            AssertEx.EqualTolerance(1, PowerRatio.FromDecibelMilliwatts(decibelwatt.DecibelMilliwatts).DecibelWatts, DecibelMilliwattsTolerance);
-            AssertEx.EqualTolerance(1, PowerRatio.FromDecibelWatts(decibelwatt.DecibelWatts).DecibelWatts, DecibelWattsTolerance);
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
+            AssertEx.EqualTolerance(1, PowerRatio<double>.FromDecibelMilliwatts(decibelwatt.DecibelMilliwatts).DecibelWatts, DecibelMilliwattsTolerance);
+            AssertEx.EqualTolerance(1, PowerRatio<double>.FromDecibelWatts(decibelwatt.DecibelWatts).DecibelWatts, DecibelWattsTolerance);
         }
 
         [Fact]
         public void LogarithmicArithmeticOperators()
         {
-            PowerRatio v = PowerRatio.FromDecibelWatts(40);
+            PowerRatio<double> v = PowerRatio<double>.FromDecibelWatts(40);
             AssertEx.EqualTolerance(-40, -v.DecibelWatts, DecibelWattsTolerance);
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
             AssertEx.EqualTolerance(50, (v*10).DecibelWatts, DecibelWattsTolerance);
             AssertEx.EqualTolerance(50, (10*v).DecibelWatts, DecibelWattsTolerance);
             AssertEx.EqualTolerance(35, (v/5).DecibelWatts, DecibelWattsTolerance);
-            AssertEx.EqualTolerance(35, v/PowerRatio.FromDecibelWatts(5), DecibelWattsTolerance);
+            AssertEx.EqualTolerance(35, v/PowerRatio<double>.FromDecibelWatts(5), DecibelWattsTolerance);
         }
 
         protected abstract void AssertLogarithmicAddition();
@@ -221,8 +221,8 @@ public void LogarithmicArithmeticOperators()
         [Fact]
         public void ComparisonOperators()
         {
-            PowerRatio oneDecibelWatt = PowerRatio.FromDecibelWatts(1);
-            PowerRatio twoDecibelWatts = PowerRatio.FromDecibelWatts(2);
+            PowerRatio<double> oneDecibelWatt = PowerRatio<double>.FromDecibelWatts(1);
+            PowerRatio<double> twoDecibelWatts = PowerRatio<double>.FromDecibelWatts(2);
 
             Assert.True(oneDecibelWatt < twoDecibelWatts);
             Assert.True(oneDecibelWatt <= twoDecibelWatts);
@@ -238,31 +238,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
             Assert.Equal(0, decibelwatt.CompareTo(decibelwatt));
-            Assert.True(decibelwatt.CompareTo(PowerRatio.Zero) > 0);
-            Assert.True(PowerRatio.Zero.CompareTo(decibelwatt) < 0);
+            Assert.True(decibelwatt.CompareTo(PowerRatio<double>.Zero) > 0);
+            Assert.True(PowerRatio<double>.Zero.CompareTo(decibelwatt) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
             Assert.Throws<ArgumentException>(() => decibelwatt.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
             Assert.Throws<ArgumentNullException>(() => decibelwatt.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = PowerRatio.FromDecibelWatts(1);
-            var b = PowerRatio.FromDecibelWatts(2);
+            var a = PowerRatio<double>.FromDecibelWatts(1);
+            var b = PowerRatio<double>.FromDecibelWatts(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -281,8 +281,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = PowerRatio.FromDecibelWatts(1);
-            var b = PowerRatio.FromDecibelWatts(2);
+            var a = PowerRatio<double>.FromDecibelWatts(1);
+            var b = PowerRatio<double>.FromDecibelWatts(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -302,9 +302,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = PowerRatio.FromDecibelWatts(1);
-            Assert.True(v.Equals(PowerRatio.FromDecibelWatts(1), DecibelWattsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(PowerRatio.Zero, DecibelWattsTolerance, ComparisonType.Relative));
+            var v = PowerRatio<double>.FromDecibelWatts(1);
+            Assert.True(v.Equals(PowerRatio<double>.FromDecibelWatts(1), DecibelWattsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(PowerRatio<double>.Zero, DecibelWattsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -317,21 +317,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
             Assert.False(decibelwatt.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
+            PowerRatio<double> decibelwatt = PowerRatio<double>.FromDecibelWatts(1);
             Assert.False(decibelwatt.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(PowerRatioUnit.Undefined, PowerRatio.Units);
+            Assert.DoesNotContain(PowerRatioUnit.Undefined, PowerRatio<double>.Units);
         }
 
         [Fact]
@@ -350,7 +350,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(PowerRatio.BaseDimensions is null);
+            Assert.False(PowerRatio<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs
index edb1919faf..aa6163f4f6 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs
@@ -94,7 +94,7 @@ public abstract partial class PowerTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Power((decimal)0.0, PowerUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Power<double>((decimal)0.0, PowerUnit.Undefined));
         }
 
         [Fact]
@@ -150,7 +150,7 @@ public void Power_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void WattToPowerUnits()
         {
-            Power watt = Power.FromWatts(1);
+            Power<double> watt = Power<double>.FromWatts(1);
             AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, watt.BoilerHorsepower, BoilerHorsepowerTolerance);
             AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, watt.BritishThermalUnitsPerHour, BritishThermalUnitsPerHourTolerance);
             AssertEx.EqualTolerance(DecawattsInOneWatt, watt.Decawatts, DecawattsTolerance);
@@ -181,103 +181,103 @@ public void WattToPowerUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Power.From(1, PowerUnit.BoilerHorsepower);
+            var quantity00 = Power<double>.From(1, PowerUnit.BoilerHorsepower);
             AssertEx.EqualTolerance(1, quantity00.BoilerHorsepower, BoilerHorsepowerTolerance);
             Assert.Equal(PowerUnit.BoilerHorsepower, quantity00.Unit);
 
-            var quantity01 = Power.From(1, PowerUnit.BritishThermalUnitPerHour);
+            var quantity01 = Power<double>.From(1, PowerUnit.BritishThermalUnitPerHour);
             AssertEx.EqualTolerance(1, quantity01.BritishThermalUnitsPerHour, BritishThermalUnitsPerHourTolerance);
             Assert.Equal(PowerUnit.BritishThermalUnitPerHour, quantity01.Unit);
 
-            var quantity02 = Power.From(1, PowerUnit.Decawatt);
+            var quantity02 = Power<double>.From(1, PowerUnit.Decawatt);
             AssertEx.EqualTolerance(1, quantity02.Decawatts, DecawattsTolerance);
             Assert.Equal(PowerUnit.Decawatt, quantity02.Unit);
 
-            var quantity03 = Power.From(1, PowerUnit.Deciwatt);
+            var quantity03 = Power<double>.From(1, PowerUnit.Deciwatt);
             AssertEx.EqualTolerance(1, quantity03.Deciwatts, DeciwattsTolerance);
             Assert.Equal(PowerUnit.Deciwatt, quantity03.Unit);
 
-            var quantity04 = Power.From(1, PowerUnit.ElectricalHorsepower);
+            var quantity04 = Power<double>.From(1, PowerUnit.ElectricalHorsepower);
             AssertEx.EqualTolerance(1, quantity04.ElectricalHorsepower, ElectricalHorsepowerTolerance);
             Assert.Equal(PowerUnit.ElectricalHorsepower, quantity04.Unit);
 
-            var quantity05 = Power.From(1, PowerUnit.Femtowatt);
+            var quantity05 = Power<double>.From(1, PowerUnit.Femtowatt);
             AssertEx.EqualTolerance(1, quantity05.Femtowatts, FemtowattsTolerance);
             Assert.Equal(PowerUnit.Femtowatt, quantity05.Unit);
 
-            var quantity06 = Power.From(1, PowerUnit.GigajoulePerHour);
+            var quantity06 = Power<double>.From(1, PowerUnit.GigajoulePerHour);
             AssertEx.EqualTolerance(1, quantity06.GigajoulesPerHour, GigajoulesPerHourTolerance);
             Assert.Equal(PowerUnit.GigajoulePerHour, quantity06.Unit);
 
-            var quantity07 = Power.From(1, PowerUnit.Gigawatt);
+            var quantity07 = Power<double>.From(1, PowerUnit.Gigawatt);
             AssertEx.EqualTolerance(1, quantity07.Gigawatts, GigawattsTolerance);
             Assert.Equal(PowerUnit.Gigawatt, quantity07.Unit);
 
-            var quantity08 = Power.From(1, PowerUnit.HydraulicHorsepower);
+            var quantity08 = Power<double>.From(1, PowerUnit.HydraulicHorsepower);
             AssertEx.EqualTolerance(1, quantity08.HydraulicHorsepower, HydraulicHorsepowerTolerance);
             Assert.Equal(PowerUnit.HydraulicHorsepower, quantity08.Unit);
 
-            var quantity09 = Power.From(1, PowerUnit.JoulePerHour);
+            var quantity09 = Power<double>.From(1, PowerUnit.JoulePerHour);
             AssertEx.EqualTolerance(1, quantity09.JoulesPerHour, JoulesPerHourTolerance);
             Assert.Equal(PowerUnit.JoulePerHour, quantity09.Unit);
 
-            var quantity10 = Power.From(1, PowerUnit.KilobritishThermalUnitPerHour);
+            var quantity10 = Power<double>.From(1, PowerUnit.KilobritishThermalUnitPerHour);
             AssertEx.EqualTolerance(1, quantity10.KilobritishThermalUnitsPerHour, KilobritishThermalUnitsPerHourTolerance);
             Assert.Equal(PowerUnit.KilobritishThermalUnitPerHour, quantity10.Unit);
 
-            var quantity11 = Power.From(1, PowerUnit.KilojoulePerHour);
+            var quantity11 = Power<double>.From(1, PowerUnit.KilojoulePerHour);
             AssertEx.EqualTolerance(1, quantity11.KilojoulesPerHour, KilojoulesPerHourTolerance);
             Assert.Equal(PowerUnit.KilojoulePerHour, quantity11.Unit);
 
-            var quantity12 = Power.From(1, PowerUnit.Kilowatt);
+            var quantity12 = Power<double>.From(1, PowerUnit.Kilowatt);
             AssertEx.EqualTolerance(1, quantity12.Kilowatts, KilowattsTolerance);
             Assert.Equal(PowerUnit.Kilowatt, quantity12.Unit);
 
-            var quantity13 = Power.From(1, PowerUnit.MechanicalHorsepower);
+            var quantity13 = Power<double>.From(1, PowerUnit.MechanicalHorsepower);
             AssertEx.EqualTolerance(1, quantity13.MechanicalHorsepower, MechanicalHorsepowerTolerance);
             Assert.Equal(PowerUnit.MechanicalHorsepower, quantity13.Unit);
 
-            var quantity14 = Power.From(1, PowerUnit.MegajoulePerHour);
+            var quantity14 = Power<double>.From(1, PowerUnit.MegajoulePerHour);
             AssertEx.EqualTolerance(1, quantity14.MegajoulesPerHour, MegajoulesPerHourTolerance);
             Assert.Equal(PowerUnit.MegajoulePerHour, quantity14.Unit);
 
-            var quantity15 = Power.From(1, PowerUnit.Megawatt);
+            var quantity15 = Power<double>.From(1, PowerUnit.Megawatt);
             AssertEx.EqualTolerance(1, quantity15.Megawatts, MegawattsTolerance);
             Assert.Equal(PowerUnit.Megawatt, quantity15.Unit);
 
-            var quantity16 = Power.From(1, PowerUnit.MetricHorsepower);
+            var quantity16 = Power<double>.From(1, PowerUnit.MetricHorsepower);
             AssertEx.EqualTolerance(1, quantity16.MetricHorsepower, MetricHorsepowerTolerance);
             Assert.Equal(PowerUnit.MetricHorsepower, quantity16.Unit);
 
-            var quantity17 = Power.From(1, PowerUnit.Microwatt);
+            var quantity17 = Power<double>.From(1, PowerUnit.Microwatt);
             AssertEx.EqualTolerance(1, quantity17.Microwatts, MicrowattsTolerance);
             Assert.Equal(PowerUnit.Microwatt, quantity17.Unit);
 
-            var quantity18 = Power.From(1, PowerUnit.MillijoulePerHour);
+            var quantity18 = Power<double>.From(1, PowerUnit.MillijoulePerHour);
             AssertEx.EqualTolerance(1, quantity18.MillijoulesPerHour, MillijoulesPerHourTolerance);
             Assert.Equal(PowerUnit.MillijoulePerHour, quantity18.Unit);
 
-            var quantity19 = Power.From(1, PowerUnit.Milliwatt);
+            var quantity19 = Power<double>.From(1, PowerUnit.Milliwatt);
             AssertEx.EqualTolerance(1, quantity19.Milliwatts, MilliwattsTolerance);
             Assert.Equal(PowerUnit.Milliwatt, quantity19.Unit);
 
-            var quantity20 = Power.From(1, PowerUnit.Nanowatt);
+            var quantity20 = Power<double>.From(1, PowerUnit.Nanowatt);
             AssertEx.EqualTolerance(1, quantity20.Nanowatts, NanowattsTolerance);
             Assert.Equal(PowerUnit.Nanowatt, quantity20.Unit);
 
-            var quantity21 = Power.From(1, PowerUnit.Petawatt);
+            var quantity21 = Power<double>.From(1, PowerUnit.Petawatt);
             AssertEx.EqualTolerance(1, quantity21.Petawatts, PetawattsTolerance);
             Assert.Equal(PowerUnit.Petawatt, quantity21.Unit);
 
-            var quantity22 = Power.From(1, PowerUnit.Picowatt);
+            var quantity22 = Power<double>.From(1, PowerUnit.Picowatt);
             AssertEx.EqualTolerance(1, quantity22.Picowatts, PicowattsTolerance);
             Assert.Equal(PowerUnit.Picowatt, quantity22.Unit);
 
-            var quantity23 = Power.From(1, PowerUnit.Terawatt);
+            var quantity23 = Power<double>.From(1, PowerUnit.Terawatt);
             AssertEx.EqualTolerance(1, quantity23.Terawatts, TerawattsTolerance);
             Assert.Equal(PowerUnit.Terawatt, quantity23.Unit);
 
-            var quantity24 = Power.From(1, PowerUnit.Watt);
+            var quantity24 = Power<double>.From(1, PowerUnit.Watt);
             AssertEx.EqualTolerance(1, quantity24.Watts, WattsTolerance);
             Assert.Equal(PowerUnit.Watt, quantity24.Unit);
 
@@ -286,7 +286,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void As()
         {
-            var watt = Power.FromWatts(1);
+            var watt = Power<double>.FromWatts(1);
             AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, watt.As(PowerUnit.BoilerHorsepower), BoilerHorsepowerTolerance);
             AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, watt.As(PowerUnit.BritishThermalUnitPerHour), BritishThermalUnitsPerHourTolerance);
             AssertEx.EqualTolerance(DecawattsInOneWatt, watt.As(PowerUnit.Decawatt), DecawattsTolerance);
@@ -334,7 +334,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var watt = Power.FromWatts(1);
+            var watt = Power<double>.FromWatts(1);
 
             var boilerhorsepowerQuantity = watt.ToUnit(PowerUnit.BoilerHorsepower);
             AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, (double)boilerhorsepowerQuantity.Value, BoilerHorsepowerTolerance);
@@ -447,52 +447,52 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Power watt = Power.FromWatts(1);
-            AssertEx.EqualTolerance(1, Power.FromBoilerHorsepower(watt.BoilerHorsepower).Watts, BoilerHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromBritishThermalUnitsPerHour(watt.BritishThermalUnitsPerHour).Watts, BritishThermalUnitsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromElectricalHorsepower(watt.ElectricalHorsepower).Watts, ElectricalHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromGigajoulesPerHour(watt.GigajoulesPerHour).Watts, GigajoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromHydraulicHorsepower(watt.HydraulicHorsepower).Watts, HydraulicHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromJoulesPerHour(watt.JoulesPerHour).Watts, JoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromKilobritishThermalUnitsPerHour(watt.KilobritishThermalUnitsPerHour).Watts, KilobritishThermalUnitsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromKilojoulesPerHour(watt.KilojoulesPerHour).Watts, KilojoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMechanicalHorsepower(watt.MechanicalHorsepower).Watts, MechanicalHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMegajoulesPerHour(watt.MegajoulesPerHour).Watts, MegajoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMetricHorsepower(watt.MetricHorsepower).Watts, MetricHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMillijoulesPerHour(watt.MillijoulesPerHour).Watts, MillijoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromWatts(watt.Watts).Watts, WattsTolerance);
+            Power<double> watt = Power<double>.FromWatts(1);
+            AssertEx.EqualTolerance(1, Power<double>.FromBoilerHorsepower(watt.BoilerHorsepower).Watts, BoilerHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromBritishThermalUnitsPerHour(watt.BritishThermalUnitsPerHour).Watts, BritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromElectricalHorsepower(watt.ElectricalHorsepower).Watts, ElectricalHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromGigajoulesPerHour(watt.GigajoulesPerHour).Watts, GigajoulesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromHydraulicHorsepower(watt.HydraulicHorsepower).Watts, HydraulicHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromJoulesPerHour(watt.JoulesPerHour).Watts, JoulesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromKilobritishThermalUnitsPerHour(watt.KilobritishThermalUnitsPerHour).Watts, KilobritishThermalUnitsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromKilojoulesPerHour(watt.KilojoulesPerHour).Watts, KilojoulesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMechanicalHorsepower(watt.MechanicalHorsepower).Watts, MechanicalHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMegajoulesPerHour(watt.MegajoulesPerHour).Watts, MegajoulesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMetricHorsepower(watt.MetricHorsepower).Watts, MetricHorsepowerTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMillijoulesPerHour(watt.MillijoulesPerHour).Watts, MillijoulesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
+            AssertEx.EqualTolerance(1, Power<double>.FromWatts(watt.Watts).Watts, WattsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Power v = Power.FromWatts(1);
+            Power<double> v = Power<double>.FromWatts(1);
             AssertEx.EqualTolerance(-1, -v.Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Power.FromWatts(3)-v).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, (Power<double>.FromWatts(3)-v).Watts, WattsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Watts, WattsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Watts, WattsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Power.FromWatts(10)/5).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, Power.FromWatts(10)/Power.FromWatts(5), WattsTolerance);
+            AssertEx.EqualTolerance(2, (Power<double>.FromWatts(10)/5).Watts, WattsTolerance);
+            AssertEx.EqualTolerance(2, Power<double>.FromWatts(10)/Power<double>.FromWatts(5), WattsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Power oneWatt = Power.FromWatts(1);
-            Power twoWatts = Power.FromWatts(2);
+            Power<double> oneWatt = Power<double>.FromWatts(1);
+            Power<double> twoWatts = Power<double>.FromWatts(2);
 
             Assert.True(oneWatt < twoWatts);
             Assert.True(oneWatt <= twoWatts);
@@ -508,31 +508,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Power watt = Power.FromWatts(1);
+            Power<double> watt = Power<double>.FromWatts(1);
             Assert.Equal(0, watt.CompareTo(watt));
-            Assert.True(watt.CompareTo(Power.Zero) > 0);
-            Assert.True(Power.Zero.CompareTo(watt) < 0);
+            Assert.True(watt.CompareTo(Power<double>.Zero) > 0);
+            Assert.True(Power<double>.Zero.CompareTo(watt) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Power watt = Power.FromWatts(1);
+            Power<double> watt = Power<double>.FromWatts(1);
             Assert.Throws<ArgumentException>(() => watt.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Power watt = Power.FromWatts(1);
+            Power<double> watt = Power<double>.FromWatts(1);
             Assert.Throws<ArgumentNullException>(() => watt.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Power.FromWatts(1);
-            var b = Power.FromWatts(2);
+            var a = Power<double>.FromWatts(1);
+            var b = Power<double>.FromWatts(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -551,8 +551,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Power.FromWatts(1);
-            var b = Power.FromWatts(2);
+            var a = Power<double>.FromWatts(1);
+            var b = Power<double>.FromWatts(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -572,9 +572,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Power.FromWatts(1);
-            Assert.True(v.Equals(Power.FromWatts(1), WattsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Power.Zero, WattsTolerance, ComparisonType.Relative));
+            var v = Power<double>.FromWatts(1);
+            Assert.True(v.Equals(Power<double>.FromWatts(1), WattsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Power<double>.Zero, WattsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -587,21 +587,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Power watt = Power.FromWatts(1);
+            Power<double> watt = Power<double>.FromWatts(1);
             Assert.False(watt.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Power watt = Power.FromWatts(1);
+            Power<double> watt = Power<double>.FromWatts(1);
             Assert.False(watt.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(PowerUnit.Undefined, Power.Units);
+            Assert.DoesNotContain(PowerUnit.Undefined, Power<double>.Units);
         }
 
         [Fact]
@@ -620,7 +620,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Power.BaseDimensions is null);
+            Assert.False(Power<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs
index e75af9d61b..fdd7d4d575 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs
@@ -58,7 +58,7 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PressureChangeRate((double)0.0, PressureChangeRateUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>((double)0.0, PressureChangeRateUnit.Undefined));
         }
 
         [Fact]
@@ -73,14 +73,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PressureChangeRate(double.PositiveInfinity, PressureChangeRateUnit.PascalPerSecond));
-            Assert.Throws<ArgumentException>(() => new PressureChangeRate(double.NegativeInfinity, PressureChangeRateUnit.PascalPerSecond));
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>(double.PositiveInfinity, PressureChangeRateUnit.PascalPerSecond));
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>(double.NegativeInfinity, PressureChangeRateUnit.PascalPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new PressureChangeRate(double.NaN, PressureChangeRateUnit.PascalPerSecond));
+            Assert.Throws<ArgumentException>(() => new PressureChangeRate<double>(double.NaN, PressureChangeRateUnit.PascalPerSecond));
         }
 
         [Fact]
@@ -126,7 +126,7 @@ public void PressureChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
         [Fact]
         public void PascalPerSecondToPressureChangeRateUnits()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
             AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.AtmospheresPerSecond, AtmospheresPerSecondTolerance);
             AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.KilopascalsPerMinute, KilopascalsPerMinuteTolerance);
             AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.KilopascalsPerSecond, KilopascalsPerSecondTolerance);
@@ -139,31 +139,31 @@ public void PascalPerSecondToPressureChangeRateUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond);
+            var quantity00 = PressureChangeRate<double>.From(1, PressureChangeRateUnit.AtmospherePerSecond);
             AssertEx.EqualTolerance(1, quantity00.AtmospheresPerSecond, AtmospheresPerSecondTolerance);
             Assert.Equal(PressureChangeRateUnit.AtmospherePerSecond, quantity00.Unit);
 
-            var quantity01 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerMinute);
+            var quantity01 = PressureChangeRate<double>.From(1, PressureChangeRateUnit.KilopascalPerMinute);
             AssertEx.EqualTolerance(1, quantity01.KilopascalsPerMinute, KilopascalsPerMinuteTolerance);
             Assert.Equal(PressureChangeRateUnit.KilopascalPerMinute, quantity01.Unit);
 
-            var quantity02 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond);
+            var quantity02 = PressureChangeRate<double>.From(1, PressureChangeRateUnit.KilopascalPerSecond);
             AssertEx.EqualTolerance(1, quantity02.KilopascalsPerSecond, KilopascalsPerSecondTolerance);
             Assert.Equal(PressureChangeRateUnit.KilopascalPerSecond, quantity02.Unit);
 
-            var quantity03 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerMinute);
+            var quantity03 = PressureChangeRate<double>.From(1, PressureChangeRateUnit.MegapascalPerMinute);
             AssertEx.EqualTolerance(1, quantity03.MegapascalsPerMinute, MegapascalsPerMinuteTolerance);
             Assert.Equal(PressureChangeRateUnit.MegapascalPerMinute, quantity03.Unit);
 
-            var quantity04 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond);
+            var quantity04 = PressureChangeRate<double>.From(1, PressureChangeRateUnit.MegapascalPerSecond);
             AssertEx.EqualTolerance(1, quantity04.MegapascalsPerSecond, MegapascalsPerSecondTolerance);
             Assert.Equal(PressureChangeRateUnit.MegapascalPerSecond, quantity04.Unit);
 
-            var quantity05 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerMinute);
+            var quantity05 = PressureChangeRate<double>.From(1, PressureChangeRateUnit.PascalPerMinute);
             AssertEx.EqualTolerance(1, quantity05.PascalsPerMinute, PascalsPerMinuteTolerance);
             Assert.Equal(PressureChangeRateUnit.PascalPerMinute, quantity05.Unit);
 
-            var quantity06 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond);
+            var quantity06 = PressureChangeRate<double>.From(1, PressureChangeRateUnit.PascalPerSecond);
             AssertEx.EqualTolerance(1, quantity06.PascalsPerSecond, PascalsPerSecondTolerance);
             Assert.Equal(PressureChangeRateUnit.PascalPerSecond, quantity06.Unit);
 
@@ -172,20 +172,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromPascalsPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => PressureChangeRate.FromPascalsPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => PressureChangeRate.FromPascalsPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => PressureChangeRate<double>.FromPascalsPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => PressureChangeRate<double>.FromPascalsPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromPascalsPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => PressureChangeRate.FromPascalsPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => PressureChangeRate<double>.FromPascalsPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            var pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
             AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.AtmospherePerSecond), AtmospheresPerSecondTolerance);
             AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerMinute), KilopascalsPerMinuteTolerance);
             AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerSecond), KilopascalsPerSecondTolerance);
@@ -215,7 +215,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            var pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
 
             var atmospherepersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.AtmospherePerSecond);
             AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, (double)atmospherepersecondQuantity.Value, AtmospheresPerSecondTolerance);
@@ -256,34 +256,34 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromAtmospheresPerSecond(pascalpersecond.AtmospheresPerSecond).PascalsPerSecond, AtmospheresPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerMinute(pascalpersecond.KilopascalsPerMinute).PascalsPerSecond, KilopascalsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerSecond(pascalpersecond.KilopascalsPerSecond).PascalsPerSecond, KilopascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapascalsPerMinute(pascalpersecond.MegapascalsPerMinute).PascalsPerSecond, MegapascalsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapascalsPerSecond(pascalpersecond.MegapascalsPerSecond).PascalsPerSecond, MegapascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerMinute(pascalpersecond.PascalsPerMinute).PascalsPerSecond, PascalsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerSecond(pascalpersecond.PascalsPerSecond).PascalsPerSecond, PascalsPerSecondTolerance);
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromAtmospheresPerSecond(pascalpersecond.AtmospheresPerSecond).PascalsPerSecond, AtmospheresPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromKilopascalsPerMinute(pascalpersecond.KilopascalsPerMinute).PascalsPerSecond, KilopascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromKilopascalsPerSecond(pascalpersecond.KilopascalsPerSecond).PascalsPerSecond, KilopascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromMegapascalsPerMinute(pascalpersecond.MegapascalsPerMinute).PascalsPerSecond, MegapascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromMegapascalsPerSecond(pascalpersecond.MegapascalsPerSecond).PascalsPerSecond, MegapascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromPascalsPerMinute(pascalpersecond.PascalsPerMinute).PascalsPerSecond, PascalsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, PressureChangeRate<double>.FromPascalsPerSecond(pascalpersecond.PascalsPerSecond).PascalsPerSecond, PascalsPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            PressureChangeRate v = PressureChangeRate.FromPascalsPerSecond(1);
+            PressureChangeRate<double> v = PressureChangeRate<double>.FromPascalsPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (PressureChangeRate.FromPascalsPerSecond(3)-v).PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (PressureChangeRate<double>.FromPascalsPerSecond(3)-v).PascalsPerSecond, PascalsPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).PascalsPerSecond, PascalsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).PascalsPerSecond, PascalsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (PressureChangeRate.FromPascalsPerSecond(10)/5).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, PressureChangeRate.FromPascalsPerSecond(10)/PressureChangeRate.FromPascalsPerSecond(5), PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (PressureChangeRate<double>.FromPascalsPerSecond(10)/5).PascalsPerSecond, PascalsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, PressureChangeRate<double>.FromPascalsPerSecond(10)/PressureChangeRate<double>.FromPascalsPerSecond(5), PascalsPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            PressureChangeRate onePascalPerSecond = PressureChangeRate.FromPascalsPerSecond(1);
-            PressureChangeRate twoPascalsPerSecond = PressureChangeRate.FromPascalsPerSecond(2);
+            PressureChangeRate<double> onePascalPerSecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            PressureChangeRate<double> twoPascalsPerSecond = PressureChangeRate<double>.FromPascalsPerSecond(2);
 
             Assert.True(onePascalPerSecond < twoPascalsPerSecond);
             Assert.True(onePascalPerSecond <= twoPascalsPerSecond);
@@ -299,31 +299,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
             Assert.Equal(0, pascalpersecond.CompareTo(pascalpersecond));
-            Assert.True(pascalpersecond.CompareTo(PressureChangeRate.Zero) > 0);
-            Assert.True(PressureChangeRate.Zero.CompareTo(pascalpersecond) < 0);
+            Assert.True(pascalpersecond.CompareTo(PressureChangeRate<double>.Zero) > 0);
+            Assert.True(PressureChangeRate<double>.Zero.CompareTo(pascalpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
             Assert.Throws<ArgumentException>(() => pascalpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => pascalpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = PressureChangeRate.FromPascalsPerSecond(1);
-            var b = PressureChangeRate.FromPascalsPerSecond(2);
+            var a = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            var b = PressureChangeRate<double>.FromPascalsPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -342,8 +342,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = PressureChangeRate.FromPascalsPerSecond(1);
-            var b = PressureChangeRate.FromPascalsPerSecond(2);
+            var a = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            var b = PressureChangeRate<double>.FromPascalsPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -363,9 +363,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = PressureChangeRate.FromPascalsPerSecond(1);
-            Assert.True(v.Equals(PressureChangeRate.FromPascalsPerSecond(1), PascalsPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(PressureChangeRate.Zero, PascalsPerSecondTolerance, ComparisonType.Relative));
+            var v = PressureChangeRate<double>.FromPascalsPerSecond(1);
+            Assert.True(v.Equals(PressureChangeRate<double>.FromPascalsPerSecond(1), PascalsPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(PressureChangeRate<double>.Zero, PascalsPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -378,21 +378,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
             Assert.False(pascalpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
+            PressureChangeRate<double> pascalpersecond = PressureChangeRate<double>.FromPascalsPerSecond(1);
             Assert.False(pascalpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(PressureChangeRateUnit.Undefined, PressureChangeRate.Units);
+            Assert.DoesNotContain(PressureChangeRateUnit.Undefined, PressureChangeRate<double>.Units);
         }
 
         [Fact]
@@ -411,7 +411,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(PressureChangeRate.BaseDimensions is null);
+            Assert.False(PressureChangeRate<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs
index 62b97ce04c..95338bb278 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs
@@ -128,7 +128,7 @@ public abstract partial class PressureTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Pressure((double)0.0, PressureUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Pressure<double>((double)0.0, PressureUnit.Undefined));
         }
 
         [Fact]
@@ -143,14 +143,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Pressure(double.PositiveInfinity, PressureUnit.Pascal));
-            Assert.Throws<ArgumentException>(() => new Pressure(double.NegativeInfinity, PressureUnit.Pascal));
+            Assert.Throws<ArgumentException>(() => new Pressure<double>(double.PositiveInfinity, PressureUnit.Pascal));
+            Assert.Throws<ArgumentException>(() => new Pressure<double>(double.NegativeInfinity, PressureUnit.Pascal));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Pressure(double.NaN, PressureUnit.Pascal));
+            Assert.Throws<ArgumentException>(() => new Pressure<double>(double.NaN, PressureUnit.Pascal));
         }
 
         [Fact]
@@ -196,7 +196,7 @@ public void Pressure_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void PascalToPressureUnits()
         {
-            Pressure pascal = Pressure.FromPascals(1);
+            Pressure<double> pascal = Pressure<double>.FromPascals(1);
             AssertEx.EqualTolerance(AtmospheresInOnePascal, pascal.Atmospheres, AtmospheresTolerance);
             AssertEx.EqualTolerance(BarsInOnePascal, pascal.Bars, BarsTolerance);
             AssertEx.EqualTolerance(CentibarsInOnePascal, pascal.Centibars, CentibarsTolerance);
@@ -244,171 +244,171 @@ public void PascalToPressureUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Pressure.From(1, PressureUnit.Atmosphere);
+            var quantity00 = Pressure<double>.From(1, PressureUnit.Atmosphere);
             AssertEx.EqualTolerance(1, quantity00.Atmospheres, AtmospheresTolerance);
             Assert.Equal(PressureUnit.Atmosphere, quantity00.Unit);
 
-            var quantity01 = Pressure.From(1, PressureUnit.Bar);
+            var quantity01 = Pressure<double>.From(1, PressureUnit.Bar);
             AssertEx.EqualTolerance(1, quantity01.Bars, BarsTolerance);
             Assert.Equal(PressureUnit.Bar, quantity01.Unit);
 
-            var quantity02 = Pressure.From(1, PressureUnit.Centibar);
+            var quantity02 = Pressure<double>.From(1, PressureUnit.Centibar);
             AssertEx.EqualTolerance(1, quantity02.Centibars, CentibarsTolerance);
             Assert.Equal(PressureUnit.Centibar, quantity02.Unit);
 
-            var quantity03 = Pressure.From(1, PressureUnit.Decapascal);
+            var quantity03 = Pressure<double>.From(1, PressureUnit.Decapascal);
             AssertEx.EqualTolerance(1, quantity03.Decapascals, DecapascalsTolerance);
             Assert.Equal(PressureUnit.Decapascal, quantity03.Unit);
 
-            var quantity04 = Pressure.From(1, PressureUnit.Decibar);
+            var quantity04 = Pressure<double>.From(1, PressureUnit.Decibar);
             AssertEx.EqualTolerance(1, quantity04.Decibars, DecibarsTolerance);
             Assert.Equal(PressureUnit.Decibar, quantity04.Unit);
 
-            var quantity05 = Pressure.From(1, PressureUnit.DynePerSquareCentimeter);
+            var quantity05 = Pressure<double>.From(1, PressureUnit.DynePerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity05.DynesPerSquareCentimeter, DynesPerSquareCentimeterTolerance);
             Assert.Equal(PressureUnit.DynePerSquareCentimeter, quantity05.Unit);
 
-            var quantity06 = Pressure.From(1, PressureUnit.FootOfHead);
+            var quantity06 = Pressure<double>.From(1, PressureUnit.FootOfHead);
             AssertEx.EqualTolerance(1, quantity06.FeetOfHead, FeetOfHeadTolerance);
             Assert.Equal(PressureUnit.FootOfHead, quantity06.Unit);
 
-            var quantity07 = Pressure.From(1, PressureUnit.Gigapascal);
+            var quantity07 = Pressure<double>.From(1, PressureUnit.Gigapascal);
             AssertEx.EqualTolerance(1, quantity07.Gigapascals, GigapascalsTolerance);
             Assert.Equal(PressureUnit.Gigapascal, quantity07.Unit);
 
-            var quantity08 = Pressure.From(1, PressureUnit.Hectopascal);
+            var quantity08 = Pressure<double>.From(1, PressureUnit.Hectopascal);
             AssertEx.EqualTolerance(1, quantity08.Hectopascals, HectopascalsTolerance);
             Assert.Equal(PressureUnit.Hectopascal, quantity08.Unit);
 
-            var quantity09 = Pressure.From(1, PressureUnit.InchOfMercury);
+            var quantity09 = Pressure<double>.From(1, PressureUnit.InchOfMercury);
             AssertEx.EqualTolerance(1, quantity09.InchesOfMercury, InchesOfMercuryTolerance);
             Assert.Equal(PressureUnit.InchOfMercury, quantity09.Unit);
 
-            var quantity10 = Pressure.From(1, PressureUnit.InchOfWaterColumn);
+            var quantity10 = Pressure<double>.From(1, PressureUnit.InchOfWaterColumn);
             AssertEx.EqualTolerance(1, quantity10.InchesOfWaterColumn, InchesOfWaterColumnTolerance);
             Assert.Equal(PressureUnit.InchOfWaterColumn, quantity10.Unit);
 
-            var quantity11 = Pressure.From(1, PressureUnit.Kilobar);
+            var quantity11 = Pressure<double>.From(1, PressureUnit.Kilobar);
             AssertEx.EqualTolerance(1, quantity11.Kilobars, KilobarsTolerance);
             Assert.Equal(PressureUnit.Kilobar, quantity11.Unit);
 
-            var quantity12 = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter);
+            var quantity12 = Pressure<double>.From(1, PressureUnit.KilogramForcePerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity12.KilogramsForcePerSquareCentimeter, KilogramsForcePerSquareCentimeterTolerance);
             Assert.Equal(PressureUnit.KilogramForcePerSquareCentimeter, quantity12.Unit);
 
-            var quantity13 = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter);
+            var quantity13 = Pressure<double>.From(1, PressureUnit.KilogramForcePerSquareMeter);
             AssertEx.EqualTolerance(1, quantity13.KilogramsForcePerSquareMeter, KilogramsForcePerSquareMeterTolerance);
             Assert.Equal(PressureUnit.KilogramForcePerSquareMeter, quantity13.Unit);
 
-            var quantity14 = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter);
+            var quantity14 = Pressure<double>.From(1, PressureUnit.KilogramForcePerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity14.KilogramsForcePerSquareMillimeter, KilogramsForcePerSquareMillimeterTolerance);
             Assert.Equal(PressureUnit.KilogramForcePerSquareMillimeter, quantity14.Unit);
 
-            var quantity15 = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter);
+            var quantity15 = Pressure<double>.From(1, PressureUnit.KilonewtonPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity15.KilonewtonsPerSquareCentimeter, KilonewtonsPerSquareCentimeterTolerance);
             Assert.Equal(PressureUnit.KilonewtonPerSquareCentimeter, quantity15.Unit);
 
-            var quantity16 = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter);
+            var quantity16 = Pressure<double>.From(1, PressureUnit.KilonewtonPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity16.KilonewtonsPerSquareMeter, KilonewtonsPerSquareMeterTolerance);
             Assert.Equal(PressureUnit.KilonewtonPerSquareMeter, quantity16.Unit);
 
-            var quantity17 = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter);
+            var quantity17 = Pressure<double>.From(1, PressureUnit.KilonewtonPerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity17.KilonewtonsPerSquareMillimeter, KilonewtonsPerSquareMillimeterTolerance);
             Assert.Equal(PressureUnit.KilonewtonPerSquareMillimeter, quantity17.Unit);
 
-            var quantity18 = Pressure.From(1, PressureUnit.Kilopascal);
+            var quantity18 = Pressure<double>.From(1, PressureUnit.Kilopascal);
             AssertEx.EqualTolerance(1, quantity18.Kilopascals, KilopascalsTolerance);
             Assert.Equal(PressureUnit.Kilopascal, quantity18.Unit);
 
-            var quantity19 = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot);
+            var quantity19 = Pressure<double>.From(1, PressureUnit.KilopoundForcePerSquareFoot);
             AssertEx.EqualTolerance(1, quantity19.KilopoundsForcePerSquareFoot, KilopoundsForcePerSquareFootTolerance);
             Assert.Equal(PressureUnit.KilopoundForcePerSquareFoot, quantity19.Unit);
 
-            var quantity20 = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch);
+            var quantity20 = Pressure<double>.From(1, PressureUnit.KilopoundForcePerSquareInch);
             AssertEx.EqualTolerance(1, quantity20.KilopoundsForcePerSquareInch, KilopoundsForcePerSquareInchTolerance);
             Assert.Equal(PressureUnit.KilopoundForcePerSquareInch, quantity20.Unit);
 
-            var quantity21 = Pressure.From(1, PressureUnit.Megabar);
+            var quantity21 = Pressure<double>.From(1, PressureUnit.Megabar);
             AssertEx.EqualTolerance(1, quantity21.Megabars, MegabarsTolerance);
             Assert.Equal(PressureUnit.Megabar, quantity21.Unit);
 
-            var quantity22 = Pressure.From(1, PressureUnit.MeganewtonPerSquareMeter);
+            var quantity22 = Pressure<double>.From(1, PressureUnit.MeganewtonPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity22.MeganewtonsPerSquareMeter, MeganewtonsPerSquareMeterTolerance);
             Assert.Equal(PressureUnit.MeganewtonPerSquareMeter, quantity22.Unit);
 
-            var quantity23 = Pressure.From(1, PressureUnit.Megapascal);
+            var quantity23 = Pressure<double>.From(1, PressureUnit.Megapascal);
             AssertEx.EqualTolerance(1, quantity23.Megapascals, MegapascalsTolerance);
             Assert.Equal(PressureUnit.Megapascal, quantity23.Unit);
 
-            var quantity24 = Pressure.From(1, PressureUnit.MeterOfHead);
+            var quantity24 = Pressure<double>.From(1, PressureUnit.MeterOfHead);
             AssertEx.EqualTolerance(1, quantity24.MetersOfHead, MetersOfHeadTolerance);
             Assert.Equal(PressureUnit.MeterOfHead, quantity24.Unit);
 
-            var quantity25 = Pressure.From(1, PressureUnit.Microbar);
+            var quantity25 = Pressure<double>.From(1, PressureUnit.Microbar);
             AssertEx.EqualTolerance(1, quantity25.Microbars, MicrobarsTolerance);
             Assert.Equal(PressureUnit.Microbar, quantity25.Unit);
 
-            var quantity26 = Pressure.From(1, PressureUnit.Micropascal);
+            var quantity26 = Pressure<double>.From(1, PressureUnit.Micropascal);
             AssertEx.EqualTolerance(1, quantity26.Micropascals, MicropascalsTolerance);
             Assert.Equal(PressureUnit.Micropascal, quantity26.Unit);
 
-            var quantity27 = Pressure.From(1, PressureUnit.Millibar);
+            var quantity27 = Pressure<double>.From(1, PressureUnit.Millibar);
             AssertEx.EqualTolerance(1, quantity27.Millibars, MillibarsTolerance);
             Assert.Equal(PressureUnit.Millibar, quantity27.Unit);
 
-            var quantity28 = Pressure.From(1, PressureUnit.MillimeterOfMercury);
+            var quantity28 = Pressure<double>.From(1, PressureUnit.MillimeterOfMercury);
             AssertEx.EqualTolerance(1, quantity28.MillimetersOfMercury, MillimetersOfMercuryTolerance);
             Assert.Equal(PressureUnit.MillimeterOfMercury, quantity28.Unit);
 
-            var quantity29 = Pressure.From(1, PressureUnit.Millipascal);
+            var quantity29 = Pressure<double>.From(1, PressureUnit.Millipascal);
             AssertEx.EqualTolerance(1, quantity29.Millipascals, MillipascalsTolerance);
             Assert.Equal(PressureUnit.Millipascal, quantity29.Unit);
 
-            var quantity30 = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter);
+            var quantity30 = Pressure<double>.From(1, PressureUnit.NewtonPerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity30.NewtonsPerSquareCentimeter, NewtonsPerSquareCentimeterTolerance);
             Assert.Equal(PressureUnit.NewtonPerSquareCentimeter, quantity30.Unit);
 
-            var quantity31 = Pressure.From(1, PressureUnit.NewtonPerSquareMeter);
+            var quantity31 = Pressure<double>.From(1, PressureUnit.NewtonPerSquareMeter);
             AssertEx.EqualTolerance(1, quantity31.NewtonsPerSquareMeter, NewtonsPerSquareMeterTolerance);
             Assert.Equal(PressureUnit.NewtonPerSquareMeter, quantity31.Unit);
 
-            var quantity32 = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter);
+            var quantity32 = Pressure<double>.From(1, PressureUnit.NewtonPerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity32.NewtonsPerSquareMillimeter, NewtonsPerSquareMillimeterTolerance);
             Assert.Equal(PressureUnit.NewtonPerSquareMillimeter, quantity32.Unit);
 
-            var quantity33 = Pressure.From(1, PressureUnit.Pascal);
+            var quantity33 = Pressure<double>.From(1, PressureUnit.Pascal);
             AssertEx.EqualTolerance(1, quantity33.Pascals, PascalsTolerance);
             Assert.Equal(PressureUnit.Pascal, quantity33.Unit);
 
-            var quantity34 = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot);
+            var quantity34 = Pressure<double>.From(1, PressureUnit.PoundForcePerSquareFoot);
             AssertEx.EqualTolerance(1, quantity34.PoundsForcePerSquareFoot, PoundsForcePerSquareFootTolerance);
             Assert.Equal(PressureUnit.PoundForcePerSquareFoot, quantity34.Unit);
 
-            var quantity35 = Pressure.From(1, PressureUnit.PoundForcePerSquareInch);
+            var quantity35 = Pressure<double>.From(1, PressureUnit.PoundForcePerSquareInch);
             AssertEx.EqualTolerance(1, quantity35.PoundsForcePerSquareInch, PoundsForcePerSquareInchTolerance);
             Assert.Equal(PressureUnit.PoundForcePerSquareInch, quantity35.Unit);
 
-            var quantity36 = Pressure.From(1, PressureUnit.PoundPerInchSecondSquared);
+            var quantity36 = Pressure<double>.From(1, PressureUnit.PoundPerInchSecondSquared);
             AssertEx.EqualTolerance(1, quantity36.PoundsPerInchSecondSquared, PoundsPerInchSecondSquaredTolerance);
             Assert.Equal(PressureUnit.PoundPerInchSecondSquared, quantity36.Unit);
 
-            var quantity37 = Pressure.From(1, PressureUnit.TechnicalAtmosphere);
+            var quantity37 = Pressure<double>.From(1, PressureUnit.TechnicalAtmosphere);
             AssertEx.EqualTolerance(1, quantity37.TechnicalAtmospheres, TechnicalAtmospheresTolerance);
             Assert.Equal(PressureUnit.TechnicalAtmosphere, quantity37.Unit);
 
-            var quantity38 = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter);
+            var quantity38 = Pressure<double>.From(1, PressureUnit.TonneForcePerSquareCentimeter);
             AssertEx.EqualTolerance(1, quantity38.TonnesForcePerSquareCentimeter, TonnesForcePerSquareCentimeterTolerance);
             Assert.Equal(PressureUnit.TonneForcePerSquareCentimeter, quantity38.Unit);
 
-            var quantity39 = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter);
+            var quantity39 = Pressure<double>.From(1, PressureUnit.TonneForcePerSquareMeter);
             AssertEx.EqualTolerance(1, quantity39.TonnesForcePerSquareMeter, TonnesForcePerSquareMeterTolerance);
             Assert.Equal(PressureUnit.TonneForcePerSquareMeter, quantity39.Unit);
 
-            var quantity40 = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter);
+            var quantity40 = Pressure<double>.From(1, PressureUnit.TonneForcePerSquareMillimeter);
             AssertEx.EqualTolerance(1, quantity40.TonnesForcePerSquareMillimeter, TonnesForcePerSquareMillimeterTolerance);
             Assert.Equal(PressureUnit.TonneForcePerSquareMillimeter, quantity40.Unit);
 
-            var quantity41 = Pressure.From(1, PressureUnit.Torr);
+            var quantity41 = Pressure<double>.From(1, PressureUnit.Torr);
             AssertEx.EqualTolerance(1, quantity41.Torrs, TorrsTolerance);
             Assert.Equal(PressureUnit.Torr, quantity41.Unit);
 
@@ -417,20 +417,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromPascals_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Pressure.FromPascals(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Pressure.FromPascals(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Pressure<double>.FromPascals(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Pressure<double>.FromPascals(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromPascals_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Pressure.FromPascals(double.NaN));
+            Assert.Throws<ArgumentException>(() => Pressure<double>.FromPascals(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var pascal = Pressure.FromPascals(1);
+            var pascal = Pressure<double>.FromPascals(1);
             AssertEx.EqualTolerance(AtmospheresInOnePascal, pascal.As(PressureUnit.Atmosphere), AtmospheresTolerance);
             AssertEx.EqualTolerance(BarsInOnePascal, pascal.As(PressureUnit.Bar), BarsTolerance);
             AssertEx.EqualTolerance(CentibarsInOnePascal, pascal.As(PressureUnit.Centibar), CentibarsTolerance);
@@ -495,7 +495,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var pascal = Pressure.FromPascals(1);
+            var pascal = Pressure<double>.FromPascals(1);
 
             var atmosphereQuantity = pascal.ToUnit(PressureUnit.Atmosphere);
             AssertEx.EqualTolerance(AtmospheresInOnePascal, (double)atmosphereQuantity.Value, AtmospheresTolerance);
@@ -676,69 +676,69 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Pressure pascal = Pressure.FromPascals(1);
-            AssertEx.EqualTolerance(1, Pressure.FromAtmospheres(pascal.Atmospheres).Pascals, AtmospheresTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromBars(pascal.Bars).Pascals, BarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromCentibars(pascal.Centibars).Pascals, CentibarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromDecapascals(pascal.Decapascals).Pascals, DecapascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromDecibars(pascal.Decibars).Pascals, DecibarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromDynesPerSquareCentimeter(pascal.DynesPerSquareCentimeter).Pascals, DynesPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromFeetOfHead(pascal.FeetOfHead).Pascals, FeetOfHeadTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromGigapascals(pascal.Gigapascals).Pascals, GigapascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromHectopascals(pascal.Hectopascals).Pascals, HectopascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromInchesOfMercury(pascal.InchesOfMercury).Pascals, InchesOfMercuryTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromInchesOfWaterColumn(pascal.InchesOfWaterColumn).Pascals, InchesOfWaterColumnTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilobars(pascal.Kilobars).Pascals, KilobarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareCentimeter(pascal.KilogramsForcePerSquareCentimeter).Pascals, KilogramsForcePerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareMeter(pascal.KilogramsForcePerSquareMeter).Pascals, KilogramsForcePerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareMillimeter(pascal.KilogramsForcePerSquareMillimeter).Pascals, KilogramsForcePerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareCentimeter(pascal.KilonewtonsPerSquareCentimeter).Pascals, KilonewtonsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareMeter(pascal.KilonewtonsPerSquareMeter).Pascals, KilonewtonsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareMillimeter(pascal.KilonewtonsPerSquareMillimeter).Pascals, KilonewtonsPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilopascals(pascal.Kilopascals).Pascals, KilopascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareFoot(pascal.KilopoundsForcePerSquareFoot).Pascals, KilopoundsForcePerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareInch(pascal.KilopoundsForcePerSquareInch).Pascals, KilopoundsForcePerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMegabars(pascal.Megabars).Pascals, MegabarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMeganewtonsPerSquareMeter(pascal.MeganewtonsPerSquareMeter).Pascals, MeganewtonsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMegapascals(pascal.Megapascals).Pascals, MegapascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMetersOfHead(pascal.MetersOfHead).Pascals, MetersOfHeadTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMicrobars(pascal.Microbars).Pascals, MicrobarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMicropascals(pascal.Micropascals).Pascals, MicropascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillibars(pascal.Millibars).Pascals, MillibarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillimetersOfMercury(pascal.MillimetersOfMercury).Pascals, MillimetersOfMercuryTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillipascals(pascal.Millipascals).Pascals, MillipascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareCentimeter(pascal.NewtonsPerSquareCentimeter).Pascals, NewtonsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareMeter(pascal.NewtonsPerSquareMeter).Pascals, NewtonsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareMillimeter(pascal.NewtonsPerSquareMillimeter).Pascals, NewtonsPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPascals(pascal.Pascals).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareFoot(pascal.PoundsForcePerSquareFoot).Pascals, PoundsForcePerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareInch(pascal.PoundsForcePerSquareInch).Pascals, PoundsForcePerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPoundsPerInchSecondSquared(pascal.PoundsPerInchSecondSquared).Pascals, PoundsPerInchSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTechnicalAtmospheres(pascal.TechnicalAtmospheres).Pascals, TechnicalAtmospheresTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTonnesForcePerSquareCentimeter(pascal.TonnesForcePerSquareCentimeter).Pascals, TonnesForcePerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTonnesForcePerSquareMeter(pascal.TonnesForcePerSquareMeter).Pascals, TonnesForcePerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTonnesForcePerSquareMillimeter(pascal.TonnesForcePerSquareMillimeter).Pascals, TonnesForcePerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTorrs(pascal.Torrs).Pascals, TorrsTolerance);
+            Pressure<double> pascal = Pressure<double>.FromPascals(1);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromAtmospheres(pascal.Atmospheres).Pascals, AtmospheresTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromBars(pascal.Bars).Pascals, BarsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromCentibars(pascal.Centibars).Pascals, CentibarsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromDecapascals(pascal.Decapascals).Pascals, DecapascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromDecibars(pascal.Decibars).Pascals, DecibarsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromDynesPerSquareCentimeter(pascal.DynesPerSquareCentimeter).Pascals, DynesPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromFeetOfHead(pascal.FeetOfHead).Pascals, FeetOfHeadTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromGigapascals(pascal.Gigapascals).Pascals, GigapascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromHectopascals(pascal.Hectopascals).Pascals, HectopascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromInchesOfMercury(pascal.InchesOfMercury).Pascals, InchesOfMercuryTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromInchesOfWaterColumn(pascal.InchesOfWaterColumn).Pascals, InchesOfWaterColumnTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilobars(pascal.Kilobars).Pascals, KilobarsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilogramsForcePerSquareCentimeter(pascal.KilogramsForcePerSquareCentimeter).Pascals, KilogramsForcePerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilogramsForcePerSquareMeter(pascal.KilogramsForcePerSquareMeter).Pascals, KilogramsForcePerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilogramsForcePerSquareMillimeter(pascal.KilogramsForcePerSquareMillimeter).Pascals, KilogramsForcePerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilonewtonsPerSquareCentimeter(pascal.KilonewtonsPerSquareCentimeter).Pascals, KilonewtonsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilonewtonsPerSquareMeter(pascal.KilonewtonsPerSquareMeter).Pascals, KilonewtonsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilonewtonsPerSquareMillimeter(pascal.KilonewtonsPerSquareMillimeter).Pascals, KilonewtonsPerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilopascals(pascal.Kilopascals).Pascals, KilopascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilopoundsForcePerSquareFoot(pascal.KilopoundsForcePerSquareFoot).Pascals, KilopoundsForcePerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromKilopoundsForcePerSquareInch(pascal.KilopoundsForcePerSquareInch).Pascals, KilopoundsForcePerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMegabars(pascal.Megabars).Pascals, MegabarsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMeganewtonsPerSquareMeter(pascal.MeganewtonsPerSquareMeter).Pascals, MeganewtonsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMegapascals(pascal.Megapascals).Pascals, MegapascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMetersOfHead(pascal.MetersOfHead).Pascals, MetersOfHeadTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMicrobars(pascal.Microbars).Pascals, MicrobarsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMicropascals(pascal.Micropascals).Pascals, MicropascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMillibars(pascal.Millibars).Pascals, MillibarsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMillimetersOfMercury(pascal.MillimetersOfMercury).Pascals, MillimetersOfMercuryTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromMillipascals(pascal.Millipascals).Pascals, MillipascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromNewtonsPerSquareCentimeter(pascal.NewtonsPerSquareCentimeter).Pascals, NewtonsPerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromNewtonsPerSquareMeter(pascal.NewtonsPerSquareMeter).Pascals, NewtonsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromNewtonsPerSquareMillimeter(pascal.NewtonsPerSquareMillimeter).Pascals, NewtonsPerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromPascals(pascal.Pascals).Pascals, PascalsTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromPoundsForcePerSquareFoot(pascal.PoundsForcePerSquareFoot).Pascals, PoundsForcePerSquareFootTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromPoundsForcePerSquareInch(pascal.PoundsForcePerSquareInch).Pascals, PoundsForcePerSquareInchTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromPoundsPerInchSecondSquared(pascal.PoundsPerInchSecondSquared).Pascals, PoundsPerInchSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromTechnicalAtmospheres(pascal.TechnicalAtmospheres).Pascals, TechnicalAtmospheresTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromTonnesForcePerSquareCentimeter(pascal.TonnesForcePerSquareCentimeter).Pascals, TonnesForcePerSquareCentimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromTonnesForcePerSquareMeter(pascal.TonnesForcePerSquareMeter).Pascals, TonnesForcePerSquareMeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromTonnesForcePerSquareMillimeter(pascal.TonnesForcePerSquareMillimeter).Pascals, TonnesForcePerSquareMillimeterTolerance);
+            AssertEx.EqualTolerance(1, Pressure<double>.FromTorrs(pascal.Torrs).Pascals, TorrsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Pressure v = Pressure.FromPascals(1);
+            Pressure<double> v = Pressure<double>.FromPascals(1);
             AssertEx.EqualTolerance(-1, -v.Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(2, (Pressure.FromPascals(3)-v).Pascals, PascalsTolerance);
+            AssertEx.EqualTolerance(2, (Pressure<double>.FromPascals(3)-v).Pascals, PascalsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Pascals, PascalsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Pascals, PascalsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(2, (Pressure.FromPascals(10)/5).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(2, Pressure.FromPascals(10)/Pressure.FromPascals(5), PascalsTolerance);
+            AssertEx.EqualTolerance(2, (Pressure<double>.FromPascals(10)/5).Pascals, PascalsTolerance);
+            AssertEx.EqualTolerance(2, Pressure<double>.FromPascals(10)/Pressure<double>.FromPascals(5), PascalsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Pressure onePascal = Pressure.FromPascals(1);
-            Pressure twoPascals = Pressure.FromPascals(2);
+            Pressure<double> onePascal = Pressure<double>.FromPascals(1);
+            Pressure<double> twoPascals = Pressure<double>.FromPascals(2);
 
             Assert.True(onePascal < twoPascals);
             Assert.True(onePascal <= twoPascals);
@@ -754,31 +754,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Pressure pascal = Pressure.FromPascals(1);
+            Pressure<double> pascal = Pressure<double>.FromPascals(1);
             Assert.Equal(0, pascal.CompareTo(pascal));
-            Assert.True(pascal.CompareTo(Pressure.Zero) > 0);
-            Assert.True(Pressure.Zero.CompareTo(pascal) < 0);
+            Assert.True(pascal.CompareTo(Pressure<double>.Zero) > 0);
+            Assert.True(Pressure<double>.Zero.CompareTo(pascal) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Pressure pascal = Pressure.FromPascals(1);
+            Pressure<double> pascal = Pressure<double>.FromPascals(1);
             Assert.Throws<ArgumentException>(() => pascal.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Pressure pascal = Pressure.FromPascals(1);
+            Pressure<double> pascal = Pressure<double>.FromPascals(1);
             Assert.Throws<ArgumentNullException>(() => pascal.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Pressure.FromPascals(1);
-            var b = Pressure.FromPascals(2);
+            var a = Pressure<double>.FromPascals(1);
+            var b = Pressure<double>.FromPascals(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -797,8 +797,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Pressure.FromPascals(1);
-            var b = Pressure.FromPascals(2);
+            var a = Pressure<double>.FromPascals(1);
+            var b = Pressure<double>.FromPascals(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -818,9 +818,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Pressure.FromPascals(1);
-            Assert.True(v.Equals(Pressure.FromPascals(1), PascalsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Pressure.Zero, PascalsTolerance, ComparisonType.Relative));
+            var v = Pressure<double>.FromPascals(1);
+            Assert.True(v.Equals(Pressure<double>.FromPascals(1), PascalsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Pressure<double>.Zero, PascalsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -833,21 +833,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Pressure pascal = Pressure.FromPascals(1);
+            Pressure<double> pascal = Pressure<double>.FromPascals(1);
             Assert.False(pascal.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Pressure pascal = Pressure.FromPascals(1);
+            Pressure<double> pascal = Pressure<double>.FromPascals(1);
             Assert.False(pascal.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(PressureUnit.Undefined, Pressure.Units);
+            Assert.DoesNotContain(PressureUnit.Undefined, Pressure<double>.Units);
         }
 
         [Fact]
@@ -866,7 +866,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Pressure.BaseDimensions is null);
+            Assert.False(Pressure<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs
index 3d2191fd88..b8f43efb1c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs
@@ -48,7 +48,7 @@ public abstract partial class RatioChangeRateTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RatioChangeRate((double)0.0, RatioChangeRateUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>((double)0.0, RatioChangeRateUnit.Undefined));
         }
 
         [Fact]
@@ -63,14 +63,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RatioChangeRate(double.PositiveInfinity, RatioChangeRateUnit.DecimalFractionPerSecond));
-            Assert.Throws<ArgumentException>(() => new RatioChangeRate(double.NegativeInfinity, RatioChangeRateUnit.DecimalFractionPerSecond));
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>(double.PositiveInfinity, RatioChangeRateUnit.DecimalFractionPerSecond));
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>(double.NegativeInfinity, RatioChangeRateUnit.DecimalFractionPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RatioChangeRate(double.NaN, RatioChangeRateUnit.DecimalFractionPerSecond));
+            Assert.Throws<ArgumentException>(() => new RatioChangeRate<double>(double.NaN, RatioChangeRateUnit.DecimalFractionPerSecond));
         }
 
         [Fact]
@@ -116,7 +116,7 @@ public void RatioChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DecimalFractionPerSecondToRatioChangeRateUnits()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             AssertEx.EqualTolerance(DecimalFractionsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
             AssertEx.EqualTolerance(PercentsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.PercentsPerSecond, PercentsPerSecondTolerance);
         }
@@ -124,11 +124,11 @@ public void DecimalFractionPerSecondToRatioChangeRateUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = RatioChangeRate.From(1, RatioChangeRateUnit.DecimalFractionPerSecond);
+            var quantity00 = RatioChangeRate<double>.From(1, RatioChangeRateUnit.DecimalFractionPerSecond);
             AssertEx.EqualTolerance(1, quantity00.DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
             Assert.Equal(RatioChangeRateUnit.DecimalFractionPerSecond, quantity00.Unit);
 
-            var quantity01 = RatioChangeRate.From(1, RatioChangeRateUnit.PercentPerSecond);
+            var quantity01 = RatioChangeRate<double>.From(1, RatioChangeRateUnit.PercentPerSecond);
             AssertEx.EqualTolerance(1, quantity01.PercentsPerSecond, PercentsPerSecondTolerance);
             Assert.Equal(RatioChangeRateUnit.PercentPerSecond, quantity01.Unit);
 
@@ -137,20 +137,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDecimalFractionsPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RatioChangeRate.FromDecimalFractionsPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => RatioChangeRate.FromDecimalFractionsPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => RatioChangeRate<double>.FromDecimalFractionsPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RatioChangeRate<double>.FromDecimalFractionsPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDecimalFractionsPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RatioChangeRate.FromDecimalFractionsPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => RatioChangeRate<double>.FromDecimalFractionsPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            var decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             AssertEx.EqualTolerance(DecimalFractionsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.As(RatioChangeRateUnit.DecimalFractionPerSecond), DecimalFractionsPerSecondTolerance);
             AssertEx.EqualTolerance(PercentsPerSecondInOneDecimalFractionPerSecond, decimalfractionpersecond.As(RatioChangeRateUnit.PercentPerSecond), PercentsPerSecondTolerance);
         }
@@ -175,7 +175,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            var decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
 
             var decimalfractionpersecondQuantity = decimalfractionpersecond.ToUnit(RatioChangeRateUnit.DecimalFractionPerSecond);
             AssertEx.EqualTolerance(DecimalFractionsPerSecondInOneDecimalFractionPerSecond, (double)decimalfractionpersecondQuantity.Value, DecimalFractionsPerSecondTolerance);
@@ -196,29 +196,29 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
-            AssertEx.EqualTolerance(1, RatioChangeRate.FromDecimalFractionsPerSecond(decimalfractionpersecond.DecimalFractionsPerSecond).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RatioChangeRate.FromPercentsPerSecond(decimalfractionpersecond.PercentsPerSecond).DecimalFractionsPerSecond, PercentsPerSecondTolerance);
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            AssertEx.EqualTolerance(1, RatioChangeRate<double>.FromDecimalFractionsPerSecond(decimalfractionpersecond.DecimalFractionsPerSecond).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RatioChangeRate<double>.FromPercentsPerSecond(decimalfractionpersecond.PercentsPerSecond).DecimalFractionsPerSecond, PercentsPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            RatioChangeRate v = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> v = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RatioChangeRate.FromDecimalFractionsPerSecond(3)-v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (RatioChangeRate<double>.FromDecimalFractionsPerSecond(3)-v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RatioChangeRate.FromDecimalFractionsPerSecond(10)/5).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, RatioChangeRate.FromDecimalFractionsPerSecond(10)/RatioChangeRate.FromDecimalFractionsPerSecond(5), DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (RatioChangeRate<double>.FromDecimalFractionsPerSecond(10)/5).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
+            AssertEx.EqualTolerance(2, RatioChangeRate<double>.FromDecimalFractionsPerSecond(10)/RatioChangeRate<double>.FromDecimalFractionsPerSecond(5), DecimalFractionsPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            RatioChangeRate oneDecimalFractionPerSecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
-            RatioChangeRate twoDecimalFractionsPerSecond = RatioChangeRate.FromDecimalFractionsPerSecond(2);
+            RatioChangeRate<double> oneDecimalFractionPerSecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> twoDecimalFractionsPerSecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(2);
 
             Assert.True(oneDecimalFractionPerSecond < twoDecimalFractionsPerSecond);
             Assert.True(oneDecimalFractionPerSecond <= twoDecimalFractionsPerSecond);
@@ -234,31 +234,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             Assert.Equal(0, decimalfractionpersecond.CompareTo(decimalfractionpersecond));
-            Assert.True(decimalfractionpersecond.CompareTo(RatioChangeRate.Zero) > 0);
-            Assert.True(RatioChangeRate.Zero.CompareTo(decimalfractionpersecond) < 0);
+            Assert.True(decimalfractionpersecond.CompareTo(RatioChangeRate<double>.Zero) > 0);
+            Assert.True(RatioChangeRate<double>.Zero.CompareTo(decimalfractionpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             Assert.Throws<ArgumentException>(() => decimalfractionpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => decimalfractionpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = RatioChangeRate.FromDecimalFractionsPerSecond(1);
-            var b = RatioChangeRate.FromDecimalFractionsPerSecond(2);
+            var a = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            var b = RatioChangeRate<double>.FromDecimalFractionsPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -277,8 +277,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = RatioChangeRate.FromDecimalFractionsPerSecond(1);
-            var b = RatioChangeRate.FromDecimalFractionsPerSecond(2);
+            var a = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            var b = RatioChangeRate<double>.FromDecimalFractionsPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -298,9 +298,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = RatioChangeRate.FromDecimalFractionsPerSecond(1);
-            Assert.True(v.Equals(RatioChangeRate.FromDecimalFractionsPerSecond(1), DecimalFractionsPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(RatioChangeRate.Zero, DecimalFractionsPerSecondTolerance, ComparisonType.Relative));
+            var v = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
+            Assert.True(v.Equals(RatioChangeRate<double>.FromDecimalFractionsPerSecond(1), DecimalFractionsPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RatioChangeRate<double>.Zero, DecimalFractionsPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -313,21 +313,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             Assert.False(decimalfractionpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
+            RatioChangeRate<double> decimalfractionpersecond = RatioChangeRate<double>.FromDecimalFractionsPerSecond(1);
             Assert.False(decimalfractionpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(RatioChangeRateUnit.Undefined, RatioChangeRate.Units);
+            Assert.DoesNotContain(RatioChangeRateUnit.Undefined, RatioChangeRate<double>.Units);
         }
 
         [Fact]
@@ -346,7 +346,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(RatioChangeRate.BaseDimensions is null);
+            Assert.False(RatioChangeRate<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs
index 313d7f0aa9..cbd7d4f09a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs
@@ -56,7 +56,7 @@ public abstract partial class RatioTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Ratio((double)0.0, RatioUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Ratio<double>((double)0.0, RatioUnit.Undefined));
         }
 
         [Fact]
@@ -71,14 +71,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Ratio(double.PositiveInfinity, RatioUnit.DecimalFraction));
-            Assert.Throws<ArgumentException>(() => new Ratio(double.NegativeInfinity, RatioUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new Ratio<double>(double.PositiveInfinity, RatioUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new Ratio<double>(double.NegativeInfinity, RatioUnit.DecimalFraction));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Ratio(double.NaN, RatioUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new Ratio<double>(double.NaN, RatioUnit.DecimalFraction));
         }
 
         [Fact]
@@ -124,7 +124,7 @@ public void Ratio_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void DecimalFractionToRatioUnits()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.PartsPerBillion, PartsPerBillionTolerance);
             AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.PartsPerMillion, PartsPerMillionTolerance);
@@ -136,27 +136,27 @@ public void DecimalFractionToRatioUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Ratio.From(1, RatioUnit.DecimalFraction);
+            var quantity00 = Ratio<double>.From(1, RatioUnit.DecimalFraction);
             AssertEx.EqualTolerance(1, quantity00.DecimalFractions, DecimalFractionsTolerance);
             Assert.Equal(RatioUnit.DecimalFraction, quantity00.Unit);
 
-            var quantity01 = Ratio.From(1, RatioUnit.PartPerBillion);
+            var quantity01 = Ratio<double>.From(1, RatioUnit.PartPerBillion);
             AssertEx.EqualTolerance(1, quantity01.PartsPerBillion, PartsPerBillionTolerance);
             Assert.Equal(RatioUnit.PartPerBillion, quantity01.Unit);
 
-            var quantity02 = Ratio.From(1, RatioUnit.PartPerMillion);
+            var quantity02 = Ratio<double>.From(1, RatioUnit.PartPerMillion);
             AssertEx.EqualTolerance(1, quantity02.PartsPerMillion, PartsPerMillionTolerance);
             Assert.Equal(RatioUnit.PartPerMillion, quantity02.Unit);
 
-            var quantity03 = Ratio.From(1, RatioUnit.PartPerThousand);
+            var quantity03 = Ratio<double>.From(1, RatioUnit.PartPerThousand);
             AssertEx.EqualTolerance(1, quantity03.PartsPerThousand, PartsPerThousandTolerance);
             Assert.Equal(RatioUnit.PartPerThousand, quantity03.Unit);
 
-            var quantity04 = Ratio.From(1, RatioUnit.PartPerTrillion);
+            var quantity04 = Ratio<double>.From(1, RatioUnit.PartPerTrillion);
             AssertEx.EqualTolerance(1, quantity04.PartsPerTrillion, PartsPerTrillionTolerance);
             Assert.Equal(RatioUnit.PartPerTrillion, quantity04.Unit);
 
-            var quantity05 = Ratio.From(1, RatioUnit.Percent);
+            var quantity05 = Ratio<double>.From(1, RatioUnit.Percent);
             AssertEx.EqualTolerance(1, quantity05.Percent, PercentTolerance);
             Assert.Equal(RatioUnit.Percent, quantity05.Unit);
 
@@ -165,20 +165,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDecimalFractions_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Ratio.FromDecimalFractions(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Ratio.FromDecimalFractions(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Ratio<double>.FromDecimalFractions(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Ratio<double>.FromDecimalFractions(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDecimalFractions_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Ratio.FromDecimalFractions(double.NaN));
+            Assert.Throws<ArgumentException>(() => Ratio<double>.FromDecimalFractions(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var decimalfraction = Ratio.FromDecimalFractions(1);
+            var decimalfraction = Ratio<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.As(RatioUnit.DecimalFraction), DecimalFractionsTolerance);
             AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerBillion), PartsPerBillionTolerance);
             AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerMillion), PartsPerMillionTolerance);
@@ -207,7 +207,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var decimalfraction = Ratio.FromDecimalFractions(1);
+            var decimalfraction = Ratio<double>.FromDecimalFractions(1);
 
             var decimalfractionQuantity = decimalfraction.ToUnit(RatioUnit.DecimalFraction);
             AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, (double)decimalfractionQuantity.Value, DecimalFractionsTolerance);
@@ -244,33 +244,33 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(1, Ratio.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
+            AssertEx.EqualTolerance(1, Ratio<double>.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Ratio v = Ratio.FromDecimalFractions(1);
+            Ratio<double> v = Ratio<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (Ratio.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (Ratio<double>.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(10, (v*10).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(10, (10*v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (Ratio.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, Ratio.FromDecimalFractions(10)/Ratio.FromDecimalFractions(5), DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (Ratio<double>.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, Ratio<double>.FromDecimalFractions(10)/Ratio<double>.FromDecimalFractions(5), DecimalFractionsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Ratio oneDecimalFraction = Ratio.FromDecimalFractions(1);
-            Ratio twoDecimalFractions = Ratio.FromDecimalFractions(2);
+            Ratio<double> oneDecimalFraction = Ratio<double>.FromDecimalFractions(1);
+            Ratio<double> twoDecimalFractions = Ratio<double>.FromDecimalFractions(2);
 
             Assert.True(oneDecimalFraction < twoDecimalFractions);
             Assert.True(oneDecimalFraction <= twoDecimalFractions);
@@ -286,31 +286,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
             Assert.Equal(0, decimalfraction.CompareTo(decimalfraction));
-            Assert.True(decimalfraction.CompareTo(Ratio.Zero) > 0);
-            Assert.True(Ratio.Zero.CompareTo(decimalfraction) < 0);
+            Assert.True(decimalfraction.CompareTo(Ratio<double>.Zero) > 0);
+            Assert.True(Ratio<double>.Zero.CompareTo(decimalfraction) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
             Assert.Throws<ArgumentException>(() => decimalfraction.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
             Assert.Throws<ArgumentNullException>(() => decimalfraction.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Ratio.FromDecimalFractions(1);
-            var b = Ratio.FromDecimalFractions(2);
+            var a = Ratio<double>.FromDecimalFractions(1);
+            var b = Ratio<double>.FromDecimalFractions(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -329,8 +329,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Ratio.FromDecimalFractions(1);
-            var b = Ratio.FromDecimalFractions(2);
+            var a = Ratio<double>.FromDecimalFractions(1);
+            var b = Ratio<double>.FromDecimalFractions(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -350,9 +350,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Ratio.FromDecimalFractions(1);
-            Assert.True(v.Equals(Ratio.FromDecimalFractions(1), DecimalFractionsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Ratio.Zero, DecimalFractionsTolerance, ComparisonType.Relative));
+            var v = Ratio<double>.FromDecimalFractions(1);
+            Assert.True(v.Equals(Ratio<double>.FromDecimalFractions(1), DecimalFractionsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Ratio<double>.Zero, DecimalFractionsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -365,21 +365,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
             Assert.False(decimalfraction.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
+            Ratio<double> decimalfraction = Ratio<double>.FromDecimalFractions(1);
             Assert.False(decimalfraction.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(RatioUnit.Undefined, Ratio.Units);
+            Assert.DoesNotContain(RatioUnit.Undefined, Ratio<double>.Units);
         }
 
         [Fact]
@@ -398,7 +398,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Ratio.BaseDimensions is null);
+            Assert.False(Ratio<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ReactiveEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ReactiveEnergyTestsBase.g.cs
index 0c39428f2d..12f3de437a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ReactiveEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ReactiveEnergyTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class ReactiveEnergyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ReactiveEnergy((double)0.0, ReactiveEnergyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>((double)0.0, ReactiveEnergyUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ReactiveEnergy(double.PositiveInfinity, ReactiveEnergyUnit.VoltampereReactiveHour));
-            Assert.Throws<ArgumentException>(() => new ReactiveEnergy(double.NegativeInfinity, ReactiveEnergyUnit.VoltampereReactiveHour));
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>(double.PositiveInfinity, ReactiveEnergyUnit.VoltampereReactiveHour));
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>(double.NegativeInfinity, ReactiveEnergyUnit.VoltampereReactiveHour));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ReactiveEnergy(double.NaN, ReactiveEnergyUnit.VoltampereReactiveHour));
+            Assert.Throws<ArgumentException>(() => new ReactiveEnergy<double>(double.NaN, ReactiveEnergyUnit.VoltampereReactiveHour));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void ReactiveEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void VoltampereReactiveHourToReactiveEnergyUnits()
         {
-            ReactiveEnergy voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             AssertEx.EqualTolerance(KilovoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.KilovoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
             AssertEx.EqualTolerance(MegavoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.MegavoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
             AssertEx.EqualTolerance(VoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
@@ -127,15 +127,15 @@ public void VoltampereReactiveHourToReactiveEnergyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ReactiveEnergy.From(1, ReactiveEnergyUnit.KilovoltampereReactiveHour);
+            var quantity00 = ReactiveEnergy<double>.From(1, ReactiveEnergyUnit.KilovoltampereReactiveHour);
             AssertEx.EqualTolerance(1, quantity00.KilovoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
             Assert.Equal(ReactiveEnergyUnit.KilovoltampereReactiveHour, quantity00.Unit);
 
-            var quantity01 = ReactiveEnergy.From(1, ReactiveEnergyUnit.MegavoltampereReactiveHour);
+            var quantity01 = ReactiveEnergy<double>.From(1, ReactiveEnergyUnit.MegavoltampereReactiveHour);
             AssertEx.EqualTolerance(1, quantity01.MegavoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
             Assert.Equal(ReactiveEnergyUnit.MegavoltampereReactiveHour, quantity01.Unit);
 
-            var quantity02 = ReactiveEnergy.From(1, ReactiveEnergyUnit.VoltampereReactiveHour);
+            var quantity02 = ReactiveEnergy<double>.From(1, ReactiveEnergyUnit.VoltampereReactiveHour);
             AssertEx.EqualTolerance(1, quantity02.VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
             Assert.Equal(ReactiveEnergyUnit.VoltampereReactiveHour, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltampereReactiveHours_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ReactiveEnergy.FromVoltampereReactiveHours(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ReactiveEnergy.FromVoltampereReactiveHours(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ReactiveEnergy<double>.FromVoltampereReactiveHours(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ReactiveEnergy<double>.FromVoltampereReactiveHours(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltampereReactiveHours_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ReactiveEnergy.FromVoltampereReactiveHours(double.NaN));
+            Assert.Throws<ArgumentException>(() => ReactiveEnergy<double>.FromVoltampereReactiveHours(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            var voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             AssertEx.EqualTolerance(KilovoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.As(ReactiveEnergyUnit.KilovoltampereReactiveHour), KilovoltampereReactiveHoursTolerance);
             AssertEx.EqualTolerance(MegavoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.As(ReactiveEnergyUnit.MegavoltampereReactiveHour), MegavoltampereReactiveHoursTolerance);
             AssertEx.EqualTolerance(VoltampereReactiveHoursInOneVoltampereReactiveHour, voltamperereactivehour.As(ReactiveEnergyUnit.VoltampereReactiveHour), VoltampereReactiveHoursTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            var voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
 
             var kilovoltamperereactivehourQuantity = voltamperereactivehour.ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour);
             AssertEx.EqualTolerance(KilovoltampereReactiveHoursInOneVoltampereReactiveHour, (double)kilovoltamperereactivehourQuantity.Value, KilovoltampereReactiveHoursTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ReactiveEnergy voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
-            AssertEx.EqualTolerance(1, ReactiveEnergy.FromKilovoltampereReactiveHours(voltamperereactivehour.KilovoltampereReactiveHours).VoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(1, ReactiveEnergy.FromMegavoltampereReactiveHours(voltamperereactivehour.MegavoltampereReactiveHours).VoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(1, ReactiveEnergy.FromVoltampereReactiveHours(voltamperereactivehour.VoltampereReactiveHours).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.FromKilovoltampereReactiveHours(voltamperereactivehour.KilovoltampereReactiveHours).VoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.FromMegavoltampereReactiveHours(voltamperereactivehour.MegavoltampereReactiveHours).VoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(1, ReactiveEnergy<double>.FromVoltampereReactiveHours(voltamperereactivehour.VoltampereReactiveHours).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ReactiveEnergy v = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> v = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             AssertEx.EqualTolerance(-1, -v.VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(2, (ReactiveEnergy.FromVoltampereReactiveHours(3)-v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(2, (ReactiveEnergy<double>.FromVoltampereReactiveHours(3)-v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
             AssertEx.EqualTolerance(2, (v + v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
             AssertEx.EqualTolerance(10, (v*10).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
             AssertEx.EqualTolerance(10, (10*v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(2, (ReactiveEnergy.FromVoltampereReactiveHours(10)/5).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(2, ReactiveEnergy.FromVoltampereReactiveHours(10)/ReactiveEnergy.FromVoltampereReactiveHours(5), VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(2, (ReactiveEnergy<double>.FromVoltampereReactiveHours(10)/5).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            AssertEx.EqualTolerance(2, ReactiveEnergy<double>.FromVoltampereReactiveHours(10)/ReactiveEnergy<double>.FromVoltampereReactiveHours(5), VoltampereReactiveHoursTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ReactiveEnergy oneVoltampereReactiveHour = ReactiveEnergy.FromVoltampereReactiveHours(1);
-            ReactiveEnergy twoVoltampereReactiveHours = ReactiveEnergy.FromVoltampereReactiveHours(2);
+            ReactiveEnergy<double> oneVoltampereReactiveHour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> twoVoltampereReactiveHours = ReactiveEnergy<double>.FromVoltampereReactiveHours(2);
 
             Assert.True(oneVoltampereReactiveHour < twoVoltampereReactiveHours);
             Assert.True(oneVoltampereReactiveHour <= twoVoltampereReactiveHours);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ReactiveEnergy voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             Assert.Equal(0, voltamperereactivehour.CompareTo(voltamperereactivehour));
-            Assert.True(voltamperereactivehour.CompareTo(ReactiveEnergy.Zero) > 0);
-            Assert.True(ReactiveEnergy.Zero.CompareTo(voltamperereactivehour) < 0);
+            Assert.True(voltamperereactivehour.CompareTo(ReactiveEnergy<double>.Zero) > 0);
+            Assert.True(ReactiveEnergy<double>.Zero.CompareTo(voltamperereactivehour) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ReactiveEnergy voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             Assert.Throws<ArgumentException>(() => voltamperereactivehour.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ReactiveEnergy voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             Assert.Throws<ArgumentNullException>(() => voltamperereactivehour.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ReactiveEnergy.FromVoltampereReactiveHours(1);
-            var b = ReactiveEnergy.FromVoltampereReactiveHours(2);
+            var a = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            var b = ReactiveEnergy<double>.FromVoltampereReactiveHours(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ReactiveEnergy.FromVoltampereReactiveHours(1);
-            var b = ReactiveEnergy.FromVoltampereReactiveHours(2);
+            var a = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            var b = ReactiveEnergy<double>.FromVoltampereReactiveHours(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ReactiveEnergy.FromVoltampereReactiveHours(1);
-            Assert.True(v.Equals(ReactiveEnergy.FromVoltampereReactiveHours(1), VoltampereReactiveHoursTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ReactiveEnergy.Zero, VoltampereReactiveHoursTolerance, ComparisonType.Relative));
+            var v = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
+            Assert.True(v.Equals(ReactiveEnergy<double>.FromVoltampereReactiveHours(1), VoltampereReactiveHoursTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ReactiveEnergy<double>.Zero, VoltampereReactiveHoursTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ReactiveEnergy voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             Assert.False(voltamperereactivehour.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ReactiveEnergy voltamperereactivehour = ReactiveEnergy.FromVoltampereReactiveHours(1);
+            ReactiveEnergy<double> voltamperereactivehour = ReactiveEnergy<double>.FromVoltampereReactiveHours(1);
             Assert.False(voltamperereactivehour.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ReactiveEnergyUnit.Undefined, ReactiveEnergy.Units);
+            Assert.DoesNotContain(ReactiveEnergyUnit.Undefined, ReactiveEnergy<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ReactiveEnergy.BaseDimensions is null);
+            Assert.False(ReactiveEnergy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ReactivePowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ReactivePowerTestsBase.g.cs
index a88ac2558f..7738cf95b8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ReactivePowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ReactivePowerTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class ReactivePowerTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ReactivePower((double)0.0, ReactivePowerUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>((double)0.0, ReactivePowerUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ReactivePower(double.PositiveInfinity, ReactivePowerUnit.VoltampereReactive));
-            Assert.Throws<ArgumentException>(() => new ReactivePower(double.NegativeInfinity, ReactivePowerUnit.VoltampereReactive));
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>(double.PositiveInfinity, ReactivePowerUnit.VoltampereReactive));
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>(double.NegativeInfinity, ReactivePowerUnit.VoltampereReactive));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ReactivePower(double.NaN, ReactivePowerUnit.VoltampereReactive));
+            Assert.Throws<ArgumentException>(() => new ReactivePower<double>(double.NaN, ReactivePowerUnit.VoltampereReactive));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void ReactivePower_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void VoltampereReactiveToReactivePowerUnits()
         {
-            ReactivePower voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
             AssertEx.EqualTolerance(GigavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.GigavoltamperesReactive, GigavoltamperesReactiveTolerance);
             AssertEx.EqualTolerance(KilovoltamperesReactiveInOneVoltampereReactive, voltamperereactive.KilovoltamperesReactive, KilovoltamperesReactiveTolerance);
             AssertEx.EqualTolerance(MegavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.MegavoltamperesReactive, MegavoltamperesReactiveTolerance);
@@ -130,19 +130,19 @@ public void VoltampereReactiveToReactivePowerUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ReactivePower.From(1, ReactivePowerUnit.GigavoltampereReactive);
+            var quantity00 = ReactivePower<double>.From(1, ReactivePowerUnit.GigavoltampereReactive);
             AssertEx.EqualTolerance(1, quantity00.GigavoltamperesReactive, GigavoltamperesReactiveTolerance);
             Assert.Equal(ReactivePowerUnit.GigavoltampereReactive, quantity00.Unit);
 
-            var quantity01 = ReactivePower.From(1, ReactivePowerUnit.KilovoltampereReactive);
+            var quantity01 = ReactivePower<double>.From(1, ReactivePowerUnit.KilovoltampereReactive);
             AssertEx.EqualTolerance(1, quantity01.KilovoltamperesReactive, KilovoltamperesReactiveTolerance);
             Assert.Equal(ReactivePowerUnit.KilovoltampereReactive, quantity01.Unit);
 
-            var quantity02 = ReactivePower.From(1, ReactivePowerUnit.MegavoltampereReactive);
+            var quantity02 = ReactivePower<double>.From(1, ReactivePowerUnit.MegavoltampereReactive);
             AssertEx.EqualTolerance(1, quantity02.MegavoltamperesReactive, MegavoltamperesReactiveTolerance);
             Assert.Equal(ReactivePowerUnit.MegavoltampereReactive, quantity02.Unit);
 
-            var quantity03 = ReactivePower.From(1, ReactivePowerUnit.VoltampereReactive);
+            var quantity03 = ReactivePower<double>.From(1, ReactivePowerUnit.VoltampereReactive);
             AssertEx.EqualTolerance(1, quantity03.VoltamperesReactive, VoltamperesReactiveTolerance);
             Assert.Equal(ReactivePowerUnit.VoltampereReactive, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromVoltamperesReactive_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ReactivePower.FromVoltamperesReactive(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ReactivePower.FromVoltamperesReactive(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ReactivePower<double>.FromVoltamperesReactive(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ReactivePower<double>.FromVoltamperesReactive(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromVoltamperesReactive_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ReactivePower.FromVoltamperesReactive(double.NaN));
+            Assert.Throws<ArgumentException>(() => ReactivePower<double>.FromVoltamperesReactive(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            var voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
             AssertEx.EqualTolerance(GigavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.As(ReactivePowerUnit.GigavoltampereReactive), GigavoltamperesReactiveTolerance);
             AssertEx.EqualTolerance(KilovoltamperesReactiveInOneVoltampereReactive, voltamperereactive.As(ReactivePowerUnit.KilovoltampereReactive), KilovoltamperesReactiveTolerance);
             AssertEx.EqualTolerance(MegavoltamperesReactiveInOneVoltampereReactive, voltamperereactive.As(ReactivePowerUnit.MegavoltampereReactive), MegavoltamperesReactiveTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            var voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
 
             var gigavoltamperereactiveQuantity = voltamperereactive.ToUnit(ReactivePowerUnit.GigavoltampereReactive);
             AssertEx.EqualTolerance(GigavoltamperesReactiveInOneVoltampereReactive, (double)gigavoltamperereactiveQuantity.Value, GigavoltamperesReactiveTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ReactivePower voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
-            AssertEx.EqualTolerance(1, ReactivePower.FromGigavoltamperesReactive(voltamperereactive.GigavoltamperesReactive).VoltamperesReactive, GigavoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(1, ReactivePower.FromKilovoltamperesReactive(voltamperereactive.KilovoltamperesReactive).VoltamperesReactive, KilovoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(1, ReactivePower.FromMegavoltamperesReactive(voltamperereactive.MegavoltamperesReactive).VoltamperesReactive, MegavoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(1, ReactivePower.FromVoltamperesReactive(voltamperereactive.VoltamperesReactive).VoltamperesReactive, VoltamperesReactiveTolerance);
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromGigavoltamperesReactive(voltamperereactive.GigavoltamperesReactive).VoltamperesReactive, GigavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromKilovoltamperesReactive(voltamperereactive.KilovoltamperesReactive).VoltamperesReactive, KilovoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromMegavoltamperesReactive(voltamperereactive.MegavoltamperesReactive).VoltamperesReactive, MegavoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(1, ReactivePower<double>.FromVoltamperesReactive(voltamperereactive.VoltamperesReactive).VoltamperesReactive, VoltamperesReactiveTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ReactivePower v = ReactivePower.FromVoltamperesReactive(1);
+            ReactivePower<double> v = ReactivePower<double>.FromVoltamperesReactive(1);
             AssertEx.EqualTolerance(-1, -v.VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(2, (ReactivePower.FromVoltamperesReactive(3)-v).VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(2, (ReactivePower<double>.FromVoltamperesReactive(3)-v).VoltamperesReactive, VoltamperesReactiveTolerance);
             AssertEx.EqualTolerance(2, (v + v).VoltamperesReactive, VoltamperesReactiveTolerance);
             AssertEx.EqualTolerance(10, (v*10).VoltamperesReactive, VoltamperesReactiveTolerance);
             AssertEx.EqualTolerance(10, (10*v).VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(2, (ReactivePower.FromVoltamperesReactive(10)/5).VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(2, ReactivePower.FromVoltamperesReactive(10)/ReactivePower.FromVoltamperesReactive(5), VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(2, (ReactivePower<double>.FromVoltamperesReactive(10)/5).VoltamperesReactive, VoltamperesReactiveTolerance);
+            AssertEx.EqualTolerance(2, ReactivePower<double>.FromVoltamperesReactive(10)/ReactivePower<double>.FromVoltamperesReactive(5), VoltamperesReactiveTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ReactivePower oneVoltampereReactive = ReactivePower.FromVoltamperesReactive(1);
-            ReactivePower twoVoltamperesReactive = ReactivePower.FromVoltamperesReactive(2);
+            ReactivePower<double> oneVoltampereReactive = ReactivePower<double>.FromVoltamperesReactive(1);
+            ReactivePower<double> twoVoltamperesReactive = ReactivePower<double>.FromVoltamperesReactive(2);
 
             Assert.True(oneVoltampereReactive < twoVoltamperesReactive);
             Assert.True(oneVoltampereReactive <= twoVoltamperesReactive);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ReactivePower voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
             Assert.Equal(0, voltamperereactive.CompareTo(voltamperereactive));
-            Assert.True(voltamperereactive.CompareTo(ReactivePower.Zero) > 0);
-            Assert.True(ReactivePower.Zero.CompareTo(voltamperereactive) < 0);
+            Assert.True(voltamperereactive.CompareTo(ReactivePower<double>.Zero) > 0);
+            Assert.True(ReactivePower<double>.Zero.CompareTo(voltamperereactive) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ReactivePower voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
             Assert.Throws<ArgumentException>(() => voltamperereactive.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ReactivePower voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
             Assert.Throws<ArgumentNullException>(() => voltamperereactive.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ReactivePower.FromVoltamperesReactive(1);
-            var b = ReactivePower.FromVoltamperesReactive(2);
+            var a = ReactivePower<double>.FromVoltamperesReactive(1);
+            var b = ReactivePower<double>.FromVoltamperesReactive(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ReactivePower.FromVoltamperesReactive(1);
-            var b = ReactivePower.FromVoltamperesReactive(2);
+            var a = ReactivePower<double>.FromVoltamperesReactive(1);
+            var b = ReactivePower<double>.FromVoltamperesReactive(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ReactivePower.FromVoltamperesReactive(1);
-            Assert.True(v.Equals(ReactivePower.FromVoltamperesReactive(1), VoltamperesReactiveTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ReactivePower.Zero, VoltamperesReactiveTolerance, ComparisonType.Relative));
+            var v = ReactivePower<double>.FromVoltamperesReactive(1);
+            Assert.True(v.Equals(ReactivePower<double>.FromVoltamperesReactive(1), VoltamperesReactiveTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ReactivePower<double>.Zero, VoltamperesReactiveTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ReactivePower voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
             Assert.False(voltamperereactive.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ReactivePower voltamperereactive = ReactivePower.FromVoltamperesReactive(1);
+            ReactivePower<double> voltamperereactive = ReactivePower<double>.FromVoltamperesReactive(1);
             Assert.False(voltamperereactive.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ReactivePowerUnit.Undefined, ReactivePower.Units);
+            Assert.DoesNotContain(ReactivePowerUnit.Undefined, ReactivePower<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ReactivePower.BaseDimensions is null);
+            Assert.False(ReactivePower<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs
index d535e4e0c2..795386a92c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class RelativeHumidityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RelativeHumidity((double)0.0, RelativeHumidityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new RelativeHumidity<double>((double)0.0, RelativeHumidityUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RelativeHumidity(double.PositiveInfinity, RelativeHumidityUnit.Percent));
-            Assert.Throws<ArgumentException>(() => new RelativeHumidity(double.NegativeInfinity, RelativeHumidityUnit.Percent));
+            Assert.Throws<ArgumentException>(() => new RelativeHumidity<double>(double.PositiveInfinity, RelativeHumidityUnit.Percent));
+            Assert.Throws<ArgumentException>(() => new RelativeHumidity<double>(double.NegativeInfinity, RelativeHumidityUnit.Percent));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RelativeHumidity(double.NaN, RelativeHumidityUnit.Percent));
+            Assert.Throws<ArgumentException>(() => new RelativeHumidity<double>(double.NaN, RelativeHumidityUnit.Percent));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void RelativeHumidity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
         [Fact]
         public void PercentToRelativeHumidityUnits()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
+            RelativeHumidity<double> percent = RelativeHumidity<double>.FromPercent(1);
             AssertEx.EqualTolerance(PercentInOnePercent, percent.Percent, PercentTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = RelativeHumidity.From(1, RelativeHumidityUnit.Percent);
+            var quantity00 = RelativeHumidity<double>.From(1, RelativeHumidityUnit.Percent);
             AssertEx.EqualTolerance(1, quantity00.Percent, PercentTolerance);
             Assert.Equal(RelativeHumidityUnit.Percent, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromPercent_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RelativeHumidity.FromPercent(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => RelativeHumidity.FromPercent(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => RelativeHumidity<double>.FromPercent(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RelativeHumidity<double>.FromPercent(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromPercent_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RelativeHumidity.FromPercent(double.NaN));
+            Assert.Throws<ArgumentException>(() => RelativeHumidity<double>.FromPercent(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var percent = RelativeHumidity.FromPercent(1);
+            var percent = RelativeHumidity<double>.FromPercent(1);
             AssertEx.EqualTolerance(PercentInOnePercent, percent.As(RelativeHumidityUnit.Percent), PercentTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var percent = RelativeHumidity.FromPercent(1);
+            var percent = RelativeHumidity<double>.FromPercent(1);
 
             var percentQuantity = percent.ToUnit(RelativeHumidityUnit.Percent);
             AssertEx.EqualTolerance(PercentInOnePercent, (double)percentQuantity.Value, PercentTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
-            AssertEx.EqualTolerance(1, RelativeHumidity.FromPercent(percent.Percent).Percent, PercentTolerance);
+            RelativeHumidity<double> percent = RelativeHumidity<double>.FromPercent(1);
+            AssertEx.EqualTolerance(1, RelativeHumidity<double>.FromPercent(percent.Percent).Percent, PercentTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            RelativeHumidity v = RelativeHumidity.FromPercent(1);
+            RelativeHumidity<double> v = RelativeHumidity<double>.FromPercent(1);
             AssertEx.EqualTolerance(-1, -v.Percent, PercentTolerance);
-            AssertEx.EqualTolerance(2, (RelativeHumidity.FromPercent(3)-v).Percent, PercentTolerance);
+            AssertEx.EqualTolerance(2, (RelativeHumidity<double>.FromPercent(3)-v).Percent, PercentTolerance);
             AssertEx.EqualTolerance(2, (v + v).Percent, PercentTolerance);
             AssertEx.EqualTolerance(10, (v*10).Percent, PercentTolerance);
             AssertEx.EqualTolerance(10, (10*v).Percent, PercentTolerance);
-            AssertEx.EqualTolerance(2, (RelativeHumidity.FromPercent(10)/5).Percent, PercentTolerance);
-            AssertEx.EqualTolerance(2, RelativeHumidity.FromPercent(10)/RelativeHumidity.FromPercent(5), PercentTolerance);
+            AssertEx.EqualTolerance(2, (RelativeHumidity<double>.FromPercent(10)/5).Percent, PercentTolerance);
+            AssertEx.EqualTolerance(2, RelativeHumidity<double>.FromPercent(10)/RelativeHumidity<double>.FromPercent(5), PercentTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            RelativeHumidity onePercent = RelativeHumidity.FromPercent(1);
-            RelativeHumidity twoPercent = RelativeHumidity.FromPercent(2);
+            RelativeHumidity<double> onePercent = RelativeHumidity<double>.FromPercent(1);
+            RelativeHumidity<double> twoPercent = RelativeHumidity<double>.FromPercent(2);
 
             Assert.True(onePercent < twoPercent);
             Assert.True(onePercent <= twoPercent);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
+            RelativeHumidity<double> percent = RelativeHumidity<double>.FromPercent(1);
             Assert.Equal(0, percent.CompareTo(percent));
-            Assert.True(percent.CompareTo(RelativeHumidity.Zero) > 0);
-            Assert.True(RelativeHumidity.Zero.CompareTo(percent) < 0);
+            Assert.True(percent.CompareTo(RelativeHumidity<double>.Zero) > 0);
+            Assert.True(RelativeHumidity<double>.Zero.CompareTo(percent) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
+            RelativeHumidity<double> percent = RelativeHumidity<double>.FromPercent(1);
             Assert.Throws<ArgumentException>(() => percent.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
+            RelativeHumidity<double> percent = RelativeHumidity<double>.FromPercent(1);
             Assert.Throws<ArgumentNullException>(() => percent.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = RelativeHumidity.FromPercent(1);
-            var b = RelativeHumidity.FromPercent(2);
+            var a = RelativeHumidity<double>.FromPercent(1);
+            var b = RelativeHumidity<double>.FromPercent(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = RelativeHumidity.FromPercent(1);
-            var b = RelativeHumidity.FromPercent(2);
+            var a = RelativeHumidity<double>.FromPercent(1);
+            var b = RelativeHumidity<double>.FromPercent(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = RelativeHumidity.FromPercent(1);
-            Assert.True(v.Equals(RelativeHumidity.FromPercent(1), PercentTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(RelativeHumidity.Zero, PercentTolerance, ComparisonType.Relative));
+            var v = RelativeHumidity<double>.FromPercent(1);
+            Assert.True(v.Equals(RelativeHumidity<double>.FromPercent(1), PercentTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RelativeHumidity<double>.Zero, PercentTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
+            RelativeHumidity<double> percent = RelativeHumidity<double>.FromPercent(1);
             Assert.False(percent.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
+            RelativeHumidity<double> percent = RelativeHumidity<double>.FromPercent(1);
             Assert.False(percent.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(RelativeHumidityUnit.Undefined, RelativeHumidity.Units);
+            Assert.DoesNotContain(RelativeHumidityUnit.Undefined, RelativeHumidity<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(RelativeHumidity.BaseDimensions is null);
+            Assert.False(RelativeHumidity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs
index 2f5cf84c57..c0867eae45 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs
@@ -52,7 +52,7 @@ public abstract partial class RotationalAccelerationTestsBase : QuantityTestsBas
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalAcceleration((double)0.0, RotationalAccelerationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>((double)0.0, RotationalAccelerationUnit.Undefined));
         }
 
         [Fact]
@@ -67,14 +67,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalAcceleration(double.PositiveInfinity, RotationalAccelerationUnit.RadianPerSecondSquared));
-            Assert.Throws<ArgumentException>(() => new RotationalAcceleration(double.NegativeInfinity, RotationalAccelerationUnit.RadianPerSecondSquared));
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>(double.PositiveInfinity, RotationalAccelerationUnit.RadianPerSecondSquared));
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>(double.NegativeInfinity, RotationalAccelerationUnit.RadianPerSecondSquared));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalAcceleration(double.NaN, RotationalAccelerationUnit.RadianPerSecondSquared));
+            Assert.Throws<ArgumentException>(() => new RotationalAcceleration<double>(double.NaN, RotationalAccelerationUnit.RadianPerSecondSquared));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void RotationalAcceleration_QuantityInfo_ReturnsQuantityInfoDescribingQua
         [Fact]
         public void RadianPerSecondSquaredToRotationalAccelerationUnits()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.DegreesPerSecondSquared, DegreesPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(RadiansPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared, radianpersecondsquared.RevolutionsPerMinutePerSecond, RevolutionsPerMinutePerSecondTolerance);
@@ -130,19 +130,19 @@ public void RadianPerSecondSquaredToRotationalAccelerationUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = RotationalAcceleration.From(1, RotationalAccelerationUnit.DegreePerSecondSquared);
+            var quantity00 = RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.DegreePerSecondSquared);
             AssertEx.EqualTolerance(1, quantity00.DegreesPerSecondSquared, DegreesPerSecondSquaredTolerance);
             Assert.Equal(RotationalAccelerationUnit.DegreePerSecondSquared, quantity00.Unit);
 
-            var quantity01 = RotationalAcceleration.From(1, RotationalAccelerationUnit.RadianPerSecondSquared);
+            var quantity01 = RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.RadianPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity01.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
             Assert.Equal(RotationalAccelerationUnit.RadianPerSecondSquared, quantity01.Unit);
 
-            var quantity02 = RotationalAcceleration.From(1, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
+            var quantity02 = RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
             AssertEx.EqualTolerance(1, quantity02.RevolutionsPerMinutePerSecond, RevolutionsPerMinutePerSecondTolerance);
             Assert.Equal(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, quantity02.Unit);
 
-            var quantity03 = RotationalAcceleration.From(1, RotationalAccelerationUnit.RevolutionPerSecondSquared);
+            var quantity03 = RotationalAcceleration<double>.From(1, RotationalAccelerationUnit.RevolutionPerSecondSquared);
             AssertEx.EqualTolerance(1, quantity03.RevolutionsPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
             Assert.Equal(RotationalAccelerationUnit.RevolutionPerSecondSquared, quantity03.Unit);
 
@@ -151,20 +151,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromRadiansPerSecondSquared_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalAcceleration.FromRadiansPerSecondSquared(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => RotationalAcceleration.FromRadiansPerSecondSquared(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalAcceleration<double>.FromRadiansPerSecondSquared(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalAcceleration<double>.FromRadiansPerSecondSquared(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromRadiansPerSecondSquared_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalAcceleration.FromRadiansPerSecondSquared(double.NaN));
+            Assert.Throws<ArgumentException>(() => RotationalAcceleration<double>.FromRadiansPerSecondSquared(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            var radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.DegreePerSecondSquared), DegreesPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(RadiansPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RadianPerSecondSquared), RadiansPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond), RevolutionsPerMinutePerSecondTolerance);
@@ -191,7 +191,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            var radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
 
             var degreepersecondsquaredQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared);
             AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, (double)degreepersecondsquaredQuantity.Value, DegreesPerSecondSquaredTolerance);
@@ -220,31 +220,31 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromDegreesPerSecondSquared(radianpersecondsquared.DegreesPerSecondSquared).RadiansPerSecondSquared, DegreesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromRadiansPerSecondSquared(radianpersecondsquared.RadiansPerSecondSquared).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromRevolutionsPerMinutePerSecond(radianpersecondsquared.RevolutionsPerMinutePerSecond).RadiansPerSecondSquared, RevolutionsPerMinutePerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromRevolutionsPerSecondSquared(radianpersecondsquared.RevolutionsPerSecondSquared).RadiansPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromDegreesPerSecondSquared(radianpersecondsquared.DegreesPerSecondSquared).RadiansPerSecondSquared, DegreesPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromRadiansPerSecondSquared(radianpersecondsquared.RadiansPerSecondSquared).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromRevolutionsPerMinutePerSecond(radianpersecondsquared.RevolutionsPerMinutePerSecond).RadiansPerSecondSquared, RevolutionsPerMinutePerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalAcceleration<double>.FromRevolutionsPerSecondSquared(radianpersecondsquared.RevolutionsPerSecondSquared).RadiansPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            RotationalAcceleration v = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> v = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             AssertEx.EqualTolerance(-1, -v.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (RotationalAcceleration.FromRadiansPerSecondSquared(3)-v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (RotationalAcceleration<double>.FromRadiansPerSecondSquared(3)-v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(2, (v + v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(10, (v*10).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(10, (10*v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (RotationalAcceleration.FromRadiansPerSecondSquared(10)/5).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, RotationalAcceleration.FromRadiansPerSecondSquared(10)/RotationalAcceleration.FromRadiansPerSecondSquared(5), RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (RotationalAcceleration<double>.FromRadiansPerSecondSquared(10)/5).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, RotationalAcceleration<double>.FromRadiansPerSecondSquared(10)/RotationalAcceleration<double>.FromRadiansPerSecondSquared(5), RadiansPerSecondSquaredTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            RotationalAcceleration oneRadianPerSecondSquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            RotationalAcceleration twoRadiansPerSecondSquared = RotationalAcceleration.FromRadiansPerSecondSquared(2);
+            RotationalAcceleration<double> oneRadianPerSecondSquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> twoRadiansPerSecondSquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(2);
 
             Assert.True(oneRadianPerSecondSquared < twoRadiansPerSecondSquared);
             Assert.True(oneRadianPerSecondSquared <= twoRadiansPerSecondSquared);
@@ -260,31 +260,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             Assert.Equal(0, radianpersecondsquared.CompareTo(radianpersecondsquared));
-            Assert.True(radianpersecondsquared.CompareTo(RotationalAcceleration.Zero) > 0);
-            Assert.True(RotationalAcceleration.Zero.CompareTo(radianpersecondsquared) < 0);
+            Assert.True(radianpersecondsquared.CompareTo(RotationalAcceleration<double>.Zero) > 0);
+            Assert.True(RotationalAcceleration<double>.Zero.CompareTo(radianpersecondsquared) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             Assert.Throws<ArgumentException>(() => radianpersecondsquared.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             Assert.Throws<ArgumentNullException>(() => radianpersecondsquared.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            var b = RotationalAcceleration.FromRadiansPerSecondSquared(2);
+            var a = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            var b = RotationalAcceleration<double>.FromRadiansPerSecondSquared(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -303,8 +303,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            var b = RotationalAcceleration.FromRadiansPerSecondSquared(2);
+            var a = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            var b = RotationalAcceleration<double>.FromRadiansPerSecondSquared(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -324,9 +324,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            Assert.True(v.Equals(RotationalAcceleration.FromRadiansPerSecondSquared(1), RadiansPerSecondSquaredTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(RotationalAcceleration.Zero, RadiansPerSecondSquaredTolerance, ComparisonType.Relative));
+            var v = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
+            Assert.True(v.Equals(RotationalAcceleration<double>.FromRadiansPerSecondSquared(1), RadiansPerSecondSquaredTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RotationalAcceleration<double>.Zero, RadiansPerSecondSquaredTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -339,21 +339,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             Assert.False(radianpersecondsquared.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
+            RotationalAcceleration<double> radianpersecondsquared = RotationalAcceleration<double>.FromRadiansPerSecondSquared(1);
             Assert.False(radianpersecondsquared.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(RotationalAccelerationUnit.Undefined, RotationalAcceleration.Units);
+            Assert.DoesNotContain(RotationalAccelerationUnit.Undefined, RotationalAcceleration<double>.Units);
         }
 
         [Fact]
@@ -372,7 +372,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(RotationalAcceleration.BaseDimensions is null);
+            Assert.False(RotationalAcceleration<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs
index 85cb84910a..3d92c262e8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs
@@ -70,7 +70,7 @@ public abstract partial class RotationalSpeedTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalSpeed((double)0.0, RotationalSpeedUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new RotationalSpeed<double>((double)0.0, RotationalSpeedUnit.Undefined));
         }
 
         [Fact]
@@ -85,14 +85,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalSpeed(double.PositiveInfinity, RotationalSpeedUnit.RadianPerSecond));
-            Assert.Throws<ArgumentException>(() => new RotationalSpeed(double.NegativeInfinity, RotationalSpeedUnit.RadianPerSecond));
+            Assert.Throws<ArgumentException>(() => new RotationalSpeed<double>(double.PositiveInfinity, RotationalSpeedUnit.RadianPerSecond));
+            Assert.Throws<ArgumentException>(() => new RotationalSpeed<double>(double.NegativeInfinity, RotationalSpeedUnit.RadianPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalSpeed(double.NaN, RotationalSpeedUnit.RadianPerSecond));
+            Assert.Throws<ArgumentException>(() => new RotationalSpeed<double>(double.NaN, RotationalSpeedUnit.RadianPerSecond));
         }
 
         [Fact]
@@ -138,7 +138,7 @@ public void RotationalSpeed_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void RadianPerSecondToRotationalSpeedUnits()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            RotationalSpeed<double> radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
             AssertEx.EqualTolerance(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.CentiradiansPerSecond, CentiradiansPerSecondTolerance);
             AssertEx.EqualTolerance(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.DeciradiansPerSecond, DeciradiansPerSecondTolerance);
             AssertEx.EqualTolerance(DegreesPerMinuteInOneRadianPerSecond, radianpersecond.DegreesPerMinute, DegreesPerMinuteTolerance);
@@ -157,55 +157,55 @@ public void RadianPerSecondToRotationalSpeedUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond);
+            var quantity00 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.CentiradianPerSecond);
             AssertEx.EqualTolerance(1, quantity00.CentiradiansPerSecond, CentiradiansPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.CentiradianPerSecond, quantity00.Unit);
 
-            var quantity01 = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond);
+            var quantity01 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.DeciradianPerSecond);
             AssertEx.EqualTolerance(1, quantity01.DeciradiansPerSecond, DeciradiansPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.DeciradianPerSecond, quantity01.Unit);
 
-            var quantity02 = RotationalSpeed.From(1, RotationalSpeedUnit.DegreePerMinute);
+            var quantity02 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.DegreePerMinute);
             AssertEx.EqualTolerance(1, quantity02.DegreesPerMinute, DegreesPerMinuteTolerance);
             Assert.Equal(RotationalSpeedUnit.DegreePerMinute, quantity02.Unit);
 
-            var quantity03 = RotationalSpeed.From(1, RotationalSpeedUnit.DegreePerSecond);
+            var quantity03 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.DegreePerSecond);
             AssertEx.EqualTolerance(1, quantity03.DegreesPerSecond, DegreesPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.DegreePerSecond, quantity03.Unit);
 
-            var quantity04 = RotationalSpeed.From(1, RotationalSpeedUnit.MicrodegreePerSecond);
+            var quantity04 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.MicrodegreePerSecond);
             AssertEx.EqualTolerance(1, quantity04.MicrodegreesPerSecond, MicrodegreesPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.MicrodegreePerSecond, quantity04.Unit);
 
-            var quantity05 = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond);
+            var quantity05 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.MicroradianPerSecond);
             AssertEx.EqualTolerance(1, quantity05.MicroradiansPerSecond, MicroradiansPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.MicroradianPerSecond, quantity05.Unit);
 
-            var quantity06 = RotationalSpeed.From(1, RotationalSpeedUnit.MillidegreePerSecond);
+            var quantity06 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.MillidegreePerSecond);
             AssertEx.EqualTolerance(1, quantity06.MillidegreesPerSecond, MillidegreesPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.MillidegreePerSecond, quantity06.Unit);
 
-            var quantity07 = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond);
+            var quantity07 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.MilliradianPerSecond);
             AssertEx.EqualTolerance(1, quantity07.MilliradiansPerSecond, MilliradiansPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.MilliradianPerSecond, quantity07.Unit);
 
-            var quantity08 = RotationalSpeed.From(1, RotationalSpeedUnit.NanodegreePerSecond);
+            var quantity08 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.NanodegreePerSecond);
             AssertEx.EqualTolerance(1, quantity08.NanodegreesPerSecond, NanodegreesPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.NanodegreePerSecond, quantity08.Unit);
 
-            var quantity09 = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond);
+            var quantity09 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.NanoradianPerSecond);
             AssertEx.EqualTolerance(1, quantity09.NanoradiansPerSecond, NanoradiansPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.NanoradianPerSecond, quantity09.Unit);
 
-            var quantity10 = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond);
+            var quantity10 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.RadianPerSecond);
             AssertEx.EqualTolerance(1, quantity10.RadiansPerSecond, RadiansPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.RadianPerSecond, quantity10.Unit);
 
-            var quantity11 = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute);
+            var quantity11 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.RevolutionPerMinute);
             AssertEx.EqualTolerance(1, quantity11.RevolutionsPerMinute, RevolutionsPerMinuteTolerance);
             Assert.Equal(RotationalSpeedUnit.RevolutionPerMinute, quantity11.Unit);
 
-            var quantity12 = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond);
+            var quantity12 = RotationalSpeed<double>.From(1, RotationalSpeedUnit.RevolutionPerSecond);
             AssertEx.EqualTolerance(1, quantity12.RevolutionsPerSecond, RevolutionsPerSecondTolerance);
             Assert.Equal(RotationalSpeedUnit.RevolutionPerSecond, quantity12.Unit);
 
@@ -214,20 +214,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromRadiansPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalSpeed.FromRadiansPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => RotationalSpeed.FromRadiansPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalSpeed<double>.FromRadiansPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalSpeed<double>.FromRadiansPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromRadiansPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalSpeed.FromRadiansPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => RotationalSpeed<double>.FromRadiansPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            var radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
             AssertEx.EqualTolerance(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.CentiradianPerSecond), CentiradiansPerSecondTolerance);
             AssertEx.EqualTolerance(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.DeciradianPerSecond), DeciradiansPerSecondTolerance);
             AssertEx.EqualTolerance(DegreesPerMinuteInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.DegreePerMinute), DegreesPerMinuteTolerance);
@@ -263,7 +263,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            var radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
 
             var centiradianpersecondQuantity = radianpersecond.ToUnit(RotationalSpeedUnit.CentiradianPerSecond);
             AssertEx.EqualTolerance(CentiradiansPerSecondInOneRadianPerSecond, (double)centiradianpersecondQuantity.Value, CentiradiansPerSecondTolerance);
@@ -328,40 +328,40 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromCentiradiansPerSecond(radianpersecond.CentiradiansPerSecond).RadiansPerSecond, CentiradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromDeciradiansPerSecond(radianpersecond.DeciradiansPerSecond).RadiansPerSecond, DeciradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromDegreesPerMinute(radianpersecond.DegreesPerMinute).RadiansPerSecond, DegreesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromDegreesPerSecond(radianpersecond.DegreesPerSecond).RadiansPerSecond, DegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMicrodegreesPerSecond(radianpersecond.MicrodegreesPerSecond).RadiansPerSecond, MicrodegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond, MicroradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMillidegreesPerSecond(radianpersecond.MillidegreesPerSecond).RadiansPerSecond, MillidegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond, MilliradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromNanodegreesPerSecond(radianpersecond.NanodegreesPerSecond).RadiansPerSecond, NanodegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromNanoradiansPerSecond(radianpersecond.NanoradiansPerSecond).RadiansPerSecond, NanoradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromRadiansPerSecond(radianpersecond.RadiansPerSecond).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromRevolutionsPerMinute(radianpersecond.RevolutionsPerMinute).RadiansPerSecond, RevolutionsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromRevolutionsPerSecond(radianpersecond.RevolutionsPerSecond).RadiansPerSecond, RevolutionsPerSecondTolerance);
+            RotationalSpeed<double> radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromCentiradiansPerSecond(radianpersecond.CentiradiansPerSecond).RadiansPerSecond, CentiradiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromDeciradiansPerSecond(radianpersecond.DeciradiansPerSecond).RadiansPerSecond, DeciradiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromDegreesPerMinute(radianpersecond.DegreesPerMinute).RadiansPerSecond, DegreesPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromDegreesPerSecond(radianpersecond.DegreesPerSecond).RadiansPerSecond, DegreesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromMicrodegreesPerSecond(radianpersecond.MicrodegreesPerSecond).RadiansPerSecond, MicrodegreesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond, MicroradiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromMillidegreesPerSecond(radianpersecond.MillidegreesPerSecond).RadiansPerSecond, MillidegreesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond, MilliradiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromNanodegreesPerSecond(radianpersecond.NanodegreesPerSecond).RadiansPerSecond, NanodegreesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromNanoradiansPerSecond(radianpersecond.NanoradiansPerSecond).RadiansPerSecond, NanoradiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromRadiansPerSecond(radianpersecond.RadiansPerSecond).RadiansPerSecond, RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromRevolutionsPerMinute(radianpersecond.RevolutionsPerMinute).RadiansPerSecond, RevolutionsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, RotationalSpeed<double>.FromRevolutionsPerSecond(radianpersecond.RevolutionsPerSecond).RadiansPerSecond, RevolutionsPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            RotationalSpeed v = RotationalSpeed.FromRadiansPerSecond(1);
+            RotationalSpeed<double> v = RotationalSpeed<double>.FromRadiansPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RotationalSpeed.FromRadiansPerSecond(3)-v).RadiansPerSecond, RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (RotationalSpeed<double>.FromRadiansPerSecond(3)-v).RadiansPerSecond, RadiansPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).RadiansPerSecond, RadiansPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).RadiansPerSecond, RadiansPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RotationalSpeed.FromRadiansPerSecond(10)/5).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(2, RotationalSpeed.FromRadiansPerSecond(10)/RotationalSpeed.FromRadiansPerSecond(5), RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (RotationalSpeed<double>.FromRadiansPerSecond(10)/5).RadiansPerSecond, RadiansPerSecondTolerance);
+            AssertEx.EqualTolerance(2, RotationalSpeed<double>.FromRadiansPerSecond(10)/RotationalSpeed<double>.FromRadiansPerSecond(5), RadiansPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            RotationalSpeed oneRadianPerSecond = RotationalSpeed.FromRadiansPerSecond(1);
-            RotationalSpeed twoRadiansPerSecond = RotationalSpeed.FromRadiansPerSecond(2);
+            RotationalSpeed<double> oneRadianPerSecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
+            RotationalSpeed<double> twoRadiansPerSecond = RotationalSpeed<double>.FromRadiansPerSecond(2);
 
             Assert.True(oneRadianPerSecond < twoRadiansPerSecond);
             Assert.True(oneRadianPerSecond <= twoRadiansPerSecond);
@@ -377,31 +377,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            RotationalSpeed<double> radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
             Assert.Equal(0, radianpersecond.CompareTo(radianpersecond));
-            Assert.True(radianpersecond.CompareTo(RotationalSpeed.Zero) > 0);
-            Assert.True(RotationalSpeed.Zero.CompareTo(radianpersecond) < 0);
+            Assert.True(radianpersecond.CompareTo(RotationalSpeed<double>.Zero) > 0);
+            Assert.True(RotationalSpeed<double>.Zero.CompareTo(radianpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            RotationalSpeed<double> radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
             Assert.Throws<ArgumentException>(() => radianpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            RotationalSpeed<double> radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => radianpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = RotationalSpeed.FromRadiansPerSecond(1);
-            var b = RotationalSpeed.FromRadiansPerSecond(2);
+            var a = RotationalSpeed<double>.FromRadiansPerSecond(1);
+            var b = RotationalSpeed<double>.FromRadiansPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -420,8 +420,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = RotationalSpeed.FromRadiansPerSecond(1);
-            var b = RotationalSpeed.FromRadiansPerSecond(2);
+            var a = RotationalSpeed<double>.FromRadiansPerSecond(1);
+            var b = RotationalSpeed<double>.FromRadiansPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -441,9 +441,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = RotationalSpeed.FromRadiansPerSecond(1);
-            Assert.True(v.Equals(RotationalSpeed.FromRadiansPerSecond(1), RadiansPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(RotationalSpeed.Zero, RadiansPerSecondTolerance, ComparisonType.Relative));
+            var v = RotationalSpeed<double>.FromRadiansPerSecond(1);
+            Assert.True(v.Equals(RotationalSpeed<double>.FromRadiansPerSecond(1), RadiansPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RotationalSpeed<double>.Zero, RadiansPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -456,21 +456,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            RotationalSpeed<double> radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
             Assert.False(radianpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
+            RotationalSpeed<double> radianpersecond = RotationalSpeed<double>.FromRadiansPerSecond(1);
             Assert.False(radianpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(RotationalSpeedUnit.Undefined, RotationalSpeed.Units);
+            Assert.DoesNotContain(RotationalSpeedUnit.Undefined, RotationalSpeed<double>.Units);
         }
 
         [Fact]
@@ -489,7 +489,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(RotationalSpeed.BaseDimensions is null);
+            Assert.False(RotationalSpeed<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs
index da6db73bf0..c22145afcc 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs
@@ -54,7 +54,7 @@ public abstract partial class RotationalStiffnessPerLengthTestsBase : QuantityTe
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength((double)0.0, RotationalStiffnessPerLengthUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>((double)0.0, RotationalStiffnessPerLengthUnit.Undefined));
         }
 
         [Fact]
@@ -69,14 +69,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength(double.PositiveInfinity, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
-            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength(double.NegativeInfinity, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>(double.PositiveInfinity, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>(double.NegativeInfinity, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength(double.NaN, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffnessPerLength<double>(double.NaN, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
         }
 
         [Fact]
@@ -122,7 +122,7 @@ public void RotationalStiffnessPerLength_QuantityInfo_ReturnsQuantityInfoDescrib
         [Fact]
         public void NewtonMeterPerRadianPerMeterToRotationalStiffnessPerLengthUnits()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             AssertEx.EqualTolerance(KilonewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.KilonewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
             AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesPerFeetInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.KilopoundForceFeetPerDegreesPerFeet, KilopoundForceFeetPerDegreesPerFeetTolerance);
             AssertEx.EqualTolerance(MeganewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.MeganewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
@@ -133,23 +133,23 @@ public void NewtonMeterPerRadianPerMeterToRotationalStiffnessPerLengthUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = RotationalStiffnessPerLength.From(1, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
+            var quantity00 = RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
             AssertEx.EqualTolerance(1, quantity00.KilonewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
             Assert.Equal(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, quantity00.Unit);
 
-            var quantity01 = RotationalStiffnessPerLength.From(1, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
+            var quantity01 = RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
             AssertEx.EqualTolerance(1, quantity01.KilopoundForceFeetPerDegreesPerFeet, KilopoundForceFeetPerDegreesPerFeetTolerance);
             Assert.Equal(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, quantity01.Unit);
 
-            var quantity02 = RotationalStiffnessPerLength.From(1, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
+            var quantity02 = RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
             AssertEx.EqualTolerance(1, quantity02.MeganewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
             Assert.Equal(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, quantity02.Unit);
 
-            var quantity03 = RotationalStiffnessPerLength.From(1, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
+            var quantity03 = RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
             AssertEx.EqualTolerance(1, quantity03.NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
             Assert.Equal(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, quantity03.Unit);
 
-            var quantity04 = RotationalStiffnessPerLength.From(1, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
+            var quantity04 = RotationalStiffnessPerLength<double>.From(1, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
             AssertEx.EqualTolerance(1, quantity04.PoundForceFeetPerDegreesPerFeet, PoundForceFeetPerDegreesPerFeetTolerance);
             Assert.Equal(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, quantity04.Unit);
 
@@ -158,20 +158,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonMetersPerRadianPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonMetersPerRadianPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            var newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             AssertEx.EqualTolerance(KilonewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.As(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter), KilonewtonMetersPerRadianPerMeterTolerance);
             AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesPerFeetInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.As(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot), KilopoundForceFeetPerDegreesPerFeetTolerance);
             AssertEx.EqualTolerance(MeganewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, newtonmeterperradianpermeter.As(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter), MeganewtonMetersPerRadianPerMeterTolerance);
@@ -199,7 +199,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            var newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
 
             var kilonewtonmeterperradianpermeterQuantity = newtonmeterperradianpermeter.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
             AssertEx.EqualTolerance(KilonewtonMetersPerRadianPerMeterInOneNewtonMeterPerRadianPerMeter, (double)kilonewtonmeterperradianpermeterQuantity.Value, KilonewtonMetersPerRadianPerMeterTolerance);
@@ -232,32 +232,32 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.KilonewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.KilopoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter, KilopoundForceFeetPerDegreesPerFeetTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.MeganewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.NewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.PoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter, PoundForceFeetPerDegreesPerFeetTolerance);
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromKilonewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.KilonewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromKilopoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.KilopoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter, KilopoundForceFeetPerDegreesPerFeetTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromMeganewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.MeganewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.NewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength<double>.FromPoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.PoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter, PoundForceFeetPerDegreesPerFeetTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            RotationalStiffnessPerLength v = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> v = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(3)-v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(3)-v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10)/5).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(2, RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10)/RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(5), NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(10)/5).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
+            AssertEx.EqualTolerance(2, RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(10)/RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(5), NewtonMetersPerRadianPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            RotationalStiffnessPerLength oneNewtonMeterPerRadianPerMeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
-            RotationalStiffnessPerLength twoNewtonMetersPerRadianPerMeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2);
+            RotationalStiffnessPerLength<double> oneNewtonMeterPerRadianPerMeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> twoNewtonMetersPerRadianPerMeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(2);
 
             Assert.True(oneNewtonMeterPerRadianPerMeter < twoNewtonMetersPerRadianPerMeter);
             Assert.True(oneNewtonMeterPerRadianPerMeter <= twoNewtonMetersPerRadianPerMeter);
@@ -273,31 +273,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             Assert.Equal(0, newtonmeterperradianpermeter.CompareTo(newtonmeterperradianpermeter));
-            Assert.True(newtonmeterperradianpermeter.CompareTo(RotationalStiffnessPerLength.Zero) > 0);
-            Assert.True(RotationalStiffnessPerLength.Zero.CompareTo(newtonmeterperradianpermeter) < 0);
+            Assert.True(newtonmeterperradianpermeter.CompareTo(RotationalStiffnessPerLength<double>.Zero) > 0);
+            Assert.True(RotationalStiffnessPerLength<double>.Zero.CompareTo(newtonmeterperradianpermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             Assert.Throws<ArgumentException>(() => newtonmeterperradianpermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => newtonmeterperradianpermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
-            var b = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2);
+            var a = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            var b = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -316,8 +316,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
-            var b = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2);
+            var a = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            var b = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -337,9 +337,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
-            Assert.True(v.Equals(RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1), NewtonMetersPerRadianPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(RotationalStiffnessPerLength.Zero, NewtonMetersPerRadianPerMeterTolerance, ComparisonType.Relative));
+            var v = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
+            Assert.True(v.Equals(RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1), NewtonMetersPerRadianPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RotationalStiffnessPerLength<double>.Zero, NewtonMetersPerRadianPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -352,21 +352,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             Assert.False(newtonmeterperradianpermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
+            RotationalStiffnessPerLength<double> newtonmeterperradianpermeter = RotationalStiffnessPerLength<double>.FromNewtonMetersPerRadianPerMeter(1);
             Assert.False(newtonmeterperradianpermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(RotationalStiffnessPerLengthUnit.Undefined, RotationalStiffnessPerLength.Units);
+            Assert.DoesNotContain(RotationalStiffnessPerLengthUnit.Undefined, RotationalStiffnessPerLength<double>.Units);
         }
 
         [Fact]
@@ -385,7 +385,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(RotationalStiffnessPerLength.BaseDimensions is null);
+            Assert.False(RotationalStiffnessPerLength<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
index d3c89d6dc9..92fdff8a7f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
@@ -110,7 +110,7 @@ public abstract partial class RotationalStiffnessTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalStiffness((double)0.0, RotationalStiffnessUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>((double)0.0, RotationalStiffnessUnit.Undefined));
         }
 
         [Fact]
@@ -125,14 +125,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalStiffness(double.PositiveInfinity, RotationalStiffnessUnit.NewtonMeterPerRadian));
-            Assert.Throws<ArgumentException>(() => new RotationalStiffness(double.NegativeInfinity, RotationalStiffnessUnit.NewtonMeterPerRadian));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>(double.PositiveInfinity, RotationalStiffnessUnit.NewtonMeterPerRadian));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>(double.NegativeInfinity, RotationalStiffnessUnit.NewtonMeterPerRadian));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new RotationalStiffness(double.NaN, RotationalStiffnessUnit.NewtonMeterPerRadian));
+            Assert.Throws<ArgumentException>(() => new RotationalStiffness<double>(double.NaN, RotationalStiffnessUnit.NewtonMeterPerRadian));
         }
 
         [Fact]
@@ -178,7 +178,7 @@ public void RotationalStiffness_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void NewtonMeterPerRadianToRotationalStiffnessUnits()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             AssertEx.EqualTolerance(CentinewtonMetersPerDegreeInOneNewtonMeterPerRadian, newtonmeterperradian.CentinewtonMetersPerDegree, CentinewtonMetersPerDegreeTolerance);
             AssertEx.EqualTolerance(CentinewtonMillimetersPerDegreeInOneNewtonMeterPerRadian, newtonmeterperradian.CentinewtonMillimetersPerDegree, CentinewtonMillimetersPerDegreeTolerance);
             AssertEx.EqualTolerance(CentinewtonMillimetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.CentinewtonMillimetersPerRadian, CentinewtonMillimetersPerRadianTolerance);
@@ -217,135 +217,135 @@ public void NewtonMeterPerRadianToRotationalStiffnessUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = RotationalStiffness.From(1, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
+            var quantity00 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity00.CentinewtonMetersPerDegree, CentinewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.CentinewtonMeterPerDegree, quantity00.Unit);
 
-            var quantity01 = RotationalStiffness.From(1, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
+            var quantity01 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity01.CentinewtonMillimetersPerDegree, CentinewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, quantity01.Unit);
 
-            var quantity02 = RotationalStiffness.From(1, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
+            var quantity02 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity02.CentinewtonMillimetersPerRadian, CentinewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, quantity02.Unit);
 
-            var quantity03 = RotationalStiffness.From(1, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
+            var quantity03 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity03.DecanewtonMetersPerDegree, DecanewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.DecanewtonMeterPerDegree, quantity03.Unit);
 
-            var quantity04 = RotationalStiffness.From(1, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
+            var quantity04 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity04.DecanewtonMillimetersPerDegree, DecanewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, quantity04.Unit);
 
-            var quantity05 = RotationalStiffness.From(1, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
+            var quantity05 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity05.DecanewtonMillimetersPerRadian, DecanewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, quantity05.Unit);
 
-            var quantity06 = RotationalStiffness.From(1, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
+            var quantity06 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity06.DecinewtonMetersPerDegree, DecinewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.DecinewtonMeterPerDegree, quantity06.Unit);
 
-            var quantity07 = RotationalStiffness.From(1, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
+            var quantity07 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity07.DecinewtonMillimetersPerDegree, DecinewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, quantity07.Unit);
 
-            var quantity08 = RotationalStiffness.From(1, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
+            var quantity08 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity08.DecinewtonMillimetersPerRadian, DecinewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, quantity08.Unit);
 
-            var quantity09 = RotationalStiffness.From(1, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
+            var quantity09 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity09.KilonewtonMetersPerDegree, KilonewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.KilonewtonMeterPerDegree, quantity09.Unit);
 
-            var quantity10 = RotationalStiffness.From(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
+            var quantity10 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
             AssertEx.EqualTolerance(1, quantity10.KilonewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.KilonewtonMeterPerRadian, quantity10.Unit);
 
-            var quantity11 = RotationalStiffness.From(1, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
+            var quantity11 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity11.KilonewtonMillimetersPerDegree, KilonewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, quantity11.Unit);
 
-            var quantity12 = RotationalStiffness.From(1, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
+            var quantity12 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity12.KilonewtonMillimetersPerRadian, KilonewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, quantity12.Unit);
 
-            var quantity13 = RotationalStiffness.From(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+            var quantity13 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
             AssertEx.EqualTolerance(1, quantity13.KilopoundForceFeetPerDegrees, KilopoundForceFeetPerDegreesTolerance);
             Assert.Equal(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, quantity13.Unit);
 
-            var quantity14 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
+            var quantity14 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity14.MeganewtonMetersPerDegree, MeganewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerDegree, quantity14.Unit);
 
-            var quantity15 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+            var quantity15 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
             AssertEx.EqualTolerance(1, quantity15.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, quantity15.Unit);
 
-            var quantity16 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
+            var quantity16 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity16.MeganewtonMillimetersPerDegree, MeganewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, quantity16.Unit);
 
-            var quantity17 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
+            var quantity17 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity17.MeganewtonMillimetersPerRadian, MeganewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, quantity17.Unit);
 
-            var quantity18 = RotationalStiffness.From(1, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
+            var quantity18 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity18.MicronewtonMetersPerDegree, MicronewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.MicronewtonMeterPerDegree, quantity18.Unit);
 
-            var quantity19 = RotationalStiffness.From(1, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
+            var quantity19 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity19.MicronewtonMillimetersPerDegree, MicronewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, quantity19.Unit);
 
-            var quantity20 = RotationalStiffness.From(1, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
+            var quantity20 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity20.MicronewtonMillimetersPerRadian, MicronewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, quantity20.Unit);
 
-            var quantity21 = RotationalStiffness.From(1, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
+            var quantity21 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity21.MillinewtonMetersPerDegree, MillinewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.MillinewtonMeterPerDegree, quantity21.Unit);
 
-            var quantity22 = RotationalStiffness.From(1, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
+            var quantity22 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity22.MillinewtonMillimetersPerDegree, MillinewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, quantity22.Unit);
 
-            var quantity23 = RotationalStiffness.From(1, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
+            var quantity23 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity23.MillinewtonMillimetersPerRadian, MillinewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, quantity23.Unit);
 
-            var quantity24 = RotationalStiffness.From(1, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
+            var quantity24 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity24.NanonewtonMetersPerDegree, NanonewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.NanonewtonMeterPerDegree, quantity24.Unit);
 
-            var quantity25 = RotationalStiffness.From(1, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
+            var quantity25 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity25.NanonewtonMillimetersPerDegree, NanonewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, quantity25.Unit);
 
-            var quantity26 = RotationalStiffness.From(1, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
+            var quantity26 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity26.NanonewtonMillimetersPerRadian, NanonewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, quantity26.Unit);
 
-            var quantity27 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMeterPerDegree);
+            var quantity27 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NewtonMeterPerDegree);
             AssertEx.EqualTolerance(1, quantity27.NewtonMetersPerDegree, NewtonMetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerDegree, quantity27.Unit);
 
-            var quantity28 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMeterPerRadian);
+            var quantity28 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NewtonMeterPerRadian);
             AssertEx.EqualTolerance(1, quantity28.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, quantity28.Unit);
 
-            var quantity29 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
+            var quantity29 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
             AssertEx.EqualTolerance(1, quantity29.NewtonMillimetersPerDegree, NewtonMillimetersPerDegreeTolerance);
             Assert.Equal(RotationalStiffnessUnit.NewtonMillimeterPerDegree, quantity29.Unit);
 
-            var quantity30 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
+            var quantity30 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
             AssertEx.EqualTolerance(1, quantity30.NewtonMillimetersPerRadian, NewtonMillimetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.NewtonMillimeterPerRadian, quantity30.Unit);
 
-            var quantity31 = RotationalStiffness.From(1, RotationalStiffnessUnit.PoundForceFeetPerRadian);
+            var quantity31 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.PoundForceFeetPerRadian);
             AssertEx.EqualTolerance(1, quantity31.PoundForceFeetPerRadian, PoundForceFeetPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.PoundForceFeetPerRadian, quantity31.Unit);
 
-            var quantity32 = RotationalStiffness.From(1, RotationalStiffnessUnit.PoundForceFootPerDegrees);
+            var quantity32 = RotationalStiffness<double>.From(1, RotationalStiffnessUnit.PoundForceFootPerDegrees);
             AssertEx.EqualTolerance(1, quantity32.PoundForceFeetPerDegrees, PoundForceFeetPerDegreesTolerance);
             Assert.Equal(RotationalStiffnessUnit.PoundForceFootPerDegrees, quantity32.Unit);
 
@@ -354,20 +354,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonMetersPerRadian_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalStiffness.FromNewtonMetersPerRadian(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => RotationalStiffness.FromNewtonMetersPerRadian(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalStiffness<double>.FromNewtonMetersPerRadian(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => RotationalStiffness<double>.FromNewtonMetersPerRadian(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonMetersPerRadian_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => RotationalStiffness.FromNewtonMetersPerRadian(double.NaN));
+            Assert.Throws<ArgumentException>(() => RotationalStiffness<double>.FromNewtonMetersPerRadian(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            var newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             AssertEx.EqualTolerance(CentinewtonMetersPerDegreeInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.CentinewtonMeterPerDegree), CentinewtonMetersPerDegreeTolerance);
             AssertEx.EqualTolerance(CentinewtonMillimetersPerDegreeInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree), CentinewtonMillimetersPerDegreeTolerance);
             AssertEx.EqualTolerance(CentinewtonMillimetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian), CentinewtonMillimetersPerRadianTolerance);
@@ -423,7 +423,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            var newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
 
             var centinewtonmeterperdegreeQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.CentinewtonMeterPerDegree);
             AssertEx.EqualTolerance(CentinewtonMetersPerDegreeInOneNewtonMeterPerRadian, (double)centinewtonmeterperdegreeQuantity.Value, CentinewtonMetersPerDegreeTolerance);
@@ -568,60 +568,60 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromCentinewtonMetersPerDegree(newtonmeterperradian.CentinewtonMetersPerDegree).NewtonMetersPerRadian, CentinewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromCentinewtonMillimetersPerDegree(newtonmeterperradian.CentinewtonMillimetersPerDegree).NewtonMetersPerRadian, CentinewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromCentinewtonMillimetersPerRadian(newtonmeterperradian.CentinewtonMillimetersPerRadian).NewtonMetersPerRadian, CentinewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecanewtonMetersPerDegree(newtonmeterperradian.DecanewtonMetersPerDegree).NewtonMetersPerRadian, DecanewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecanewtonMillimetersPerDegree(newtonmeterperradian.DecanewtonMillimetersPerDegree).NewtonMetersPerRadian, DecanewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecanewtonMillimetersPerRadian(newtonmeterperradian.DecanewtonMillimetersPerRadian).NewtonMetersPerRadian, DecanewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecinewtonMetersPerDegree(newtonmeterperradian.DecinewtonMetersPerDegree).NewtonMetersPerRadian, DecinewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecinewtonMillimetersPerDegree(newtonmeterperradian.DecinewtonMillimetersPerDegree).NewtonMetersPerRadian, DecinewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecinewtonMillimetersPerRadian(newtonmeterperradian.DecinewtonMillimetersPerRadian).NewtonMetersPerRadian, DecinewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMetersPerDegree(newtonmeterperradian.KilonewtonMetersPerDegree).NewtonMetersPerRadian, KilonewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMetersPerRadian(newtonmeterperradian.KilonewtonMetersPerRadian).NewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMillimetersPerDegree(newtonmeterperradian.KilonewtonMillimetersPerDegree).NewtonMetersPerRadian, KilonewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMillimetersPerRadian(newtonmeterperradian.KilonewtonMillimetersPerRadian).NewtonMetersPerRadian, KilonewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilopoundForceFeetPerDegrees(newtonmeterperradian.KilopoundForceFeetPerDegrees).NewtonMetersPerRadian, KilopoundForceFeetPerDegreesTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMetersPerDegree(newtonmeterperradian.MeganewtonMetersPerDegree).NewtonMetersPerRadian, MeganewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMetersPerRadian(newtonmeterperradian.MeganewtonMetersPerRadian).NewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMillimetersPerDegree(newtonmeterperradian.MeganewtonMillimetersPerDegree).NewtonMetersPerRadian, MeganewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMillimetersPerRadian(newtonmeterperradian.MeganewtonMillimetersPerRadian).NewtonMetersPerRadian, MeganewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMicronewtonMetersPerDegree(newtonmeterperradian.MicronewtonMetersPerDegree).NewtonMetersPerRadian, MicronewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMicronewtonMillimetersPerDegree(newtonmeterperradian.MicronewtonMillimetersPerDegree).NewtonMetersPerRadian, MicronewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMicronewtonMillimetersPerRadian(newtonmeterperradian.MicronewtonMillimetersPerRadian).NewtonMetersPerRadian, MicronewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMillinewtonMetersPerDegree(newtonmeterperradian.MillinewtonMetersPerDegree).NewtonMetersPerRadian, MillinewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMillinewtonMillimetersPerDegree(newtonmeterperradian.MillinewtonMillimetersPerDegree).NewtonMetersPerRadian, MillinewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMillinewtonMillimetersPerRadian(newtonmeterperradian.MillinewtonMillimetersPerRadian).NewtonMetersPerRadian, MillinewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNanonewtonMetersPerDegree(newtonmeterperradian.NanonewtonMetersPerDegree).NewtonMetersPerRadian, NanonewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNanonewtonMillimetersPerDegree(newtonmeterperradian.NanonewtonMillimetersPerDegree).NewtonMetersPerRadian, NanonewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNanonewtonMillimetersPerRadian(newtonmeterperradian.NanonewtonMillimetersPerRadian).NewtonMetersPerRadian, NanonewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMetersPerDegree(newtonmeterperradian.NewtonMetersPerDegree).NewtonMetersPerRadian, NewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMetersPerRadian(newtonmeterperradian.NewtonMetersPerRadian).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMillimetersPerDegree(newtonmeterperradian.NewtonMillimetersPerDegree).NewtonMetersPerRadian, NewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMillimetersPerRadian(newtonmeterperradian.NewtonMillimetersPerRadian).NewtonMetersPerRadian, NewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromPoundForceFeetPerRadian(newtonmeterperradian.PoundForceFeetPerRadian).NewtonMetersPerRadian, PoundForceFeetPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromPoundForceFeetPerDegrees(newtonmeterperradian.PoundForceFeetPerDegrees).NewtonMetersPerRadian, PoundForceFeetPerDegreesTolerance);
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromCentinewtonMetersPerDegree(newtonmeterperradian.CentinewtonMetersPerDegree).NewtonMetersPerRadian, CentinewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromCentinewtonMillimetersPerDegree(newtonmeterperradian.CentinewtonMillimetersPerDegree).NewtonMetersPerRadian, CentinewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromCentinewtonMillimetersPerRadian(newtonmeterperradian.CentinewtonMillimetersPerRadian).NewtonMetersPerRadian, CentinewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromDecanewtonMetersPerDegree(newtonmeterperradian.DecanewtonMetersPerDegree).NewtonMetersPerRadian, DecanewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromDecanewtonMillimetersPerDegree(newtonmeterperradian.DecanewtonMillimetersPerDegree).NewtonMetersPerRadian, DecanewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromDecanewtonMillimetersPerRadian(newtonmeterperradian.DecanewtonMillimetersPerRadian).NewtonMetersPerRadian, DecanewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromDecinewtonMetersPerDegree(newtonmeterperradian.DecinewtonMetersPerDegree).NewtonMetersPerRadian, DecinewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromDecinewtonMillimetersPerDegree(newtonmeterperradian.DecinewtonMillimetersPerDegree).NewtonMetersPerRadian, DecinewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromDecinewtonMillimetersPerRadian(newtonmeterperradian.DecinewtonMillimetersPerRadian).NewtonMetersPerRadian, DecinewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromKilonewtonMetersPerDegree(newtonmeterperradian.KilonewtonMetersPerDegree).NewtonMetersPerRadian, KilonewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromKilonewtonMetersPerRadian(newtonmeterperradian.KilonewtonMetersPerRadian).NewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromKilonewtonMillimetersPerDegree(newtonmeterperradian.KilonewtonMillimetersPerDegree).NewtonMetersPerRadian, KilonewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromKilonewtonMillimetersPerRadian(newtonmeterperradian.KilonewtonMillimetersPerRadian).NewtonMetersPerRadian, KilonewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromKilopoundForceFeetPerDegrees(newtonmeterperradian.KilopoundForceFeetPerDegrees).NewtonMetersPerRadian, KilopoundForceFeetPerDegreesTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMeganewtonMetersPerDegree(newtonmeterperradian.MeganewtonMetersPerDegree).NewtonMetersPerRadian, MeganewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMeganewtonMetersPerRadian(newtonmeterperradian.MeganewtonMetersPerRadian).NewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMeganewtonMillimetersPerDegree(newtonmeterperradian.MeganewtonMillimetersPerDegree).NewtonMetersPerRadian, MeganewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMeganewtonMillimetersPerRadian(newtonmeterperradian.MeganewtonMillimetersPerRadian).NewtonMetersPerRadian, MeganewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMicronewtonMetersPerDegree(newtonmeterperradian.MicronewtonMetersPerDegree).NewtonMetersPerRadian, MicronewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMicronewtonMillimetersPerDegree(newtonmeterperradian.MicronewtonMillimetersPerDegree).NewtonMetersPerRadian, MicronewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMicronewtonMillimetersPerRadian(newtonmeterperradian.MicronewtonMillimetersPerRadian).NewtonMetersPerRadian, MicronewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMillinewtonMetersPerDegree(newtonmeterperradian.MillinewtonMetersPerDegree).NewtonMetersPerRadian, MillinewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMillinewtonMillimetersPerDegree(newtonmeterperradian.MillinewtonMillimetersPerDegree).NewtonMetersPerRadian, MillinewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromMillinewtonMillimetersPerRadian(newtonmeterperradian.MillinewtonMillimetersPerRadian).NewtonMetersPerRadian, MillinewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNanonewtonMetersPerDegree(newtonmeterperradian.NanonewtonMetersPerDegree).NewtonMetersPerRadian, NanonewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNanonewtonMillimetersPerDegree(newtonmeterperradian.NanonewtonMillimetersPerDegree).NewtonMetersPerRadian, NanonewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNanonewtonMillimetersPerRadian(newtonmeterperradian.NanonewtonMillimetersPerRadian).NewtonMetersPerRadian, NanonewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNewtonMetersPerDegree(newtonmeterperradian.NewtonMetersPerDegree).NewtonMetersPerRadian, NewtonMetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNewtonMetersPerRadian(newtonmeterperradian.NewtonMetersPerRadian).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNewtonMillimetersPerDegree(newtonmeterperradian.NewtonMillimetersPerDegree).NewtonMetersPerRadian, NewtonMillimetersPerDegreeTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromNewtonMillimetersPerRadian(newtonmeterperradian.NewtonMillimetersPerRadian).NewtonMetersPerRadian, NewtonMillimetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromPoundForceFeetPerRadian(newtonmeterperradian.PoundForceFeetPerRadian).NewtonMetersPerRadian, PoundForceFeetPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness<double>.FromPoundForceFeetPerDegrees(newtonmeterperradian.PoundForceFeetPerDegrees).NewtonMetersPerRadian, PoundForceFeetPerDegreesTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            RotationalStiffness v = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> v = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             AssertEx.EqualTolerance(-1, -v.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffness.FromNewtonMetersPerRadian(3)-v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffness<double>.FromNewtonMetersPerRadian(3)-v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffness.FromNewtonMetersPerRadian(10)/5).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(2, RotationalStiffness.FromNewtonMetersPerRadian(10)/RotationalStiffness.FromNewtonMetersPerRadian(5), NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(2, (RotationalStiffness<double>.FromNewtonMetersPerRadian(10)/5).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(2, RotationalStiffness<double>.FromNewtonMetersPerRadian(10)/RotationalStiffness<double>.FromNewtonMetersPerRadian(5), NewtonMetersPerRadianTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            RotationalStiffness oneNewtonMeterPerRadian = RotationalStiffness.FromNewtonMetersPerRadian(1);
-            RotationalStiffness twoNewtonMetersPerRadian = RotationalStiffness.FromNewtonMetersPerRadian(2);
+            RotationalStiffness<double> oneNewtonMeterPerRadian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> twoNewtonMetersPerRadian = RotationalStiffness<double>.FromNewtonMetersPerRadian(2);
 
             Assert.True(oneNewtonMeterPerRadian < twoNewtonMetersPerRadian);
             Assert.True(oneNewtonMeterPerRadian <= twoNewtonMetersPerRadian);
@@ -637,31 +637,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             Assert.Equal(0, newtonmeterperradian.CompareTo(newtonmeterperradian));
-            Assert.True(newtonmeterperradian.CompareTo(RotationalStiffness.Zero) > 0);
-            Assert.True(RotationalStiffness.Zero.CompareTo(newtonmeterperradian) < 0);
+            Assert.True(newtonmeterperradian.CompareTo(RotationalStiffness<double>.Zero) > 0);
+            Assert.True(RotationalStiffness<double>.Zero.CompareTo(newtonmeterperradian) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             Assert.Throws<ArgumentException>(() => newtonmeterperradian.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             Assert.Throws<ArgumentNullException>(() => newtonmeterperradian.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = RotationalStiffness.FromNewtonMetersPerRadian(1);
-            var b = RotationalStiffness.FromNewtonMetersPerRadian(2);
+            var a = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            var b = RotationalStiffness<double>.FromNewtonMetersPerRadian(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -680,8 +680,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = RotationalStiffness.FromNewtonMetersPerRadian(1);
-            var b = RotationalStiffness.FromNewtonMetersPerRadian(2);
+            var a = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            var b = RotationalStiffness<double>.FromNewtonMetersPerRadian(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -701,9 +701,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = RotationalStiffness.FromNewtonMetersPerRadian(1);
-            Assert.True(v.Equals(RotationalStiffness.FromNewtonMetersPerRadian(1), NewtonMetersPerRadianTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(RotationalStiffness.Zero, NewtonMetersPerRadianTolerance, ComparisonType.Relative));
+            var v = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
+            Assert.True(v.Equals(RotationalStiffness<double>.FromNewtonMetersPerRadian(1), NewtonMetersPerRadianTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(RotationalStiffness<double>.Zero, NewtonMetersPerRadianTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -716,21 +716,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             Assert.False(newtonmeterperradian.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
+            RotationalStiffness<double> newtonmeterperradian = RotationalStiffness<double>.FromNewtonMetersPerRadian(1);
             Assert.False(newtonmeterperradian.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(RotationalStiffnessUnit.Undefined, RotationalStiffness.Units);
+            Assert.DoesNotContain(RotationalStiffnessUnit.Undefined, RotationalStiffness<double>.Units);
         }
 
         [Fact]
@@ -749,7 +749,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(RotationalStiffness.BaseDimensions is null);
+            Assert.False(RotationalStiffness<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs
index 65d9a0008c..8acbff5d3c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class SolidAngleTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SolidAngle((double)0.0, SolidAngleUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>((double)0.0, SolidAngleUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SolidAngle(double.PositiveInfinity, SolidAngleUnit.Steradian));
-            Assert.Throws<ArgumentException>(() => new SolidAngle(double.NegativeInfinity, SolidAngleUnit.Steradian));
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>(double.PositiveInfinity, SolidAngleUnit.Steradian));
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>(double.NegativeInfinity, SolidAngleUnit.Steradian));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SolidAngle(double.NaN, SolidAngleUnit.Steradian));
+            Assert.Throws<ArgumentException>(() => new SolidAngle<double>(double.NaN, SolidAngleUnit.Steradian));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void SolidAngle_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void SteradianToSolidAngleUnits()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
             AssertEx.EqualTolerance(SteradiansInOneSteradian, steradian.Steradians, SteradiansTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = SolidAngle.From(1, SolidAngleUnit.Steradian);
+            var quantity00 = SolidAngle<double>.From(1, SolidAngleUnit.Steradian);
             AssertEx.EqualTolerance(1, quantity00.Steradians, SteradiansTolerance);
             Assert.Equal(SolidAngleUnit.Steradian, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSteradians_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SolidAngle.FromSteradians(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => SolidAngle.FromSteradians(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => SolidAngle<double>.FromSteradians(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SolidAngle<double>.FromSteradians(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSteradians_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SolidAngle.FromSteradians(double.NaN));
+            Assert.Throws<ArgumentException>(() => SolidAngle<double>.FromSteradians(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var steradian = SolidAngle.FromSteradians(1);
+            var steradian = SolidAngle<double>.FromSteradians(1);
             AssertEx.EqualTolerance(SteradiansInOneSteradian, steradian.As(SolidAngleUnit.Steradian), SteradiansTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var steradian = SolidAngle.FromSteradians(1);
+            var steradian = SolidAngle<double>.FromSteradians(1);
 
             var steradianQuantity = steradian.ToUnit(SolidAngleUnit.Steradian);
             AssertEx.EqualTolerance(SteradiansInOneSteradian, (double)steradianQuantity.Value, SteradiansTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
-            AssertEx.EqualTolerance(1, SolidAngle.FromSteradians(steradian.Steradians).Steradians, SteradiansTolerance);
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
+            AssertEx.EqualTolerance(1, SolidAngle<double>.FromSteradians(steradian.Steradians).Steradians, SteradiansTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            SolidAngle v = SolidAngle.FromSteradians(1);
+            SolidAngle<double> v = SolidAngle<double>.FromSteradians(1);
             AssertEx.EqualTolerance(-1, -v.Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(2, (SolidAngle.FromSteradians(3)-v).Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(2, (SolidAngle<double>.FromSteradians(3)-v).Steradians, SteradiansTolerance);
             AssertEx.EqualTolerance(2, (v + v).Steradians, SteradiansTolerance);
             AssertEx.EqualTolerance(10, (v*10).Steradians, SteradiansTolerance);
             AssertEx.EqualTolerance(10, (10*v).Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(2, (SolidAngle.FromSteradians(10)/5).Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(2, SolidAngle.FromSteradians(10)/SolidAngle.FromSteradians(5), SteradiansTolerance);
+            AssertEx.EqualTolerance(2, (SolidAngle<double>.FromSteradians(10)/5).Steradians, SteradiansTolerance);
+            AssertEx.EqualTolerance(2, SolidAngle<double>.FromSteradians(10)/SolidAngle<double>.FromSteradians(5), SteradiansTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            SolidAngle oneSteradian = SolidAngle.FromSteradians(1);
-            SolidAngle twoSteradians = SolidAngle.FromSteradians(2);
+            SolidAngle<double> oneSteradian = SolidAngle<double>.FromSteradians(1);
+            SolidAngle<double> twoSteradians = SolidAngle<double>.FromSteradians(2);
 
             Assert.True(oneSteradian < twoSteradians);
             Assert.True(oneSteradian <= twoSteradians);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
             Assert.Equal(0, steradian.CompareTo(steradian));
-            Assert.True(steradian.CompareTo(SolidAngle.Zero) > 0);
-            Assert.True(SolidAngle.Zero.CompareTo(steradian) < 0);
+            Assert.True(steradian.CompareTo(SolidAngle<double>.Zero) > 0);
+            Assert.True(SolidAngle<double>.Zero.CompareTo(steradian) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
             Assert.Throws<ArgumentException>(() => steradian.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
             Assert.Throws<ArgumentNullException>(() => steradian.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = SolidAngle.FromSteradians(1);
-            var b = SolidAngle.FromSteradians(2);
+            var a = SolidAngle<double>.FromSteradians(1);
+            var b = SolidAngle<double>.FromSteradians(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = SolidAngle.FromSteradians(1);
-            var b = SolidAngle.FromSteradians(2);
+            var a = SolidAngle<double>.FromSteradians(1);
+            var b = SolidAngle<double>.FromSteradians(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = SolidAngle.FromSteradians(1);
-            Assert.True(v.Equals(SolidAngle.FromSteradians(1), SteradiansTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(SolidAngle.Zero, SteradiansTolerance, ComparisonType.Relative));
+            var v = SolidAngle<double>.FromSteradians(1);
+            Assert.True(v.Equals(SolidAngle<double>.FromSteradians(1), SteradiansTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SolidAngle<double>.Zero, SteradiansTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
             Assert.False(steradian.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
+            SolidAngle<double> steradian = SolidAngle<double>.FromSteradians(1);
             Assert.False(steradian.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(SolidAngleUnit.Undefined, SolidAngle.Units);
+            Assert.DoesNotContain(SolidAngleUnit.Undefined, SolidAngle<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(SolidAngle.BaseDimensions is null);
+            Assert.False(SolidAngle<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs
index dd9c2664f0..8ff4aad608 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs
@@ -94,7 +94,7 @@ public abstract partial class SpecificEnergyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificEnergy((double)0.0, SpecificEnergyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>((double)0.0, SpecificEnergyUnit.Undefined));
         }
 
         [Fact]
@@ -109,14 +109,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificEnergy(double.PositiveInfinity, SpecificEnergyUnit.JoulePerKilogram));
-            Assert.Throws<ArgumentException>(() => new SpecificEnergy(double.NegativeInfinity, SpecificEnergyUnit.JoulePerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>(double.PositiveInfinity, SpecificEnergyUnit.JoulePerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>(double.NegativeInfinity, SpecificEnergyUnit.JoulePerKilogram));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificEnergy(double.NaN, SpecificEnergyUnit.JoulePerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificEnergy<double>(double.NaN, SpecificEnergyUnit.JoulePerKilogram));
         }
 
         [Fact]
@@ -162,7 +162,7 @@ public void SpecificEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void JoulePerKilogramToSpecificEnergyUnits()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             AssertEx.EqualTolerance(BtuPerPoundInOneJoulePerKilogram, jouleperkilogram.BtuPerPound, BtuPerPoundTolerance);
             AssertEx.EqualTolerance(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.CaloriesPerGram, CaloriesPerGramTolerance);
             AssertEx.EqualTolerance(GigawattDaysPerKilogramInOneJoulePerKilogram, jouleperkilogram.GigawattDaysPerKilogram, GigawattDaysPerKilogramTolerance);
@@ -193,103 +193,103 @@ public void JoulePerKilogramToSpecificEnergyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = SpecificEnergy.From(1, SpecificEnergyUnit.BtuPerPound);
+            var quantity00 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.BtuPerPound);
             AssertEx.EqualTolerance(1, quantity00.BtuPerPound, BtuPerPoundTolerance);
             Assert.Equal(SpecificEnergyUnit.BtuPerPound, quantity00.Unit);
 
-            var quantity01 = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram);
+            var quantity01 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.CaloriePerGram);
             AssertEx.EqualTolerance(1, quantity01.CaloriesPerGram, CaloriesPerGramTolerance);
             Assert.Equal(SpecificEnergyUnit.CaloriePerGram, quantity01.Unit);
 
-            var quantity02 = SpecificEnergy.From(1, SpecificEnergyUnit.GigawattDayPerKilogram);
+            var quantity02 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.GigawattDayPerKilogram);
             AssertEx.EqualTolerance(1, quantity02.GigawattDaysPerKilogram, GigawattDaysPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.GigawattDayPerKilogram, quantity02.Unit);
 
-            var quantity03 = SpecificEnergy.From(1, SpecificEnergyUnit.GigawattDayPerShortTon);
+            var quantity03 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.GigawattDayPerShortTon);
             AssertEx.EqualTolerance(1, quantity03.GigawattDaysPerShortTon, GigawattDaysPerShortTonTolerance);
             Assert.Equal(SpecificEnergyUnit.GigawattDayPerShortTon, quantity03.Unit);
 
-            var quantity04 = SpecificEnergy.From(1, SpecificEnergyUnit.GigawattDayPerTonne);
+            var quantity04 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.GigawattDayPerTonne);
             AssertEx.EqualTolerance(1, quantity04.GigawattDaysPerTonne, GigawattDaysPerTonneTolerance);
             Assert.Equal(SpecificEnergyUnit.GigawattDayPerTonne, quantity04.Unit);
 
-            var quantity05 = SpecificEnergy.From(1, SpecificEnergyUnit.GigawattHourPerKilogram);
+            var quantity05 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.GigawattHourPerKilogram);
             AssertEx.EqualTolerance(1, quantity05.GigawattHoursPerKilogram, GigawattHoursPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.GigawattHourPerKilogram, quantity05.Unit);
 
-            var quantity06 = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram);
+            var quantity06 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.JoulePerKilogram);
             AssertEx.EqualTolerance(1, quantity06.JoulesPerKilogram, JoulesPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.JoulePerKilogram, quantity06.Unit);
 
-            var quantity07 = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram);
+            var quantity07 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilocaloriePerGram);
             AssertEx.EqualTolerance(1, quantity07.KilocaloriesPerGram, KilocaloriesPerGramTolerance);
             Assert.Equal(SpecificEnergyUnit.KilocaloriePerGram, quantity07.Unit);
 
-            var quantity08 = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram);
+            var quantity08 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilojoulePerKilogram);
             AssertEx.EqualTolerance(1, quantity08.KilojoulesPerKilogram, KilojoulesPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.KilojoulePerKilogram, quantity08.Unit);
 
-            var quantity09 = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattDayPerKilogram);
+            var quantity09 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilowattDayPerKilogram);
             AssertEx.EqualTolerance(1, quantity09.KilowattDaysPerKilogram, KilowattDaysPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.KilowattDayPerKilogram, quantity09.Unit);
 
-            var quantity10 = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattDayPerShortTon);
+            var quantity10 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilowattDayPerShortTon);
             AssertEx.EqualTolerance(1, quantity10.KilowattDaysPerShortTon, KilowattDaysPerShortTonTolerance);
             Assert.Equal(SpecificEnergyUnit.KilowattDayPerShortTon, quantity10.Unit);
 
-            var quantity11 = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattDayPerTonne);
+            var quantity11 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilowattDayPerTonne);
             AssertEx.EqualTolerance(1, quantity11.KilowattDaysPerTonne, KilowattDaysPerTonneTolerance);
             Assert.Equal(SpecificEnergyUnit.KilowattDayPerTonne, quantity11.Unit);
 
-            var quantity12 = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram);
+            var quantity12 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.KilowattHourPerKilogram);
             AssertEx.EqualTolerance(1, quantity12.KilowattHoursPerKilogram, KilowattHoursPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.KilowattHourPerKilogram, quantity12.Unit);
 
-            var quantity13 = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram);
+            var quantity13 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.MegajoulePerKilogram);
             AssertEx.EqualTolerance(1, quantity13.MegajoulesPerKilogram, MegajoulesPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.MegajoulePerKilogram, quantity13.Unit);
 
-            var quantity14 = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattDayPerKilogram);
+            var quantity14 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.MegawattDayPerKilogram);
             AssertEx.EqualTolerance(1, quantity14.MegawattDaysPerKilogram, MegawattDaysPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.MegawattDayPerKilogram, quantity14.Unit);
 
-            var quantity15 = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattDayPerShortTon);
+            var quantity15 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.MegawattDayPerShortTon);
             AssertEx.EqualTolerance(1, quantity15.MegawattDaysPerShortTon, MegawattDaysPerShortTonTolerance);
             Assert.Equal(SpecificEnergyUnit.MegawattDayPerShortTon, quantity15.Unit);
 
-            var quantity16 = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattDayPerTonne);
+            var quantity16 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.MegawattDayPerTonne);
             AssertEx.EqualTolerance(1, quantity16.MegawattDaysPerTonne, MegawattDaysPerTonneTolerance);
             Assert.Equal(SpecificEnergyUnit.MegawattDayPerTonne, quantity16.Unit);
 
-            var quantity17 = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram);
+            var quantity17 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.MegawattHourPerKilogram);
             AssertEx.EqualTolerance(1, quantity17.MegawattHoursPerKilogram, MegawattHoursPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.MegawattHourPerKilogram, quantity17.Unit);
 
-            var quantity18 = SpecificEnergy.From(1, SpecificEnergyUnit.TerawattDayPerKilogram);
+            var quantity18 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.TerawattDayPerKilogram);
             AssertEx.EqualTolerance(1, quantity18.TerawattDaysPerKilogram, TerawattDaysPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.TerawattDayPerKilogram, quantity18.Unit);
 
-            var quantity19 = SpecificEnergy.From(1, SpecificEnergyUnit.TerawattDayPerShortTon);
+            var quantity19 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.TerawattDayPerShortTon);
             AssertEx.EqualTolerance(1, quantity19.TerawattDaysPerShortTon, TerawattDaysPerShortTonTolerance);
             Assert.Equal(SpecificEnergyUnit.TerawattDayPerShortTon, quantity19.Unit);
 
-            var quantity20 = SpecificEnergy.From(1, SpecificEnergyUnit.TerawattDayPerTonne);
+            var quantity20 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.TerawattDayPerTonne);
             AssertEx.EqualTolerance(1, quantity20.TerawattDaysPerTonne, TerawattDaysPerTonneTolerance);
             Assert.Equal(SpecificEnergyUnit.TerawattDayPerTonne, quantity20.Unit);
 
-            var quantity21 = SpecificEnergy.From(1, SpecificEnergyUnit.WattDayPerKilogram);
+            var quantity21 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.WattDayPerKilogram);
             AssertEx.EqualTolerance(1, quantity21.WattDaysPerKilogram, WattDaysPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.WattDayPerKilogram, quantity21.Unit);
 
-            var quantity22 = SpecificEnergy.From(1, SpecificEnergyUnit.WattDayPerShortTon);
+            var quantity22 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.WattDayPerShortTon);
             AssertEx.EqualTolerance(1, quantity22.WattDaysPerShortTon, WattDaysPerShortTonTolerance);
             Assert.Equal(SpecificEnergyUnit.WattDayPerShortTon, quantity22.Unit);
 
-            var quantity23 = SpecificEnergy.From(1, SpecificEnergyUnit.WattDayPerTonne);
+            var quantity23 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.WattDayPerTonne);
             AssertEx.EqualTolerance(1, quantity23.WattDaysPerTonne, WattDaysPerTonneTolerance);
             Assert.Equal(SpecificEnergyUnit.WattDayPerTonne, quantity23.Unit);
 
-            var quantity24 = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram);
+            var quantity24 = SpecificEnergy<double>.From(1, SpecificEnergyUnit.WattHourPerKilogram);
             AssertEx.EqualTolerance(1, quantity24.WattHoursPerKilogram, WattHoursPerKilogramTolerance);
             Assert.Equal(SpecificEnergyUnit.WattHourPerKilogram, quantity24.Unit);
 
@@ -298,20 +298,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromJoulesPerKilogram_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificEnergy.FromJoulesPerKilogram(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => SpecificEnergy.FromJoulesPerKilogram(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificEnergy<double>.FromJoulesPerKilogram(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificEnergy<double>.FromJoulesPerKilogram(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromJoulesPerKilogram_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificEnergy.FromJoulesPerKilogram(double.NaN));
+            Assert.Throws<ArgumentException>(() => SpecificEnergy<double>.FromJoulesPerKilogram(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            var jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             AssertEx.EqualTolerance(BtuPerPoundInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.BtuPerPound), BtuPerPoundTolerance);
             AssertEx.EqualTolerance(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.CaloriePerGram), CaloriesPerGramTolerance);
             AssertEx.EqualTolerance(GigawattDaysPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.GigawattDayPerKilogram), GigawattDaysPerKilogramTolerance);
@@ -359,7 +359,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            var jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
 
             var btuperpoundQuantity = jouleperkilogram.ToUnit(SpecificEnergyUnit.BtuPerPound);
             AssertEx.EqualTolerance(BtuPerPoundInOneJoulePerKilogram, (double)btuperpoundQuantity.Value, BtuPerPoundTolerance);
@@ -472,52 +472,52 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromBtuPerPound(jouleperkilogram.BtuPerPound).JoulesPerKilogram, BtuPerPoundTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromCaloriesPerGram(jouleperkilogram.CaloriesPerGram).JoulesPerKilogram, CaloriesPerGramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattDaysPerKilogram(jouleperkilogram.GigawattDaysPerKilogram).JoulesPerKilogram, GigawattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattDaysPerShortTon(jouleperkilogram.GigawattDaysPerShortTon).JoulesPerKilogram, GigawattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattDaysPerTonne(jouleperkilogram.GigawattDaysPerTonne).JoulesPerKilogram, GigawattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattHoursPerKilogram(jouleperkilogram.GigawattHoursPerKilogram).JoulesPerKilogram, GigawattHoursPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromJoulesPerKilogram(jouleperkilogram.JoulesPerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilocaloriesPerGram(jouleperkilogram.KilocaloriesPerGram).JoulesPerKilogram, KilocaloriesPerGramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilojoulesPerKilogram(jouleperkilogram.KilojoulesPerKilogram).JoulesPerKilogram, KilojoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattDaysPerKilogram(jouleperkilogram.KilowattDaysPerKilogram).JoulesPerKilogram, KilowattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattDaysPerShortTon(jouleperkilogram.KilowattDaysPerShortTon).JoulesPerKilogram, KilowattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattDaysPerTonne(jouleperkilogram.KilowattDaysPerTonne).JoulesPerKilogram, KilowattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattHoursPerKilogram(jouleperkilogram.KilowattHoursPerKilogram).JoulesPerKilogram, KilowattHoursPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegajoulesPerKilogram(jouleperkilogram.MegajoulesPerKilogram).JoulesPerKilogram, MegajoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattDaysPerKilogram(jouleperkilogram.MegawattDaysPerKilogram).JoulesPerKilogram, MegawattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattDaysPerShortTon(jouleperkilogram.MegawattDaysPerShortTon).JoulesPerKilogram, MegawattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattDaysPerTonne(jouleperkilogram.MegawattDaysPerTonne).JoulesPerKilogram, MegawattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattHoursPerKilogram(jouleperkilogram.MegawattHoursPerKilogram).JoulesPerKilogram, MegawattHoursPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromTerawattDaysPerKilogram(jouleperkilogram.TerawattDaysPerKilogram).JoulesPerKilogram, TerawattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromTerawattDaysPerShortTon(jouleperkilogram.TerawattDaysPerShortTon).JoulesPerKilogram, TerawattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromTerawattDaysPerTonne(jouleperkilogram.TerawattDaysPerTonne).JoulesPerKilogram, TerawattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattDaysPerKilogram(jouleperkilogram.WattDaysPerKilogram).JoulesPerKilogram, WattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattDaysPerShortTon(jouleperkilogram.WattDaysPerShortTon).JoulesPerKilogram, WattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattDaysPerTonne(jouleperkilogram.WattDaysPerTonne).JoulesPerKilogram, WattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattHoursPerKilogram(jouleperkilogram.WattHoursPerKilogram).JoulesPerKilogram, WattHoursPerKilogramTolerance);
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromBtuPerPound(jouleperkilogram.BtuPerPound).JoulesPerKilogram, BtuPerPoundTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromCaloriesPerGram(jouleperkilogram.CaloriesPerGram).JoulesPerKilogram, CaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromGigawattDaysPerKilogram(jouleperkilogram.GigawattDaysPerKilogram).JoulesPerKilogram, GigawattDaysPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromGigawattDaysPerShortTon(jouleperkilogram.GigawattDaysPerShortTon).JoulesPerKilogram, GigawattDaysPerShortTonTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromGigawattDaysPerTonne(jouleperkilogram.GigawattDaysPerTonne).JoulesPerKilogram, GigawattDaysPerTonneTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromGigawattHoursPerKilogram(jouleperkilogram.GigawattHoursPerKilogram).JoulesPerKilogram, GigawattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromJoulesPerKilogram(jouleperkilogram.JoulesPerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilocaloriesPerGram(jouleperkilogram.KilocaloriesPerGram).JoulesPerKilogram, KilocaloriesPerGramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilojoulesPerKilogram(jouleperkilogram.KilojoulesPerKilogram).JoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilowattDaysPerKilogram(jouleperkilogram.KilowattDaysPerKilogram).JoulesPerKilogram, KilowattDaysPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilowattDaysPerShortTon(jouleperkilogram.KilowattDaysPerShortTon).JoulesPerKilogram, KilowattDaysPerShortTonTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilowattDaysPerTonne(jouleperkilogram.KilowattDaysPerTonne).JoulesPerKilogram, KilowattDaysPerTonneTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromKilowattHoursPerKilogram(jouleperkilogram.KilowattHoursPerKilogram).JoulesPerKilogram, KilowattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromMegajoulesPerKilogram(jouleperkilogram.MegajoulesPerKilogram).JoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromMegawattDaysPerKilogram(jouleperkilogram.MegawattDaysPerKilogram).JoulesPerKilogram, MegawattDaysPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromMegawattDaysPerShortTon(jouleperkilogram.MegawattDaysPerShortTon).JoulesPerKilogram, MegawattDaysPerShortTonTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromMegawattDaysPerTonne(jouleperkilogram.MegawattDaysPerTonne).JoulesPerKilogram, MegawattDaysPerTonneTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromMegawattHoursPerKilogram(jouleperkilogram.MegawattHoursPerKilogram).JoulesPerKilogram, MegawattHoursPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromTerawattDaysPerKilogram(jouleperkilogram.TerawattDaysPerKilogram).JoulesPerKilogram, TerawattDaysPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromTerawattDaysPerShortTon(jouleperkilogram.TerawattDaysPerShortTon).JoulesPerKilogram, TerawattDaysPerShortTonTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromTerawattDaysPerTonne(jouleperkilogram.TerawattDaysPerTonne).JoulesPerKilogram, TerawattDaysPerTonneTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromWattDaysPerKilogram(jouleperkilogram.WattDaysPerKilogram).JoulesPerKilogram, WattDaysPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromWattDaysPerShortTon(jouleperkilogram.WattDaysPerShortTon).JoulesPerKilogram, WattDaysPerShortTonTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromWattDaysPerTonne(jouleperkilogram.WattDaysPerTonne).JoulesPerKilogram, WattDaysPerTonneTolerance);
+            AssertEx.EqualTolerance(1, SpecificEnergy<double>.FromWattHoursPerKilogram(jouleperkilogram.WattHoursPerKilogram).JoulesPerKilogram, WattHoursPerKilogramTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            SpecificEnergy v = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> v = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             AssertEx.EqualTolerance(-1, -v.JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEnergy.FromJoulesPerKilogram(3)-v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificEnergy<double>.FromJoulesPerKilogram(3)-v).JoulesPerKilogram, JoulesPerKilogramTolerance);
             AssertEx.EqualTolerance(2, (v + v).JoulesPerKilogram, JoulesPerKilogramTolerance);
             AssertEx.EqualTolerance(10, (v*10).JoulesPerKilogram, JoulesPerKilogramTolerance);
             AssertEx.EqualTolerance(10, (10*v).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEnergy.FromJoulesPerKilogram(10)/5).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, SpecificEnergy.FromJoulesPerKilogram(10)/SpecificEnergy.FromJoulesPerKilogram(5), JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificEnergy<double>.FromJoulesPerKilogram(10)/5).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, SpecificEnergy<double>.FromJoulesPerKilogram(10)/SpecificEnergy<double>.FromJoulesPerKilogram(5), JoulesPerKilogramTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            SpecificEnergy oneJoulePerKilogram = SpecificEnergy.FromJoulesPerKilogram(1);
-            SpecificEnergy twoJoulesPerKilogram = SpecificEnergy.FromJoulesPerKilogram(2);
+            SpecificEnergy<double> oneJoulePerKilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> twoJoulesPerKilogram = SpecificEnergy<double>.FromJoulesPerKilogram(2);
 
             Assert.True(oneJoulePerKilogram < twoJoulesPerKilogram);
             Assert.True(oneJoulePerKilogram <= twoJoulesPerKilogram);
@@ -533,31 +533,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             Assert.Equal(0, jouleperkilogram.CompareTo(jouleperkilogram));
-            Assert.True(jouleperkilogram.CompareTo(SpecificEnergy.Zero) > 0);
-            Assert.True(SpecificEnergy.Zero.CompareTo(jouleperkilogram) < 0);
+            Assert.True(jouleperkilogram.CompareTo(SpecificEnergy<double>.Zero) > 0);
+            Assert.True(SpecificEnergy<double>.Zero.CompareTo(jouleperkilogram) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             Assert.Throws<ArgumentException>(() => jouleperkilogram.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             Assert.Throws<ArgumentNullException>(() => jouleperkilogram.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = SpecificEnergy.FromJoulesPerKilogram(1);
-            var b = SpecificEnergy.FromJoulesPerKilogram(2);
+            var a = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            var b = SpecificEnergy<double>.FromJoulesPerKilogram(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -576,8 +576,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = SpecificEnergy.FromJoulesPerKilogram(1);
-            var b = SpecificEnergy.FromJoulesPerKilogram(2);
+            var a = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            var b = SpecificEnergy<double>.FromJoulesPerKilogram(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -597,9 +597,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = SpecificEnergy.FromJoulesPerKilogram(1);
-            Assert.True(v.Equals(SpecificEnergy.FromJoulesPerKilogram(1), JoulesPerKilogramTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(SpecificEnergy.Zero, JoulesPerKilogramTolerance, ComparisonType.Relative));
+            var v = SpecificEnergy<double>.FromJoulesPerKilogram(1);
+            Assert.True(v.Equals(SpecificEnergy<double>.FromJoulesPerKilogram(1), JoulesPerKilogramTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SpecificEnergy<double>.Zero, JoulesPerKilogramTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -612,21 +612,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             Assert.False(jouleperkilogram.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy<double> jouleperkilogram = SpecificEnergy<double>.FromJoulesPerKilogram(1);
             Assert.False(jouleperkilogram.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(SpecificEnergyUnit.Undefined, SpecificEnergy.Units);
+            Assert.DoesNotContain(SpecificEnergyUnit.Undefined, SpecificEnergy<double>.Units);
         }
 
         [Fact]
@@ -645,7 +645,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(SpecificEnergy.BaseDimensions is null);
+            Assert.False(SpecificEnergy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs
index 8a47a53f74..5021a53ebf 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs
@@ -62,7 +62,7 @@ public abstract partial class SpecificEntropyTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificEntropy((double)0.0, SpecificEntropyUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new SpecificEntropy<double>((double)0.0, SpecificEntropyUnit.Undefined));
         }
 
         [Fact]
@@ -77,14 +77,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificEntropy(double.PositiveInfinity, SpecificEntropyUnit.JoulePerKilogramKelvin));
-            Assert.Throws<ArgumentException>(() => new SpecificEntropy(double.NegativeInfinity, SpecificEntropyUnit.JoulePerKilogramKelvin));
+            Assert.Throws<ArgumentException>(() => new SpecificEntropy<double>(double.PositiveInfinity, SpecificEntropyUnit.JoulePerKilogramKelvin));
+            Assert.Throws<ArgumentException>(() => new SpecificEntropy<double>(double.NegativeInfinity, SpecificEntropyUnit.JoulePerKilogramKelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificEntropy(double.NaN, SpecificEntropyUnit.JoulePerKilogramKelvin));
+            Assert.Throws<ArgumentException>(() => new SpecificEntropy<double>(double.NaN, SpecificEntropyUnit.JoulePerKilogramKelvin));
         }
 
         [Fact]
@@ -130,7 +130,7 @@ public void SpecificEntropy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void JoulePerKilogramKelvinToSpecificEntropyUnits()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             AssertEx.EqualTolerance(BtusPerPoundFahrenheitInOneJoulePerKilogramKelvin, jouleperkilogramkelvin.BtusPerPoundFahrenheit, BtusPerPoundFahrenheitTolerance);
             AssertEx.EqualTolerance(CaloriesPerGramKelvinInOneJoulePerKilogramKelvin, jouleperkilogramkelvin.CaloriesPerGramKelvin, CaloriesPerGramKelvinTolerance);
             AssertEx.EqualTolerance(JoulesPerKilogramDegreeCelsiusInOneJoulePerKilogramKelvin, jouleperkilogramkelvin.JoulesPerKilogramDegreeCelsius, JoulesPerKilogramDegreeCelsiusTolerance);
@@ -145,39 +145,39 @@ public void JoulePerKilogramKelvinToSpecificEntropyUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = SpecificEntropy.From(1, SpecificEntropyUnit.BtuPerPoundFahrenheit);
+            var quantity00 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.BtuPerPoundFahrenheit);
             AssertEx.EqualTolerance(1, quantity00.BtusPerPoundFahrenheit, BtusPerPoundFahrenheitTolerance);
             Assert.Equal(SpecificEntropyUnit.BtuPerPoundFahrenheit, quantity00.Unit);
 
-            var quantity01 = SpecificEntropy.From(1, SpecificEntropyUnit.CaloriePerGramKelvin);
+            var quantity01 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.CaloriePerGramKelvin);
             AssertEx.EqualTolerance(1, quantity01.CaloriesPerGramKelvin, CaloriesPerGramKelvinTolerance);
             Assert.Equal(SpecificEntropyUnit.CaloriePerGramKelvin, quantity01.Unit);
 
-            var quantity02 = SpecificEntropy.From(1, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
+            var quantity02 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
             AssertEx.EqualTolerance(1, quantity02.JoulesPerKilogramDegreeCelsius, JoulesPerKilogramDegreeCelsiusTolerance);
             Assert.Equal(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, quantity02.Unit);
 
-            var quantity03 = SpecificEntropy.From(1, SpecificEntropyUnit.JoulePerKilogramKelvin);
+            var quantity03 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.JoulePerKilogramKelvin);
             AssertEx.EqualTolerance(1, quantity03.JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
             Assert.Equal(SpecificEntropyUnit.JoulePerKilogramKelvin, quantity03.Unit);
 
-            var quantity04 = SpecificEntropy.From(1, SpecificEntropyUnit.KilocaloriePerGramKelvin);
+            var quantity04 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.KilocaloriePerGramKelvin);
             AssertEx.EqualTolerance(1, quantity04.KilocaloriesPerGramKelvin, KilocaloriesPerGramKelvinTolerance);
             Assert.Equal(SpecificEntropyUnit.KilocaloriePerGramKelvin, quantity04.Unit);
 
-            var quantity05 = SpecificEntropy.From(1, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
+            var quantity05 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
             AssertEx.EqualTolerance(1, quantity05.KilojoulesPerKilogramDegreeCelsius, KilojoulesPerKilogramDegreeCelsiusTolerance);
             Assert.Equal(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, quantity05.Unit);
 
-            var quantity06 = SpecificEntropy.From(1, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
+            var quantity06 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
             AssertEx.EqualTolerance(1, quantity06.KilojoulesPerKilogramKelvin, KilojoulesPerKilogramKelvinTolerance);
             Assert.Equal(SpecificEntropyUnit.KilojoulePerKilogramKelvin, quantity06.Unit);
 
-            var quantity07 = SpecificEntropy.From(1, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
+            var quantity07 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
             AssertEx.EqualTolerance(1, quantity07.MegajoulesPerKilogramDegreeCelsius, MegajoulesPerKilogramDegreeCelsiusTolerance);
             Assert.Equal(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, quantity07.Unit);
 
-            var quantity08 = SpecificEntropy.From(1, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
+            var quantity08 = SpecificEntropy<double>.From(1, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
             AssertEx.EqualTolerance(1, quantity08.MegajoulesPerKilogramKelvin, MegajoulesPerKilogramKelvinTolerance);
             Assert.Equal(SpecificEntropyUnit.MegajoulePerKilogramKelvin, quantity08.Unit);
 
@@ -186,20 +186,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromJoulesPerKilogramKelvin_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificEntropy.FromJoulesPerKilogramKelvin(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => SpecificEntropy.FromJoulesPerKilogramKelvin(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificEntropy<double>.FromJoulesPerKilogramKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificEntropy<double>.FromJoulesPerKilogramKelvin(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromJoulesPerKilogramKelvin_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificEntropy.FromJoulesPerKilogramKelvin(double.NaN));
+            Assert.Throws<ArgumentException>(() => SpecificEntropy<double>.FromJoulesPerKilogramKelvin(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            var jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             AssertEx.EqualTolerance(BtusPerPoundFahrenheitInOneJoulePerKilogramKelvin, jouleperkilogramkelvin.As(SpecificEntropyUnit.BtuPerPoundFahrenheit), BtusPerPoundFahrenheitTolerance);
             AssertEx.EqualTolerance(CaloriesPerGramKelvinInOneJoulePerKilogramKelvin, jouleperkilogramkelvin.As(SpecificEntropyUnit.CaloriePerGramKelvin), CaloriesPerGramKelvinTolerance);
             AssertEx.EqualTolerance(JoulesPerKilogramDegreeCelsiusInOneJoulePerKilogramKelvin, jouleperkilogramkelvin.As(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius), JoulesPerKilogramDegreeCelsiusTolerance);
@@ -231,7 +231,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            var jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
 
             var btuperpoundfahrenheitQuantity = jouleperkilogramkelvin.ToUnit(SpecificEntropyUnit.BtuPerPoundFahrenheit);
             AssertEx.EqualTolerance(BtusPerPoundFahrenheitInOneJoulePerKilogramKelvin, (double)btuperpoundfahrenheitQuantity.Value, BtusPerPoundFahrenheitTolerance);
@@ -280,36 +280,36 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromBtusPerPoundFahrenheit(jouleperkilogramkelvin.BtusPerPoundFahrenheit).JoulesPerKilogramKelvin, BtusPerPoundFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromCaloriesPerGramKelvin(jouleperkilogramkelvin.CaloriesPerGramKelvin).JoulesPerKilogramKelvin, CaloriesPerGramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.JoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, JoulesPerKilogramDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromJoulesPerKilogramKelvin(jouleperkilogramkelvin.JoulesPerKilogramKelvin).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromKilocaloriesPerGramKelvin(jouleperkilogramkelvin.KilocaloriesPerGramKelvin).JoulesPerKilogramKelvin, KilocaloriesPerGramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.KilojoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, KilojoulesPerKilogramDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromKilojoulesPerKilogramKelvin(jouleperkilogramkelvin.KilojoulesPerKilogramKelvin).JoulesPerKilogramKelvin, KilojoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.MegajoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, MegajoulesPerKilogramDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromMegajoulesPerKilogramKelvin(jouleperkilogramkelvin.MegajoulesPerKilogramKelvin).JoulesPerKilogramKelvin, MegajoulesPerKilogramKelvinTolerance);
+            SpecificEntropy<double> jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromBtusPerPoundFahrenheit(jouleperkilogramkelvin.BtusPerPoundFahrenheit).JoulesPerKilogramKelvin, BtusPerPoundFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromCaloriesPerGramKelvin(jouleperkilogramkelvin.CaloriesPerGramKelvin).JoulesPerKilogramKelvin, CaloriesPerGramKelvinTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromJoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.JoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, JoulesPerKilogramDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromJoulesPerKilogramKelvin(jouleperkilogramkelvin.JoulesPerKilogramKelvin).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromKilocaloriesPerGramKelvin(jouleperkilogramkelvin.KilocaloriesPerGramKelvin).JoulesPerKilogramKelvin, KilocaloriesPerGramKelvinTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromKilojoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.KilojoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, KilojoulesPerKilogramDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromKilojoulesPerKilogramKelvin(jouleperkilogramkelvin.KilojoulesPerKilogramKelvin).JoulesPerKilogramKelvin, KilojoulesPerKilogramKelvinTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromMegajoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.MegajoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, MegajoulesPerKilogramDegreeCelsiusTolerance);
+            AssertEx.EqualTolerance(1, SpecificEntropy<double>.FromMegajoulesPerKilogramKelvin(jouleperkilogramkelvin.MegajoulesPerKilogramKelvin).JoulesPerKilogramKelvin, MegajoulesPerKilogramKelvinTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            SpecificEntropy v = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> v = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             AssertEx.EqualTolerance(-1, -v.JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEntropy.FromJoulesPerKilogramKelvin(3)-v).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
+            AssertEx.EqualTolerance(2, (SpecificEntropy<double>.FromJoulesPerKilogramKelvin(3)-v).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
             AssertEx.EqualTolerance(2, (v + v).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
             AssertEx.EqualTolerance(10, (v*10).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
             AssertEx.EqualTolerance(10, (10*v).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEntropy.FromJoulesPerKilogramKelvin(10)/5).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(2, SpecificEntropy.FromJoulesPerKilogramKelvin(10)/SpecificEntropy.FromJoulesPerKilogramKelvin(5), JoulesPerKilogramKelvinTolerance);
+            AssertEx.EqualTolerance(2, (SpecificEntropy<double>.FromJoulesPerKilogramKelvin(10)/5).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
+            AssertEx.EqualTolerance(2, SpecificEntropy<double>.FromJoulesPerKilogramKelvin(10)/SpecificEntropy<double>.FromJoulesPerKilogramKelvin(5), JoulesPerKilogramKelvinTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            SpecificEntropy oneJoulePerKilogramKelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            SpecificEntropy twoJoulesPerKilogramKelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(2);
+            SpecificEntropy<double> oneJoulePerKilogramKelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> twoJoulesPerKilogramKelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(2);
 
             Assert.True(oneJoulePerKilogramKelvin < twoJoulesPerKilogramKelvin);
             Assert.True(oneJoulePerKilogramKelvin <= twoJoulesPerKilogramKelvin);
@@ -325,31 +325,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             Assert.Equal(0, jouleperkilogramkelvin.CompareTo(jouleperkilogramkelvin));
-            Assert.True(jouleperkilogramkelvin.CompareTo(SpecificEntropy.Zero) > 0);
-            Assert.True(SpecificEntropy.Zero.CompareTo(jouleperkilogramkelvin) < 0);
+            Assert.True(jouleperkilogramkelvin.CompareTo(SpecificEntropy<double>.Zero) > 0);
+            Assert.True(SpecificEntropy<double>.Zero.CompareTo(jouleperkilogramkelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             Assert.Throws<ArgumentException>(() => jouleperkilogramkelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             Assert.Throws<ArgumentNullException>(() => jouleperkilogramkelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            var b = SpecificEntropy.FromJoulesPerKilogramKelvin(2);
+            var a = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
+            var b = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -368,8 +368,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            var b = SpecificEntropy.FromJoulesPerKilogramKelvin(2);
+            var a = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
+            var b = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -389,9 +389,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            Assert.True(v.Equals(SpecificEntropy.FromJoulesPerKilogramKelvin(1), JoulesPerKilogramKelvinTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(SpecificEntropy.Zero, JoulesPerKilogramKelvinTolerance, ComparisonType.Relative));
+            var v = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
+            Assert.True(v.Equals(SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1), JoulesPerKilogramKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SpecificEntropy<double>.Zero, JoulesPerKilogramKelvinTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -404,21 +404,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             Assert.False(jouleperkilogramkelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
+            SpecificEntropy<double> jouleperkilogramkelvin = SpecificEntropy<double>.FromJoulesPerKilogramKelvin(1);
             Assert.False(jouleperkilogramkelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(SpecificEntropyUnit.Undefined, SpecificEntropy.Units);
+            Assert.DoesNotContain(SpecificEntropyUnit.Undefined, SpecificEntropy<double>.Units);
         }
 
         [Fact]
@@ -437,7 +437,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(SpecificEntropy.BaseDimensions is null);
+            Assert.False(SpecificEntropy<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs
index b9d93260ce..670e2ac066 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs
@@ -50,7 +50,7 @@ public abstract partial class SpecificVolumeTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificVolume((double)0.0, SpecificVolumeUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>((double)0.0, SpecificVolumeUnit.Undefined));
         }
 
         [Fact]
@@ -65,14 +65,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificVolume(double.PositiveInfinity, SpecificVolumeUnit.CubicMeterPerKilogram));
-            Assert.Throws<ArgumentException>(() => new SpecificVolume(double.NegativeInfinity, SpecificVolumeUnit.CubicMeterPerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>(double.PositiveInfinity, SpecificVolumeUnit.CubicMeterPerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>(double.NegativeInfinity, SpecificVolumeUnit.CubicMeterPerKilogram));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificVolume(double.NaN, SpecificVolumeUnit.CubicMeterPerKilogram));
+            Assert.Throws<ArgumentException>(() => new SpecificVolume<double>(double.NaN, SpecificVolumeUnit.CubicMeterPerKilogram));
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void SpecificVolume_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void CubicMeterPerKilogramToSpecificVolumeUnits()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, cubicmeterperkilogram.CubicFeetPerPound, CubicFeetPerPoundTolerance);
             AssertEx.EqualTolerance(CubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
             AssertEx.EqualTolerance(MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.MillicubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
@@ -127,15 +127,15 @@ public void CubicMeterPerKilogramToSpecificVolumeUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = SpecificVolume.From(1, SpecificVolumeUnit.CubicFootPerPound);
+            var quantity00 = SpecificVolume<double>.From(1, SpecificVolumeUnit.CubicFootPerPound);
             AssertEx.EqualTolerance(1, quantity00.CubicFeetPerPound, CubicFeetPerPoundTolerance);
             Assert.Equal(SpecificVolumeUnit.CubicFootPerPound, quantity00.Unit);
 
-            var quantity01 = SpecificVolume.From(1, SpecificVolumeUnit.CubicMeterPerKilogram);
+            var quantity01 = SpecificVolume<double>.From(1, SpecificVolumeUnit.CubicMeterPerKilogram);
             AssertEx.EqualTolerance(1, quantity01.CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
             Assert.Equal(SpecificVolumeUnit.CubicMeterPerKilogram, quantity01.Unit);
 
-            var quantity02 = SpecificVolume.From(1, SpecificVolumeUnit.MillicubicMeterPerKilogram);
+            var quantity02 = SpecificVolume<double>.From(1, SpecificVolumeUnit.MillicubicMeterPerKilogram);
             AssertEx.EqualTolerance(1, quantity02.MillicubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
             Assert.Equal(SpecificVolumeUnit.MillicubicMeterPerKilogram, quantity02.Unit);
 
@@ -144,20 +144,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCubicMetersPerKilogram_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificVolume.FromCubicMetersPerKilogram(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => SpecificVolume.FromCubicMetersPerKilogram(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificVolume<double>.FromCubicMetersPerKilogram(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificVolume<double>.FromCubicMetersPerKilogram(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCubicMetersPerKilogram_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificVolume.FromCubicMetersPerKilogram(double.NaN));
+            Assert.Throws<ArgumentException>(() => SpecificVolume<double>.FromCubicMetersPerKilogram(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            var cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.CubicFootPerPound), CubicFeetPerPoundTolerance);
             AssertEx.EqualTolerance(CubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.CubicMeterPerKilogram), CubicMetersPerKilogramTolerance);
             AssertEx.EqualTolerance(MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.MillicubicMeterPerKilogram), MillicubicMetersPerKilogramTolerance);
@@ -183,7 +183,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            var cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
 
             var cubicfootperpoundQuantity = cubicmeterperkilogram.ToUnit(SpecificVolumeUnit.CubicFootPerPound);
             AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, (double)cubicfootperpoundQuantity.Value, CubicFeetPerPoundTolerance);
@@ -208,30 +208,30 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
-            AssertEx.EqualTolerance(1, SpecificVolume.FromCubicFeetPerPound(cubicmeterperkilogram.CubicFeetPerPound).CubicMetersPerKilogram, CubicFeetPerPoundTolerance);
-            AssertEx.EqualTolerance(1, SpecificVolume.FromCubicMetersPerKilogram(cubicmeterperkilogram.CubicMetersPerKilogram).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificVolume.FromMillicubicMetersPerKilogram(cubicmeterperkilogram.MillicubicMetersPerKilogram).CubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.FromCubicFeetPerPound(cubicmeterperkilogram.CubicFeetPerPound).CubicMetersPerKilogram, CubicFeetPerPoundTolerance);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.FromCubicMetersPerKilogram(cubicmeterperkilogram.CubicMetersPerKilogram).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(1, SpecificVolume<double>.FromMillicubicMetersPerKilogram(cubicmeterperkilogram.MillicubicMetersPerKilogram).CubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            SpecificVolume v = SpecificVolume.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> v = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             AssertEx.EqualTolerance(-1, -v.CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificVolume.FromCubicMetersPerKilogram(3)-v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificVolume<double>.FromCubicMetersPerKilogram(3)-v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
             AssertEx.EqualTolerance(2, (v + v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
             AssertEx.EqualTolerance(10, (v*10).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
             AssertEx.EqualTolerance(10, (10*v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificVolume.FromCubicMetersPerKilogram(10)/5).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, SpecificVolume.FromCubicMetersPerKilogram(10)/SpecificVolume.FromCubicMetersPerKilogram(5), CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, (SpecificVolume<double>.FromCubicMetersPerKilogram(10)/5).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(2, SpecificVolume<double>.FromCubicMetersPerKilogram(10)/SpecificVolume<double>.FromCubicMetersPerKilogram(5), CubicMetersPerKilogramTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            SpecificVolume oneCubicMeterPerKilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
-            SpecificVolume twoCubicMetersPerKilogram = SpecificVolume.FromCubicMetersPerKilogram(2);
+            SpecificVolume<double> oneCubicMeterPerKilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> twoCubicMetersPerKilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(2);
 
             Assert.True(oneCubicMeterPerKilogram < twoCubicMetersPerKilogram);
             Assert.True(oneCubicMeterPerKilogram <= twoCubicMetersPerKilogram);
@@ -247,31 +247,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             Assert.Equal(0, cubicmeterperkilogram.CompareTo(cubicmeterperkilogram));
-            Assert.True(cubicmeterperkilogram.CompareTo(SpecificVolume.Zero) > 0);
-            Assert.True(SpecificVolume.Zero.CompareTo(cubicmeterperkilogram) < 0);
+            Assert.True(cubicmeterperkilogram.CompareTo(SpecificVolume<double>.Zero) > 0);
+            Assert.True(SpecificVolume<double>.Zero.CompareTo(cubicmeterperkilogram) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             Assert.Throws<ArgumentException>(() => cubicmeterperkilogram.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             Assert.Throws<ArgumentNullException>(() => cubicmeterperkilogram.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = SpecificVolume.FromCubicMetersPerKilogram(1);
-            var b = SpecificVolume.FromCubicMetersPerKilogram(2);
+            var a = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            var b = SpecificVolume<double>.FromCubicMetersPerKilogram(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -290,8 +290,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = SpecificVolume.FromCubicMetersPerKilogram(1);
-            var b = SpecificVolume.FromCubicMetersPerKilogram(2);
+            var a = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            var b = SpecificVolume<double>.FromCubicMetersPerKilogram(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -311,9 +311,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = SpecificVolume.FromCubicMetersPerKilogram(1);
-            Assert.True(v.Equals(SpecificVolume.FromCubicMetersPerKilogram(1), CubicMetersPerKilogramTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(SpecificVolume.Zero, CubicMetersPerKilogramTolerance, ComparisonType.Relative));
+            var v = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
+            Assert.True(v.Equals(SpecificVolume<double>.FromCubicMetersPerKilogram(1), CubicMetersPerKilogramTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SpecificVolume<double>.Zero, CubicMetersPerKilogramTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -326,21 +326,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             Assert.False(cubicmeterperkilogram.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
+            SpecificVolume<double> cubicmeterperkilogram = SpecificVolume<double>.FromCubicMetersPerKilogram(1);
             Assert.False(cubicmeterperkilogram.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(SpecificVolumeUnit.Undefined, SpecificVolume.Units);
+            Assert.DoesNotContain(SpecificVolumeUnit.Undefined, SpecificVolume<double>.Units);
         }
 
         [Fact]
@@ -359,7 +359,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(SpecificVolume.BaseDimensions is null);
+            Assert.False(SpecificVolume<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs
index 2e7dcd72cb..0eaf9fc022 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs
@@ -78,7 +78,7 @@ public abstract partial class SpecificWeightTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificWeight((double)0.0, SpecificWeightUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new SpecificWeight<double>((double)0.0, SpecificWeightUnit.Undefined));
         }
 
         [Fact]
@@ -93,14 +93,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificWeight(double.PositiveInfinity, SpecificWeightUnit.NewtonPerCubicMeter));
-            Assert.Throws<ArgumentException>(() => new SpecificWeight(double.NegativeInfinity, SpecificWeightUnit.NewtonPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new SpecificWeight<double>(double.PositiveInfinity, SpecificWeightUnit.NewtonPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new SpecificWeight<double>(double.NegativeInfinity, SpecificWeightUnit.NewtonPerCubicMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new SpecificWeight(double.NaN, SpecificWeightUnit.NewtonPerCubicMeter));
+            Assert.Throws<ArgumentException>(() => new SpecificWeight<double>(double.NaN, SpecificWeightUnit.NewtonPerCubicMeter));
         }
 
         [Fact]
@@ -146,7 +146,7 @@ public void SpecificWeight_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void NewtonPerCubicMeterToSpecificWeightUnits()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             AssertEx.EqualTolerance(KilogramsForcePerCubicCentimeterInOneNewtonPerCubicMeter, newtonpercubicmeter.KilogramsForcePerCubicCentimeter, KilogramsForcePerCubicCentimeterTolerance);
             AssertEx.EqualTolerance(KilogramsForcePerCubicMeterInOneNewtonPerCubicMeter, newtonpercubicmeter.KilogramsForcePerCubicMeter, KilogramsForcePerCubicMeterTolerance);
             AssertEx.EqualTolerance(KilogramsForcePerCubicMillimeterInOneNewtonPerCubicMeter, newtonpercubicmeter.KilogramsForcePerCubicMillimeter, KilogramsForcePerCubicMillimeterTolerance);
@@ -169,71 +169,71 @@ public void NewtonPerCubicMeterToSpecificWeightUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
+            var quantity00 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity00.KilogramsForcePerCubicCentimeter, KilogramsForcePerCubicCentimeterTolerance);
             Assert.Equal(SpecificWeightUnit.KilogramForcePerCubicCentimeter, quantity00.Unit);
 
-            var quantity01 = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter);
+            var quantity01 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter);
             AssertEx.EqualTolerance(1, quantity01.KilogramsForcePerCubicMeter, KilogramsForcePerCubicMeterTolerance);
             Assert.Equal(SpecificWeightUnit.KilogramForcePerCubicMeter, quantity01.Unit);
 
-            var quantity02 = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
+            var quantity02 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity02.KilogramsForcePerCubicMillimeter, KilogramsForcePerCubicMillimeterTolerance);
             Assert.Equal(SpecificWeightUnit.KilogramForcePerCubicMillimeter, quantity02.Unit);
 
-            var quantity03 = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
+            var quantity03 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity03.KilonewtonsPerCubicCentimeter, KilonewtonsPerCubicCentimeterTolerance);
             Assert.Equal(SpecificWeightUnit.KilonewtonPerCubicCentimeter, quantity03.Unit);
 
-            var quantity04 = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter);
+            var quantity04 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity04.KilonewtonsPerCubicMeter, KilonewtonsPerCubicMeterTolerance);
             Assert.Equal(SpecificWeightUnit.KilonewtonPerCubicMeter, quantity04.Unit);
 
-            var quantity05 = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
+            var quantity05 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity05.KilonewtonsPerCubicMillimeter, KilonewtonsPerCubicMillimeterTolerance);
             Assert.Equal(SpecificWeightUnit.KilonewtonPerCubicMillimeter, quantity05.Unit);
 
-            var quantity06 = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot);
+            var quantity06 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot);
             AssertEx.EqualTolerance(1, quantity06.KilopoundsForcePerCubicFoot, KilopoundsForcePerCubicFootTolerance);
             Assert.Equal(SpecificWeightUnit.KilopoundForcePerCubicFoot, quantity06.Unit);
 
-            var quantity07 = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch);
+            var quantity07 = SpecificWeight<double>.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch);
             AssertEx.EqualTolerance(1, quantity07.KilopoundsForcePerCubicInch, KilopoundsForcePerCubicInchTolerance);
             Assert.Equal(SpecificWeightUnit.KilopoundForcePerCubicInch, quantity07.Unit);
 
-            var quantity08 = SpecificWeight.From(1, SpecificWeightUnit.MeganewtonPerCubicMeter);
+            var quantity08 = SpecificWeight<double>.From(1, SpecificWeightUnit.MeganewtonPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity08.MeganewtonsPerCubicMeter, MeganewtonsPerCubicMeterTolerance);
             Assert.Equal(SpecificWeightUnit.MeganewtonPerCubicMeter, quantity08.Unit);
 
-            var quantity09 = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter);
+            var quantity09 = SpecificWeight<double>.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity09.NewtonsPerCubicCentimeter, NewtonsPerCubicCentimeterTolerance);
             Assert.Equal(SpecificWeightUnit.NewtonPerCubicCentimeter, quantity09.Unit);
 
-            var quantity10 = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter);
+            var quantity10 = SpecificWeight<double>.From(1, SpecificWeightUnit.NewtonPerCubicMeter);
             AssertEx.EqualTolerance(1, quantity10.NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
             Assert.Equal(SpecificWeightUnit.NewtonPerCubicMeter, quantity10.Unit);
 
-            var quantity11 = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter);
+            var quantity11 = SpecificWeight<double>.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity11.NewtonsPerCubicMillimeter, NewtonsPerCubicMillimeterTolerance);
             Assert.Equal(SpecificWeightUnit.NewtonPerCubicMillimeter, quantity11.Unit);
 
-            var quantity12 = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot);
+            var quantity12 = SpecificWeight<double>.From(1, SpecificWeightUnit.PoundForcePerCubicFoot);
             AssertEx.EqualTolerance(1, quantity12.PoundsForcePerCubicFoot, PoundsForcePerCubicFootTolerance);
             Assert.Equal(SpecificWeightUnit.PoundForcePerCubicFoot, quantity12.Unit);
 
-            var quantity13 = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch);
+            var quantity13 = SpecificWeight<double>.From(1, SpecificWeightUnit.PoundForcePerCubicInch);
             AssertEx.EqualTolerance(1, quantity13.PoundsForcePerCubicInch, PoundsForcePerCubicInchTolerance);
             Assert.Equal(SpecificWeightUnit.PoundForcePerCubicInch, quantity13.Unit);
 
-            var quantity14 = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter);
+            var quantity14 = SpecificWeight<double>.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter);
             AssertEx.EqualTolerance(1, quantity14.TonnesForcePerCubicCentimeter, TonnesForcePerCubicCentimeterTolerance);
             Assert.Equal(SpecificWeightUnit.TonneForcePerCubicCentimeter, quantity14.Unit);
 
-            var quantity15 = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter);
+            var quantity15 = SpecificWeight<double>.From(1, SpecificWeightUnit.TonneForcePerCubicMeter);
             AssertEx.EqualTolerance(1, quantity15.TonnesForcePerCubicMeter, TonnesForcePerCubicMeterTolerance);
             Assert.Equal(SpecificWeightUnit.TonneForcePerCubicMeter, quantity15.Unit);
 
-            var quantity16 = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter);
+            var quantity16 = SpecificWeight<double>.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter);
             AssertEx.EqualTolerance(1, quantity16.TonnesForcePerCubicMillimeter, TonnesForcePerCubicMillimeterTolerance);
             Assert.Equal(SpecificWeightUnit.TonneForcePerCubicMillimeter, quantity16.Unit);
 
@@ -242,20 +242,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonsPerCubicMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificWeight.FromNewtonsPerCubicMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => SpecificWeight.FromNewtonsPerCubicMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificWeight<double>.FromNewtonsPerCubicMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => SpecificWeight<double>.FromNewtonsPerCubicMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonsPerCubicMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => SpecificWeight.FromNewtonsPerCubicMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => SpecificWeight<double>.FromNewtonsPerCubicMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            var newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             AssertEx.EqualTolerance(KilogramsForcePerCubicCentimeterInOneNewtonPerCubicMeter, newtonpercubicmeter.As(SpecificWeightUnit.KilogramForcePerCubicCentimeter), KilogramsForcePerCubicCentimeterTolerance);
             AssertEx.EqualTolerance(KilogramsForcePerCubicMeterInOneNewtonPerCubicMeter, newtonpercubicmeter.As(SpecificWeightUnit.KilogramForcePerCubicMeter), KilogramsForcePerCubicMeterTolerance);
             AssertEx.EqualTolerance(KilogramsForcePerCubicMillimeterInOneNewtonPerCubicMeter, newtonpercubicmeter.As(SpecificWeightUnit.KilogramForcePerCubicMillimeter), KilogramsForcePerCubicMillimeterTolerance);
@@ -295,7 +295,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            var newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
 
             var kilogramforcepercubiccentimeterQuantity = newtonpercubicmeter.ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter);
             AssertEx.EqualTolerance(KilogramsForcePerCubicCentimeterInOneNewtonPerCubicMeter, (double)kilogramforcepercubiccentimeterQuantity.Value, KilogramsForcePerCubicCentimeterTolerance);
@@ -376,44 +376,44 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilogramsForcePerCubicCentimeter(newtonpercubicmeter.KilogramsForcePerCubicCentimeter).NewtonsPerCubicMeter, KilogramsForcePerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilogramsForcePerCubicMeter(newtonpercubicmeter.KilogramsForcePerCubicMeter).NewtonsPerCubicMeter, KilogramsForcePerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilogramsForcePerCubicMillimeter(newtonpercubicmeter.KilogramsForcePerCubicMillimeter).NewtonsPerCubicMeter, KilogramsForcePerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilonewtonsPerCubicCentimeter(newtonpercubicmeter.KilonewtonsPerCubicCentimeter).NewtonsPerCubicMeter, KilonewtonsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilonewtonsPerCubicMeter(newtonpercubicmeter.KilonewtonsPerCubicMeter).NewtonsPerCubicMeter, KilonewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilonewtonsPerCubicMillimeter(newtonpercubicmeter.KilonewtonsPerCubicMillimeter).NewtonsPerCubicMeter, KilonewtonsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilopoundsForcePerCubicFoot(newtonpercubicmeter.KilopoundsForcePerCubicFoot).NewtonsPerCubicMeter, KilopoundsForcePerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilopoundsForcePerCubicInch(newtonpercubicmeter.KilopoundsForcePerCubicInch).NewtonsPerCubicMeter, KilopoundsForcePerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromMeganewtonsPerCubicMeter(newtonpercubicmeter.MeganewtonsPerCubicMeter).NewtonsPerCubicMeter, MeganewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromNewtonsPerCubicCentimeter(newtonpercubicmeter.NewtonsPerCubicCentimeter).NewtonsPerCubicMeter, NewtonsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromNewtonsPerCubicMeter(newtonpercubicmeter.NewtonsPerCubicMeter).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromNewtonsPerCubicMillimeter(newtonpercubicmeter.NewtonsPerCubicMillimeter).NewtonsPerCubicMeter, NewtonsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromPoundsForcePerCubicFoot(newtonpercubicmeter.PoundsForcePerCubicFoot).NewtonsPerCubicMeter, PoundsForcePerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromPoundsForcePerCubicInch(newtonpercubicmeter.PoundsForcePerCubicInch).NewtonsPerCubicMeter, PoundsForcePerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromTonnesForcePerCubicCentimeter(newtonpercubicmeter.TonnesForcePerCubicCentimeter).NewtonsPerCubicMeter, TonnesForcePerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromTonnesForcePerCubicMeter(newtonpercubicmeter.TonnesForcePerCubicMeter).NewtonsPerCubicMeter, TonnesForcePerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromTonnesForcePerCubicMillimeter(newtonpercubicmeter.TonnesForcePerCubicMillimeter).NewtonsPerCubicMeter, TonnesForcePerCubicMillimeterTolerance);
+            SpecificWeight<double> newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilogramsForcePerCubicCentimeter(newtonpercubicmeter.KilogramsForcePerCubicCentimeter).NewtonsPerCubicMeter, KilogramsForcePerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilogramsForcePerCubicMeter(newtonpercubicmeter.KilogramsForcePerCubicMeter).NewtonsPerCubicMeter, KilogramsForcePerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilogramsForcePerCubicMillimeter(newtonpercubicmeter.KilogramsForcePerCubicMillimeter).NewtonsPerCubicMeter, KilogramsForcePerCubicMillimeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilonewtonsPerCubicCentimeter(newtonpercubicmeter.KilonewtonsPerCubicCentimeter).NewtonsPerCubicMeter, KilonewtonsPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilonewtonsPerCubicMeter(newtonpercubicmeter.KilonewtonsPerCubicMeter).NewtonsPerCubicMeter, KilonewtonsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilonewtonsPerCubicMillimeter(newtonpercubicmeter.KilonewtonsPerCubicMillimeter).NewtonsPerCubicMeter, KilonewtonsPerCubicMillimeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilopoundsForcePerCubicFoot(newtonpercubicmeter.KilopoundsForcePerCubicFoot).NewtonsPerCubicMeter, KilopoundsForcePerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromKilopoundsForcePerCubicInch(newtonpercubicmeter.KilopoundsForcePerCubicInch).NewtonsPerCubicMeter, KilopoundsForcePerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromMeganewtonsPerCubicMeter(newtonpercubicmeter.MeganewtonsPerCubicMeter).NewtonsPerCubicMeter, MeganewtonsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromNewtonsPerCubicCentimeter(newtonpercubicmeter.NewtonsPerCubicCentimeter).NewtonsPerCubicMeter, NewtonsPerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromNewtonsPerCubicMeter(newtonpercubicmeter.NewtonsPerCubicMeter).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromNewtonsPerCubicMillimeter(newtonpercubicmeter.NewtonsPerCubicMillimeter).NewtonsPerCubicMeter, NewtonsPerCubicMillimeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromPoundsForcePerCubicFoot(newtonpercubicmeter.PoundsForcePerCubicFoot).NewtonsPerCubicMeter, PoundsForcePerCubicFootTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromPoundsForcePerCubicInch(newtonpercubicmeter.PoundsForcePerCubicInch).NewtonsPerCubicMeter, PoundsForcePerCubicInchTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromTonnesForcePerCubicCentimeter(newtonpercubicmeter.TonnesForcePerCubicCentimeter).NewtonsPerCubicMeter, TonnesForcePerCubicCentimeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromTonnesForcePerCubicMeter(newtonpercubicmeter.TonnesForcePerCubicMeter).NewtonsPerCubicMeter, TonnesForcePerCubicMeterTolerance);
+            AssertEx.EqualTolerance(1, SpecificWeight<double>.FromTonnesForcePerCubicMillimeter(newtonpercubicmeter.TonnesForcePerCubicMillimeter).NewtonsPerCubicMeter, TonnesForcePerCubicMillimeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            SpecificWeight v = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> v = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             AssertEx.EqualTolerance(-1, -v.NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (SpecificWeight.FromNewtonsPerCubicMeter(3)-v).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (SpecificWeight<double>.FromNewtonsPerCubicMeter(3)-v).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (SpecificWeight.FromNewtonsPerCubicMeter(10)/5).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, SpecificWeight.FromNewtonsPerCubicMeter(10)/SpecificWeight.FromNewtonsPerCubicMeter(5), NewtonsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, (SpecificWeight<double>.FromNewtonsPerCubicMeter(10)/5).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
+            AssertEx.EqualTolerance(2, SpecificWeight<double>.FromNewtonsPerCubicMeter(10)/SpecificWeight<double>.FromNewtonsPerCubicMeter(5), NewtonsPerCubicMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            SpecificWeight oneNewtonPerCubicMeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            SpecificWeight twoNewtonsPerCubicMeter = SpecificWeight.FromNewtonsPerCubicMeter(2);
+            SpecificWeight<double> oneNewtonPerCubicMeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> twoNewtonsPerCubicMeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(2);
 
             Assert.True(oneNewtonPerCubicMeter < twoNewtonsPerCubicMeter);
             Assert.True(oneNewtonPerCubicMeter <= twoNewtonsPerCubicMeter);
@@ -429,31 +429,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             Assert.Equal(0, newtonpercubicmeter.CompareTo(newtonpercubicmeter));
-            Assert.True(newtonpercubicmeter.CompareTo(SpecificWeight.Zero) > 0);
-            Assert.True(SpecificWeight.Zero.CompareTo(newtonpercubicmeter) < 0);
+            Assert.True(newtonpercubicmeter.CompareTo(SpecificWeight<double>.Zero) > 0);
+            Assert.True(SpecificWeight<double>.Zero.CompareTo(newtonpercubicmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             Assert.Throws<ArgumentException>(() => newtonpercubicmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             Assert.Throws<ArgumentNullException>(() => newtonpercubicmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            var b = SpecificWeight.FromNewtonsPerCubicMeter(2);
+            var a = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
+            var b = SpecificWeight<double>.FromNewtonsPerCubicMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -472,8 +472,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            var b = SpecificWeight.FromNewtonsPerCubicMeter(2);
+            var a = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
+            var b = SpecificWeight<double>.FromNewtonsPerCubicMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -493,9 +493,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            Assert.True(v.Equals(SpecificWeight.FromNewtonsPerCubicMeter(1), NewtonsPerCubicMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(SpecificWeight.Zero, NewtonsPerCubicMeterTolerance, ComparisonType.Relative));
+            var v = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
+            Assert.True(v.Equals(SpecificWeight<double>.FromNewtonsPerCubicMeter(1), NewtonsPerCubicMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(SpecificWeight<double>.Zero, NewtonsPerCubicMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -508,21 +508,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             Assert.False(newtonpercubicmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
+            SpecificWeight<double> newtonpercubicmeter = SpecificWeight<double>.FromNewtonsPerCubicMeter(1);
             Assert.False(newtonpercubicmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(SpecificWeightUnit.Undefined, SpecificWeight.Units);
+            Assert.DoesNotContain(SpecificWeightUnit.Undefined, SpecificWeight<double>.Units);
         }
 
         [Fact]
@@ -541,7 +541,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(SpecificWeight.BaseDimensions is null);
+            Assert.False(SpecificWeight<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs
index 66ed06e657..2cf5a7e0f3 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs
@@ -108,7 +108,7 @@ public abstract partial class SpeedTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Speed((double)0.0, SpeedUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Speed<double>((double)0.0, SpeedUnit.Undefined));
         }
 
         [Fact]
@@ -123,14 +123,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Speed(double.PositiveInfinity, SpeedUnit.MeterPerSecond));
-            Assert.Throws<ArgumentException>(() => new Speed(double.NegativeInfinity, SpeedUnit.MeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new Speed<double>(double.PositiveInfinity, SpeedUnit.MeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new Speed<double>(double.NegativeInfinity, SpeedUnit.MeterPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Speed(double.NaN, SpeedUnit.MeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new Speed<double>(double.NaN, SpeedUnit.MeterPerSecond));
         }
 
         [Fact]
@@ -176,7 +176,7 @@ public void Speed_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void MeterPerSecondToSpeedUnits()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
+            Speed<double> meterpersecond = Speed<double>.FromMetersPerSecond(1);
             AssertEx.EqualTolerance(CentimetersPerHourInOneMeterPerSecond, meterpersecond.CentimetersPerHour, CentimetersPerHourTolerance);
             AssertEx.EqualTolerance(CentimetersPerMinutesInOneMeterPerSecond, meterpersecond.CentimetersPerMinutes, CentimetersPerMinutesTolerance);
             AssertEx.EqualTolerance(CentimetersPerSecondInOneMeterPerSecond, meterpersecond.CentimetersPerSecond, CentimetersPerSecondTolerance);
@@ -214,131 +214,131 @@ public void MeterPerSecondToSpeedUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Speed.From(1, SpeedUnit.CentimeterPerHour);
+            var quantity00 = Speed<double>.From(1, SpeedUnit.CentimeterPerHour);
             AssertEx.EqualTolerance(1, quantity00.CentimetersPerHour, CentimetersPerHourTolerance);
             Assert.Equal(SpeedUnit.CentimeterPerHour, quantity00.Unit);
 
-            var quantity01 = Speed.From(1, SpeedUnit.CentimeterPerMinute);
+            var quantity01 = Speed<double>.From(1, SpeedUnit.CentimeterPerMinute);
             AssertEx.EqualTolerance(1, quantity01.CentimetersPerMinutes, CentimetersPerMinutesTolerance);
             Assert.Equal(SpeedUnit.CentimeterPerMinute, quantity01.Unit);
 
-            var quantity02 = Speed.From(1, SpeedUnit.CentimeterPerSecond);
+            var quantity02 = Speed<double>.From(1, SpeedUnit.CentimeterPerSecond);
             AssertEx.EqualTolerance(1, quantity02.CentimetersPerSecond, CentimetersPerSecondTolerance);
             Assert.Equal(SpeedUnit.CentimeterPerSecond, quantity02.Unit);
 
-            var quantity03 = Speed.From(1, SpeedUnit.DecimeterPerMinute);
+            var quantity03 = Speed<double>.From(1, SpeedUnit.DecimeterPerMinute);
             AssertEx.EqualTolerance(1, quantity03.DecimetersPerMinutes, DecimetersPerMinutesTolerance);
             Assert.Equal(SpeedUnit.DecimeterPerMinute, quantity03.Unit);
 
-            var quantity04 = Speed.From(1, SpeedUnit.DecimeterPerSecond);
+            var quantity04 = Speed<double>.From(1, SpeedUnit.DecimeterPerSecond);
             AssertEx.EqualTolerance(1, quantity04.DecimetersPerSecond, DecimetersPerSecondTolerance);
             Assert.Equal(SpeedUnit.DecimeterPerSecond, quantity04.Unit);
 
-            var quantity05 = Speed.From(1, SpeedUnit.FootPerHour);
+            var quantity05 = Speed<double>.From(1, SpeedUnit.FootPerHour);
             AssertEx.EqualTolerance(1, quantity05.FeetPerHour, FeetPerHourTolerance);
             Assert.Equal(SpeedUnit.FootPerHour, quantity05.Unit);
 
-            var quantity06 = Speed.From(1, SpeedUnit.FootPerMinute);
+            var quantity06 = Speed<double>.From(1, SpeedUnit.FootPerMinute);
             AssertEx.EqualTolerance(1, quantity06.FeetPerMinute, FeetPerMinuteTolerance);
             Assert.Equal(SpeedUnit.FootPerMinute, quantity06.Unit);
 
-            var quantity07 = Speed.From(1, SpeedUnit.FootPerSecond);
+            var quantity07 = Speed<double>.From(1, SpeedUnit.FootPerSecond);
             AssertEx.EqualTolerance(1, quantity07.FeetPerSecond, FeetPerSecondTolerance);
             Assert.Equal(SpeedUnit.FootPerSecond, quantity07.Unit);
 
-            var quantity08 = Speed.From(1, SpeedUnit.InchPerHour);
+            var quantity08 = Speed<double>.From(1, SpeedUnit.InchPerHour);
             AssertEx.EqualTolerance(1, quantity08.InchesPerHour, InchesPerHourTolerance);
             Assert.Equal(SpeedUnit.InchPerHour, quantity08.Unit);
 
-            var quantity09 = Speed.From(1, SpeedUnit.InchPerMinute);
+            var quantity09 = Speed<double>.From(1, SpeedUnit.InchPerMinute);
             AssertEx.EqualTolerance(1, quantity09.InchesPerMinute, InchesPerMinuteTolerance);
             Assert.Equal(SpeedUnit.InchPerMinute, quantity09.Unit);
 
-            var quantity10 = Speed.From(1, SpeedUnit.InchPerSecond);
+            var quantity10 = Speed<double>.From(1, SpeedUnit.InchPerSecond);
             AssertEx.EqualTolerance(1, quantity10.InchesPerSecond, InchesPerSecondTolerance);
             Assert.Equal(SpeedUnit.InchPerSecond, quantity10.Unit);
 
-            var quantity11 = Speed.From(1, SpeedUnit.KilometerPerHour);
+            var quantity11 = Speed<double>.From(1, SpeedUnit.KilometerPerHour);
             AssertEx.EqualTolerance(1, quantity11.KilometersPerHour, KilometersPerHourTolerance);
             Assert.Equal(SpeedUnit.KilometerPerHour, quantity11.Unit);
 
-            var quantity12 = Speed.From(1, SpeedUnit.KilometerPerMinute);
+            var quantity12 = Speed<double>.From(1, SpeedUnit.KilometerPerMinute);
             AssertEx.EqualTolerance(1, quantity12.KilometersPerMinutes, KilometersPerMinutesTolerance);
             Assert.Equal(SpeedUnit.KilometerPerMinute, quantity12.Unit);
 
-            var quantity13 = Speed.From(1, SpeedUnit.KilometerPerSecond);
+            var quantity13 = Speed<double>.From(1, SpeedUnit.KilometerPerSecond);
             AssertEx.EqualTolerance(1, quantity13.KilometersPerSecond, KilometersPerSecondTolerance);
             Assert.Equal(SpeedUnit.KilometerPerSecond, quantity13.Unit);
 
-            var quantity14 = Speed.From(1, SpeedUnit.Knot);
+            var quantity14 = Speed<double>.From(1, SpeedUnit.Knot);
             AssertEx.EqualTolerance(1, quantity14.Knots, KnotsTolerance);
             Assert.Equal(SpeedUnit.Knot, quantity14.Unit);
 
-            var quantity15 = Speed.From(1, SpeedUnit.MeterPerHour);
+            var quantity15 = Speed<double>.From(1, SpeedUnit.MeterPerHour);
             AssertEx.EqualTolerance(1, quantity15.MetersPerHour, MetersPerHourTolerance);
             Assert.Equal(SpeedUnit.MeterPerHour, quantity15.Unit);
 
-            var quantity16 = Speed.From(1, SpeedUnit.MeterPerMinute);
+            var quantity16 = Speed<double>.From(1, SpeedUnit.MeterPerMinute);
             AssertEx.EqualTolerance(1, quantity16.MetersPerMinutes, MetersPerMinutesTolerance);
             Assert.Equal(SpeedUnit.MeterPerMinute, quantity16.Unit);
 
-            var quantity17 = Speed.From(1, SpeedUnit.MeterPerSecond);
+            var quantity17 = Speed<double>.From(1, SpeedUnit.MeterPerSecond);
             AssertEx.EqualTolerance(1, quantity17.MetersPerSecond, MetersPerSecondTolerance);
             Assert.Equal(SpeedUnit.MeterPerSecond, quantity17.Unit);
 
-            var quantity18 = Speed.From(1, SpeedUnit.MicrometerPerMinute);
+            var quantity18 = Speed<double>.From(1, SpeedUnit.MicrometerPerMinute);
             AssertEx.EqualTolerance(1, quantity18.MicrometersPerMinutes, MicrometersPerMinutesTolerance);
             Assert.Equal(SpeedUnit.MicrometerPerMinute, quantity18.Unit);
 
-            var quantity19 = Speed.From(1, SpeedUnit.MicrometerPerSecond);
+            var quantity19 = Speed<double>.From(1, SpeedUnit.MicrometerPerSecond);
             AssertEx.EqualTolerance(1, quantity19.MicrometersPerSecond, MicrometersPerSecondTolerance);
             Assert.Equal(SpeedUnit.MicrometerPerSecond, quantity19.Unit);
 
-            var quantity20 = Speed.From(1, SpeedUnit.MilePerHour);
+            var quantity20 = Speed<double>.From(1, SpeedUnit.MilePerHour);
             AssertEx.EqualTolerance(1, quantity20.MilesPerHour, MilesPerHourTolerance);
             Assert.Equal(SpeedUnit.MilePerHour, quantity20.Unit);
 
-            var quantity21 = Speed.From(1, SpeedUnit.MillimeterPerHour);
+            var quantity21 = Speed<double>.From(1, SpeedUnit.MillimeterPerHour);
             AssertEx.EqualTolerance(1, quantity21.MillimetersPerHour, MillimetersPerHourTolerance);
             Assert.Equal(SpeedUnit.MillimeterPerHour, quantity21.Unit);
 
-            var quantity22 = Speed.From(1, SpeedUnit.MillimeterPerMinute);
+            var quantity22 = Speed<double>.From(1, SpeedUnit.MillimeterPerMinute);
             AssertEx.EqualTolerance(1, quantity22.MillimetersPerMinutes, MillimetersPerMinutesTolerance);
             Assert.Equal(SpeedUnit.MillimeterPerMinute, quantity22.Unit);
 
-            var quantity23 = Speed.From(1, SpeedUnit.MillimeterPerSecond);
+            var quantity23 = Speed<double>.From(1, SpeedUnit.MillimeterPerSecond);
             AssertEx.EqualTolerance(1, quantity23.MillimetersPerSecond, MillimetersPerSecondTolerance);
             Assert.Equal(SpeedUnit.MillimeterPerSecond, quantity23.Unit);
 
-            var quantity24 = Speed.From(1, SpeedUnit.NanometerPerMinute);
+            var quantity24 = Speed<double>.From(1, SpeedUnit.NanometerPerMinute);
             AssertEx.EqualTolerance(1, quantity24.NanometersPerMinutes, NanometersPerMinutesTolerance);
             Assert.Equal(SpeedUnit.NanometerPerMinute, quantity24.Unit);
 
-            var quantity25 = Speed.From(1, SpeedUnit.NanometerPerSecond);
+            var quantity25 = Speed<double>.From(1, SpeedUnit.NanometerPerSecond);
             AssertEx.EqualTolerance(1, quantity25.NanometersPerSecond, NanometersPerSecondTolerance);
             Assert.Equal(SpeedUnit.NanometerPerSecond, quantity25.Unit);
 
-            var quantity26 = Speed.From(1, SpeedUnit.UsSurveyFootPerHour);
+            var quantity26 = Speed<double>.From(1, SpeedUnit.UsSurveyFootPerHour);
             AssertEx.EqualTolerance(1, quantity26.UsSurveyFeetPerHour, UsSurveyFeetPerHourTolerance);
             Assert.Equal(SpeedUnit.UsSurveyFootPerHour, quantity26.Unit);
 
-            var quantity27 = Speed.From(1, SpeedUnit.UsSurveyFootPerMinute);
+            var quantity27 = Speed<double>.From(1, SpeedUnit.UsSurveyFootPerMinute);
             AssertEx.EqualTolerance(1, quantity27.UsSurveyFeetPerMinute, UsSurveyFeetPerMinuteTolerance);
             Assert.Equal(SpeedUnit.UsSurveyFootPerMinute, quantity27.Unit);
 
-            var quantity28 = Speed.From(1, SpeedUnit.UsSurveyFootPerSecond);
+            var quantity28 = Speed<double>.From(1, SpeedUnit.UsSurveyFootPerSecond);
             AssertEx.EqualTolerance(1, quantity28.UsSurveyFeetPerSecond, UsSurveyFeetPerSecondTolerance);
             Assert.Equal(SpeedUnit.UsSurveyFootPerSecond, quantity28.Unit);
 
-            var quantity29 = Speed.From(1, SpeedUnit.YardPerHour);
+            var quantity29 = Speed<double>.From(1, SpeedUnit.YardPerHour);
             AssertEx.EqualTolerance(1, quantity29.YardsPerHour, YardsPerHourTolerance);
             Assert.Equal(SpeedUnit.YardPerHour, quantity29.Unit);
 
-            var quantity30 = Speed.From(1, SpeedUnit.YardPerMinute);
+            var quantity30 = Speed<double>.From(1, SpeedUnit.YardPerMinute);
             AssertEx.EqualTolerance(1, quantity30.YardsPerMinute, YardsPerMinuteTolerance);
             Assert.Equal(SpeedUnit.YardPerMinute, quantity30.Unit);
 
-            var quantity31 = Speed.From(1, SpeedUnit.YardPerSecond);
+            var quantity31 = Speed<double>.From(1, SpeedUnit.YardPerSecond);
             AssertEx.EqualTolerance(1, quantity31.YardsPerSecond, YardsPerSecondTolerance);
             Assert.Equal(SpeedUnit.YardPerSecond, quantity31.Unit);
 
@@ -347,20 +347,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromMetersPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Speed.FromMetersPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Speed.FromMetersPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Speed<double>.FromMetersPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Speed<double>.FromMetersPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromMetersPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Speed.FromMetersPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => Speed<double>.FromMetersPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var meterpersecond = Speed.FromMetersPerSecond(1);
+            var meterpersecond = Speed<double>.FromMetersPerSecond(1);
             AssertEx.EqualTolerance(CentimetersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerHour), CentimetersPerHourTolerance);
             AssertEx.EqualTolerance(CentimetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerMinute), CentimetersPerMinutesTolerance);
             AssertEx.EqualTolerance(CentimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerSecond), CentimetersPerSecondTolerance);
@@ -415,7 +415,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var meterpersecond = Speed.FromMetersPerSecond(1);
+            var meterpersecond = Speed<double>.FromMetersPerSecond(1);
 
             var centimeterperhourQuantity = meterpersecond.ToUnit(SpeedUnit.CentimeterPerHour);
             AssertEx.EqualTolerance(CentimetersPerHourInOneMeterPerSecond, (double)centimeterperhourQuantity.Value, CentimetersPerHourTolerance);
@@ -556,59 +556,59 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, Speed.FromCentimetersPerHour(meterpersecond.CentimetersPerHour).MetersPerSecond, CentimetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromCentimetersPerMinutes(meterpersecond.CentimetersPerMinutes).MetersPerSecond, CentimetersPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromCentimetersPerSecond(meterpersecond.CentimetersPerSecond).MetersPerSecond, CentimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromDecimetersPerMinutes(meterpersecond.DecimetersPerMinutes).MetersPerSecond, DecimetersPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromDecimetersPerSecond(meterpersecond.DecimetersPerSecond).MetersPerSecond, DecimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromFeetPerHour(meterpersecond.FeetPerHour).MetersPerSecond, FeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromFeetPerMinute(meterpersecond.FeetPerMinute).MetersPerSecond, FeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromFeetPerSecond(meterpersecond.FeetPerSecond).MetersPerSecond, FeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromInchesPerHour(meterpersecond.InchesPerHour).MetersPerSecond, InchesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromInchesPerMinute(meterpersecond.InchesPerMinute).MetersPerSecond, InchesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromInchesPerSecond(meterpersecond.InchesPerSecond).MetersPerSecond, InchesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond, KilometersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKilometersPerMinutes(meterpersecond.KilometersPerMinutes).MetersPerSecond, KilometersPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond, KilometersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKnots(meterpersecond.Knots).MetersPerSecond, KnotsTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMetersPerHour(meterpersecond.MetersPerHour).MetersPerSecond, MetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMetersPerMinutes(meterpersecond.MetersPerMinutes).MetersPerSecond, MetersPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMetersPerSecond(meterpersecond.MetersPerSecond).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMicrometersPerMinutes(meterpersecond.MicrometersPerMinutes).MetersPerSecond, MicrometersPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMicrometersPerSecond(meterpersecond.MicrometersPerSecond).MetersPerSecond, MicrometersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMilesPerHour(meterpersecond.MilesPerHour).MetersPerSecond, MilesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMillimetersPerHour(meterpersecond.MillimetersPerHour).MetersPerSecond, MillimetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMillimetersPerMinutes(meterpersecond.MillimetersPerMinutes).MetersPerSecond, MillimetersPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMillimetersPerSecond(meterpersecond.MillimetersPerSecond).MetersPerSecond, MillimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromNanometersPerMinutes(meterpersecond.NanometersPerMinutes).MetersPerSecond, NanometersPerMinutesTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromNanometersPerSecond(meterpersecond.NanometersPerSecond).MetersPerSecond, NanometersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerHour(meterpersecond.UsSurveyFeetPerHour).MetersPerSecond, UsSurveyFeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerMinute(meterpersecond.UsSurveyFeetPerMinute).MetersPerSecond, UsSurveyFeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerSecond(meterpersecond.UsSurveyFeetPerSecond).MetersPerSecond, UsSurveyFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromYardsPerHour(meterpersecond.YardsPerHour).MetersPerSecond, YardsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromYardsPerMinute(meterpersecond.YardsPerMinute).MetersPerSecond, YardsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromYardsPerSecond(meterpersecond.YardsPerSecond).MetersPerSecond, YardsPerSecondTolerance);
+            Speed<double> meterpersecond = Speed<double>.FromMetersPerSecond(1);
+            AssertEx.EqualTolerance(1, Speed<double>.FromCentimetersPerHour(meterpersecond.CentimetersPerHour).MetersPerSecond, CentimetersPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromCentimetersPerMinutes(meterpersecond.CentimetersPerMinutes).MetersPerSecond, CentimetersPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromCentimetersPerSecond(meterpersecond.CentimetersPerSecond).MetersPerSecond, CentimetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromDecimetersPerMinutes(meterpersecond.DecimetersPerMinutes).MetersPerSecond, DecimetersPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromDecimetersPerSecond(meterpersecond.DecimetersPerSecond).MetersPerSecond, DecimetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromFeetPerHour(meterpersecond.FeetPerHour).MetersPerSecond, FeetPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromFeetPerMinute(meterpersecond.FeetPerMinute).MetersPerSecond, FeetPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromFeetPerSecond(meterpersecond.FeetPerSecond).MetersPerSecond, FeetPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromInchesPerHour(meterpersecond.InchesPerHour).MetersPerSecond, InchesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromInchesPerMinute(meterpersecond.InchesPerMinute).MetersPerSecond, InchesPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromInchesPerSecond(meterpersecond.InchesPerSecond).MetersPerSecond, InchesPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond, KilometersPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromKilometersPerMinutes(meterpersecond.KilometersPerMinutes).MetersPerSecond, KilometersPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond, KilometersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromKnots(meterpersecond.Knots).MetersPerSecond, KnotsTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMetersPerHour(meterpersecond.MetersPerHour).MetersPerSecond, MetersPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMetersPerMinutes(meterpersecond.MetersPerMinutes).MetersPerSecond, MetersPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMetersPerSecond(meterpersecond.MetersPerSecond).MetersPerSecond, MetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMicrometersPerMinutes(meterpersecond.MicrometersPerMinutes).MetersPerSecond, MicrometersPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMicrometersPerSecond(meterpersecond.MicrometersPerSecond).MetersPerSecond, MicrometersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMilesPerHour(meterpersecond.MilesPerHour).MetersPerSecond, MilesPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMillimetersPerHour(meterpersecond.MillimetersPerHour).MetersPerSecond, MillimetersPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMillimetersPerMinutes(meterpersecond.MillimetersPerMinutes).MetersPerSecond, MillimetersPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromMillimetersPerSecond(meterpersecond.MillimetersPerSecond).MetersPerSecond, MillimetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromNanometersPerMinutes(meterpersecond.NanometersPerMinutes).MetersPerSecond, NanometersPerMinutesTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromNanometersPerSecond(meterpersecond.NanometersPerSecond).MetersPerSecond, NanometersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromUsSurveyFeetPerHour(meterpersecond.UsSurveyFeetPerHour).MetersPerSecond, UsSurveyFeetPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromUsSurveyFeetPerMinute(meterpersecond.UsSurveyFeetPerMinute).MetersPerSecond, UsSurveyFeetPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromUsSurveyFeetPerSecond(meterpersecond.UsSurveyFeetPerSecond).MetersPerSecond, UsSurveyFeetPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromYardsPerHour(meterpersecond.YardsPerHour).MetersPerSecond, YardsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromYardsPerMinute(meterpersecond.YardsPerMinute).MetersPerSecond, YardsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Speed<double>.FromYardsPerSecond(meterpersecond.YardsPerSecond).MetersPerSecond, YardsPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Speed v = Speed.FromMetersPerSecond(1);
+            Speed<double> v = Speed<double>.FromMetersPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (Speed.FromMetersPerSecond(3)-v).MetersPerSecond, MetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (Speed<double>.FromMetersPerSecond(3)-v).MetersPerSecond, MetersPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).MetersPerSecond, MetersPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).MetersPerSecond, MetersPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (Speed.FromMetersPerSecond(10)/5).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, Speed.FromMetersPerSecond(10)/Speed.FromMetersPerSecond(5), MetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (Speed<double>.FromMetersPerSecond(10)/5).MetersPerSecond, MetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, Speed<double>.FromMetersPerSecond(10)/Speed<double>.FromMetersPerSecond(5), MetersPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Speed oneMeterPerSecond = Speed.FromMetersPerSecond(1);
-            Speed twoMetersPerSecond = Speed.FromMetersPerSecond(2);
+            Speed<double> oneMeterPerSecond = Speed<double>.FromMetersPerSecond(1);
+            Speed<double> twoMetersPerSecond = Speed<double>.FromMetersPerSecond(2);
 
             Assert.True(oneMeterPerSecond < twoMetersPerSecond);
             Assert.True(oneMeterPerSecond <= twoMetersPerSecond);
@@ -624,31 +624,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
+            Speed<double> meterpersecond = Speed<double>.FromMetersPerSecond(1);
             Assert.Equal(0, meterpersecond.CompareTo(meterpersecond));
-            Assert.True(meterpersecond.CompareTo(Speed.Zero) > 0);
-            Assert.True(Speed.Zero.CompareTo(meterpersecond) < 0);
+            Assert.True(meterpersecond.CompareTo(Speed<double>.Zero) > 0);
+            Assert.True(Speed<double>.Zero.CompareTo(meterpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
+            Speed<double> meterpersecond = Speed<double>.FromMetersPerSecond(1);
             Assert.Throws<ArgumentException>(() => meterpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
+            Speed<double> meterpersecond = Speed<double>.FromMetersPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => meterpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Speed.FromMetersPerSecond(1);
-            var b = Speed.FromMetersPerSecond(2);
+            var a = Speed<double>.FromMetersPerSecond(1);
+            var b = Speed<double>.FromMetersPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -667,8 +667,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Speed.FromMetersPerSecond(1);
-            var b = Speed.FromMetersPerSecond(2);
+            var a = Speed<double>.FromMetersPerSecond(1);
+            var b = Speed<double>.FromMetersPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -688,9 +688,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Speed.FromMetersPerSecond(1);
-            Assert.True(v.Equals(Speed.FromMetersPerSecond(1), MetersPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Speed.Zero, MetersPerSecondTolerance, ComparisonType.Relative));
+            var v = Speed<double>.FromMetersPerSecond(1);
+            Assert.True(v.Equals(Speed<double>.FromMetersPerSecond(1), MetersPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Speed<double>.Zero, MetersPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -703,21 +703,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
+            Speed<double> meterpersecond = Speed<double>.FromMetersPerSecond(1);
             Assert.False(meterpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
+            Speed<double> meterpersecond = Speed<double>.FromMetersPerSecond(1);
             Assert.False(meterpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(SpeedUnit.Undefined, Speed.Units);
+            Assert.DoesNotContain(SpeedUnit.Undefined, Speed<double>.Units);
         }
 
         [Fact]
@@ -736,7 +736,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Speed.BaseDimensions is null);
+            Assert.False(Speed<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs
index 1de2c9c846..a638605171 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs
@@ -64,7 +64,7 @@ public abstract partial class TemperatureChangeRateTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate((double)0.0, TemperatureChangeRateUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate<double>((double)0.0, TemperatureChangeRateUnit.Undefined));
         }
 
         [Fact]
@@ -79,14 +79,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate(double.PositiveInfinity, TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate(double.NegativeInfinity, TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
+            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate<double>(double.PositiveInfinity, TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
+            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate<double>(double.NegativeInfinity, TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate(double.NaN, TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
+            Assert.Throws<ArgumentException>(() => new TemperatureChangeRate<double>(double.NaN, TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
         }
 
         [Fact]
@@ -132,7 +132,7 @@ public void TemperatureChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuan
         [Fact]
         public void DegreeCelsiusPerSecondToTemperatureChangeRateUnits()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             AssertEx.EqualTolerance(CentidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond, degreecelsiuspersecond.CentidegreesCelsiusPerSecond, CentidegreesCelsiusPerSecondTolerance);
             AssertEx.EqualTolerance(DecadegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond, degreecelsiuspersecond.DecadegreesCelsiusPerSecond, DecadegreesCelsiusPerSecondTolerance);
             AssertEx.EqualTolerance(DecidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond, degreecelsiuspersecond.DecidegreesCelsiusPerSecond, DecidegreesCelsiusPerSecondTolerance);
@@ -148,43 +148,43 @@ public void DegreeCelsiusPerSecondToTemperatureChangeRateUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
+            var quantity00 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity00.CentidegreesCelsiusPerSecond, CentidegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, quantity00.Unit);
 
-            var quantity01 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
+            var quantity01 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity01.DecadegreesCelsiusPerSecond, DecadegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, quantity01.Unit);
 
-            var quantity02 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
+            var quantity02 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity02.DecidegreesCelsiusPerSecond, DecidegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, quantity02.Unit);
 
-            var quantity03 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
+            var quantity03 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
             AssertEx.EqualTolerance(1, quantity03.DegreesCelsiusPerMinute, DegreesCelsiusPerMinuteTolerance);
             Assert.Equal(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, quantity03.Unit);
 
-            var quantity04 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
+            var quantity04 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity04.DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity04.Unit);
 
-            var quantity05 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
+            var quantity05 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity05.HectodegreesCelsiusPerSecond, HectodegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, quantity05.Unit);
 
-            var quantity06 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
+            var quantity06 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity06.KilodegreesCelsiusPerSecond, KilodegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, quantity06.Unit);
 
-            var quantity07 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
+            var quantity07 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity07.MicrodegreesCelsiusPerSecond, MicrodegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, quantity07.Unit);
 
-            var quantity08 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
+            var quantity08 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity08.MillidegreesCelsiusPerSecond, MillidegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, quantity08.Unit);
 
-            var quantity09 = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
+            var quantity09 = TemperatureChangeRate<double>.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(1, quantity09.NanodegreesCelsiusPerSecond, NanodegreesCelsiusPerSecondTolerance);
             Assert.Equal(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, quantity09.Unit);
 
@@ -193,20 +193,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDegreesCelsiusPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => TemperatureChangeRate.FromDegreesCelsiusPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => TemperatureChangeRate.FromDegreesCelsiusPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDegreesCelsiusPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => TemperatureChangeRate.FromDegreesCelsiusPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            var degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             AssertEx.EqualTolerance(CentidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond, degreecelsiuspersecond.As(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond), CentidegreesCelsiusPerSecondTolerance);
             AssertEx.EqualTolerance(DecadegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond, degreecelsiuspersecond.As(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond), DecadegreesCelsiusPerSecondTolerance);
             AssertEx.EqualTolerance(DecidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond, degreecelsiuspersecond.As(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond), DecidegreesCelsiusPerSecondTolerance);
@@ -239,7 +239,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            var degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
 
             var centidegreecelsiuspersecondQuantity = degreecelsiuspersecond.ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
             AssertEx.EqualTolerance(CentidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond, (double)centidegreecelsiuspersecondQuantity.Value, CentidegreesCelsiusPerSecondTolerance);
@@ -292,37 +292,37 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(degreecelsiuspersecond.CentidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, CentidegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(degreecelsiuspersecond.DecadegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DecadegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(degreecelsiuspersecond.DecidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DecidegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesCelsiusPerMinute(degreecelsiuspersecond.DegreesCelsiusPerMinute).DegreesCelsiusPerSecond, DegreesCelsiusPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesCelsiusPerSecond(degreecelsiuspersecond.DegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(degreecelsiuspersecond.HectodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, HectodegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(degreecelsiuspersecond.KilodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, KilodegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(degreecelsiuspersecond.MicrodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, MicrodegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(degreecelsiuspersecond.MillidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, MillidegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(degreecelsiuspersecond.NanodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, NanodegreesCelsiusPerSecondTolerance);
+            TemperatureChangeRate<double> degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromCentidegreesCelsiusPerSecond(degreecelsiuspersecond.CentidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, CentidegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromDecadegreesCelsiusPerSecond(degreecelsiuspersecond.DecadegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DecadegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromDecidegreesCelsiusPerSecond(degreecelsiuspersecond.DecidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DecidegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromDegreesCelsiusPerMinute(degreecelsiuspersecond.DegreesCelsiusPerMinute).DegreesCelsiusPerSecond, DegreesCelsiusPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(degreecelsiuspersecond.DegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromHectodegreesCelsiusPerSecond(degreecelsiuspersecond.HectodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, HectodegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromKilodegreesCelsiusPerSecond(degreecelsiuspersecond.KilodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, KilodegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromMicrodegreesCelsiusPerSecond(degreecelsiuspersecond.MicrodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, MicrodegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromMillidegreesCelsiusPerSecond(degreecelsiuspersecond.MillidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, MillidegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(1, TemperatureChangeRate<double>.FromNanodegreesCelsiusPerSecond(degreecelsiuspersecond.NanodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, NanodegreesCelsiusPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            TemperatureChangeRate v = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> v = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureChangeRate.FromDegreesCelsiusPerSecond(3)-v).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(3)-v).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureChangeRate.FromDegreesCelsiusPerSecond(10)/5).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(2, TemperatureChangeRate.FromDegreesCelsiusPerSecond(10)/TemperatureChangeRate.FromDegreesCelsiusPerSecond(5), DegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(10)/5).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
+            AssertEx.EqualTolerance(2, TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(10)/TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(5), DegreesCelsiusPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            TemperatureChangeRate oneDegreeCelsiusPerSecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            TemperatureChangeRate twoDegreesCelsiusPerSecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(2);
+            TemperatureChangeRate<double> oneDegreeCelsiusPerSecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> twoDegreesCelsiusPerSecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(2);
 
             Assert.True(oneDegreeCelsiusPerSecond < twoDegreesCelsiusPerSecond);
             Assert.True(oneDegreeCelsiusPerSecond <= twoDegreesCelsiusPerSecond);
@@ -338,31 +338,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             Assert.Equal(0, degreecelsiuspersecond.CompareTo(degreecelsiuspersecond));
-            Assert.True(degreecelsiuspersecond.CompareTo(TemperatureChangeRate.Zero) > 0);
-            Assert.True(TemperatureChangeRate.Zero.CompareTo(degreecelsiuspersecond) < 0);
+            Assert.True(degreecelsiuspersecond.CompareTo(TemperatureChangeRate<double>.Zero) > 0);
+            Assert.True(TemperatureChangeRate<double>.Zero.CompareTo(degreecelsiuspersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             Assert.Throws<ArgumentException>(() => degreecelsiuspersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => degreecelsiuspersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            var b = TemperatureChangeRate.FromDegreesCelsiusPerSecond(2);
+            var a = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
+            var b = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -381,8 +381,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            var b = TemperatureChangeRate.FromDegreesCelsiusPerSecond(2);
+            var a = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
+            var b = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -402,9 +402,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            Assert.True(v.Equals(TemperatureChangeRate.FromDegreesCelsiusPerSecond(1), DegreesCelsiusPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(TemperatureChangeRate.Zero, DegreesCelsiusPerSecondTolerance, ComparisonType.Relative));
+            var v = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
+            Assert.True(v.Equals(TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1), DegreesCelsiusPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(TemperatureChangeRate<double>.Zero, DegreesCelsiusPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -417,21 +417,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             Assert.False(degreecelsiuspersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
+            TemperatureChangeRate<double> degreecelsiuspersecond = TemperatureChangeRate<double>.FromDegreesCelsiusPerSecond(1);
             Assert.False(degreecelsiuspersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(TemperatureChangeRateUnit.Undefined, TemperatureChangeRate.Units);
+            Assert.DoesNotContain(TemperatureChangeRateUnit.Undefined, TemperatureChangeRate<double>.Units);
         }
 
         [Fact]
@@ -450,7 +450,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(TemperatureChangeRate.BaseDimensions is null);
+            Assert.False(TemperatureChangeRate<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs
index e67ca24273..d3cf1c9570 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs
@@ -62,7 +62,7 @@ public abstract partial class TemperatureDeltaTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TemperatureDelta((double)0.0, TemperatureDeltaUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>((double)0.0, TemperatureDeltaUnit.Undefined));
         }
 
         [Fact]
@@ -77,14 +77,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TemperatureDelta(double.PositiveInfinity, TemperatureDeltaUnit.Kelvin));
-            Assert.Throws<ArgumentException>(() => new TemperatureDelta(double.NegativeInfinity, TemperatureDeltaUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>(double.PositiveInfinity, TemperatureDeltaUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>(double.NegativeInfinity, TemperatureDeltaUnit.Kelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TemperatureDelta(double.NaN, TemperatureDeltaUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new TemperatureDelta<double>(double.NaN, TemperatureDeltaUnit.Kelvin));
         }
 
         [Fact]
@@ -130,7 +130,7 @@ public void TemperatureDelta_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
         [Fact]
         public void KelvinToTemperatureDeltaUnits()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
             AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.DegreesCelsius, DegreesCelsiusTolerance);
             AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.DegreesDelisle, DegreesDelisleTolerance);
             AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.DegreesFahrenheit, DegreesFahrenheitTolerance);
@@ -145,39 +145,39 @@ public void KelvinToTemperatureDeltaUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeCelsius);
+            var quantity00 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeCelsius);
             AssertEx.EqualTolerance(1, quantity00.DegreesCelsius, DegreesCelsiusTolerance);
             Assert.Equal(TemperatureDeltaUnit.DegreeCelsius, quantity00.Unit);
 
-            var quantity01 = TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeDelisle);
+            var quantity01 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeDelisle);
             AssertEx.EqualTolerance(1, quantity01.DegreesDelisle, DegreesDelisleTolerance);
             Assert.Equal(TemperatureDeltaUnit.DegreeDelisle, quantity01.Unit);
 
-            var quantity02 = TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeFahrenheit);
+            var quantity02 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeFahrenheit);
             AssertEx.EqualTolerance(1, quantity02.DegreesFahrenheit, DegreesFahrenheitTolerance);
             Assert.Equal(TemperatureDeltaUnit.DegreeFahrenheit, quantity02.Unit);
 
-            var quantity03 = TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeNewton);
+            var quantity03 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeNewton);
             AssertEx.EqualTolerance(1, quantity03.DegreesNewton, DegreesNewtonTolerance);
             Assert.Equal(TemperatureDeltaUnit.DegreeNewton, quantity03.Unit);
 
-            var quantity04 = TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeRankine);
+            var quantity04 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeRankine);
             AssertEx.EqualTolerance(1, quantity04.DegreesRankine, DegreesRankineTolerance);
             Assert.Equal(TemperatureDeltaUnit.DegreeRankine, quantity04.Unit);
 
-            var quantity05 = TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeReaumur);
+            var quantity05 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeReaumur);
             AssertEx.EqualTolerance(1, quantity05.DegreesReaumur, DegreesReaumurTolerance);
             Assert.Equal(TemperatureDeltaUnit.DegreeReaumur, quantity05.Unit);
 
-            var quantity06 = TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeRoemer);
+            var quantity06 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.DegreeRoemer);
             AssertEx.EqualTolerance(1, quantity06.DegreesRoemer, DegreesRoemerTolerance);
             Assert.Equal(TemperatureDeltaUnit.DegreeRoemer, quantity06.Unit);
 
-            var quantity07 = TemperatureDelta.From(1, TemperatureDeltaUnit.Kelvin);
+            var quantity07 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.Kelvin);
             AssertEx.EqualTolerance(1, quantity07.Kelvins, KelvinsTolerance);
             Assert.Equal(TemperatureDeltaUnit.Kelvin, quantity07.Unit);
 
-            var quantity08 = TemperatureDelta.From(1, TemperatureDeltaUnit.MillidegreeCelsius);
+            var quantity08 = TemperatureDelta<double>.From(1, TemperatureDeltaUnit.MillidegreeCelsius);
             AssertEx.EqualTolerance(1, quantity08.MillidegreesCelsius, MillidegreesCelsiusTolerance);
             Assert.Equal(TemperatureDeltaUnit.MillidegreeCelsius, quantity08.Unit);
 
@@ -186,20 +186,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKelvins_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => TemperatureDelta.FromKelvins(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => TemperatureDelta.FromKelvins(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => TemperatureDelta<double>.FromKelvins(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => TemperatureDelta<double>.FromKelvins(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKelvins_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => TemperatureDelta.FromKelvins(double.NaN));
+            Assert.Throws<ArgumentException>(() => TemperatureDelta<double>.FromKelvins(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kelvin = TemperatureDelta.FromKelvins(1);
+            var kelvin = TemperatureDelta<double>.FromKelvins(1);
             AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeCelsius), DegreesCelsiusTolerance);
             AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeDelisle), DegreesDelisleTolerance);
             AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeFahrenheit), DegreesFahrenheitTolerance);
@@ -231,7 +231,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kelvin = TemperatureDelta.FromKelvins(1);
+            var kelvin = TemperatureDelta<double>.FromKelvins(1);
 
             var degreecelsiusQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeCelsius);
             AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, (double)degreecelsiusQuantity.Value, DegreesCelsiusTolerance);
@@ -280,36 +280,36 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins, MillidegreesCelsiusTolerance);
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(1, TemperatureDelta<double>.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins, MillidegreesCelsiusTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            TemperatureDelta v = TemperatureDelta.FromKelvins(1);
+            TemperatureDelta<double> v = TemperatureDelta<double>.FromKelvins(1);
             AssertEx.EqualTolerance(-1, -v.Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvins(3)-v).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(2, (TemperatureDelta<double>.FromKelvins(3)-v).Kelvins, KelvinsTolerance);
             AssertEx.EqualTolerance(2, (v + v).Kelvins, KelvinsTolerance);
             AssertEx.EqualTolerance(10, (v*10).Kelvins, KelvinsTolerance);
             AssertEx.EqualTolerance(10, (10*v).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvins(10)/5).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(2, TemperatureDelta.FromKelvins(10)/TemperatureDelta.FromKelvins(5), KelvinsTolerance);
+            AssertEx.EqualTolerance(2, (TemperatureDelta<double>.FromKelvins(10)/5).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(2, TemperatureDelta<double>.FromKelvins(10)/TemperatureDelta<double>.FromKelvins(5), KelvinsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            TemperatureDelta oneKelvin = TemperatureDelta.FromKelvins(1);
-            TemperatureDelta twoKelvins = TemperatureDelta.FromKelvins(2);
+            TemperatureDelta<double> oneKelvin = TemperatureDelta<double>.FromKelvins(1);
+            TemperatureDelta<double> twoKelvins = TemperatureDelta<double>.FromKelvins(2);
 
             Assert.True(oneKelvin < twoKelvins);
             Assert.True(oneKelvin <= twoKelvins);
@@ -325,31 +325,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
             Assert.Equal(0, kelvin.CompareTo(kelvin));
-            Assert.True(kelvin.CompareTo(TemperatureDelta.Zero) > 0);
-            Assert.True(TemperatureDelta.Zero.CompareTo(kelvin) < 0);
+            Assert.True(kelvin.CompareTo(TemperatureDelta<double>.Zero) > 0);
+            Assert.True(TemperatureDelta<double>.Zero.CompareTo(kelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
             Assert.Throws<ArgumentException>(() => kelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
             Assert.Throws<ArgumentNullException>(() => kelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = TemperatureDelta.FromKelvins(1);
-            var b = TemperatureDelta.FromKelvins(2);
+            var a = TemperatureDelta<double>.FromKelvins(1);
+            var b = TemperatureDelta<double>.FromKelvins(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -368,8 +368,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = TemperatureDelta.FromKelvins(1);
-            var b = TemperatureDelta.FromKelvins(2);
+            var a = TemperatureDelta<double>.FromKelvins(1);
+            var b = TemperatureDelta<double>.FromKelvins(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -389,9 +389,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = TemperatureDelta.FromKelvins(1);
-            Assert.True(v.Equals(TemperatureDelta.FromKelvins(1), KelvinsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(TemperatureDelta.Zero, KelvinsTolerance, ComparisonType.Relative));
+            var v = TemperatureDelta<double>.FromKelvins(1);
+            Assert.True(v.Equals(TemperatureDelta<double>.FromKelvins(1), KelvinsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(TemperatureDelta<double>.Zero, KelvinsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -404,21 +404,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
             Assert.False(kelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
+            TemperatureDelta<double> kelvin = TemperatureDelta<double>.FromKelvins(1);
             Assert.False(kelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(TemperatureDeltaUnit.Undefined, TemperatureDelta.Units);
+            Assert.DoesNotContain(TemperatureDeltaUnit.Undefined, TemperatureDelta<double>.Units);
         }
 
         [Fact]
@@ -437,7 +437,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(TemperatureDelta.BaseDimensions is null);
+            Assert.False(TemperatureDelta<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs
index e0cfb18096..88681c6c82 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs
@@ -64,7 +64,7 @@ public abstract partial class TemperatureTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Temperature((double)0.0, TemperatureUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Temperature<double>((double)0.0, TemperatureUnit.Undefined));
         }
 
         [Fact]
@@ -79,14 +79,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Temperature(double.PositiveInfinity, TemperatureUnit.Kelvin));
-            Assert.Throws<ArgumentException>(() => new Temperature(double.NegativeInfinity, TemperatureUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new Temperature<double>(double.PositiveInfinity, TemperatureUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new Temperature<double>(double.NegativeInfinity, TemperatureUnit.Kelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Temperature(double.NaN, TemperatureUnit.Kelvin));
+            Assert.Throws<ArgumentException>(() => new Temperature<double>(double.NaN, TemperatureUnit.Kelvin));
         }
 
         [Fact]
@@ -132,7 +132,7 @@ public void Temperature_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void KelvinToTemperatureUnits()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
             AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.DegreesCelsius, DegreesCelsiusTolerance);
             AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.DegreesDelisle, DegreesDelisleTolerance);
             AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.DegreesFahrenheit, DegreesFahrenheitTolerance);
@@ -148,43 +148,43 @@ public void KelvinToTemperatureUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Temperature.From(1, TemperatureUnit.DegreeCelsius);
+            var quantity00 = Temperature<double>.From(1, TemperatureUnit.DegreeCelsius);
             AssertEx.EqualTolerance(1, quantity00.DegreesCelsius, DegreesCelsiusTolerance);
             Assert.Equal(TemperatureUnit.DegreeCelsius, quantity00.Unit);
 
-            var quantity01 = Temperature.From(1, TemperatureUnit.DegreeDelisle);
+            var quantity01 = Temperature<double>.From(1, TemperatureUnit.DegreeDelisle);
             AssertEx.EqualTolerance(1, quantity01.DegreesDelisle, DegreesDelisleTolerance);
             Assert.Equal(TemperatureUnit.DegreeDelisle, quantity01.Unit);
 
-            var quantity02 = Temperature.From(1, TemperatureUnit.DegreeFahrenheit);
+            var quantity02 = Temperature<double>.From(1, TemperatureUnit.DegreeFahrenheit);
             AssertEx.EqualTolerance(1, quantity02.DegreesFahrenheit, DegreesFahrenheitTolerance);
             Assert.Equal(TemperatureUnit.DegreeFahrenheit, quantity02.Unit);
 
-            var quantity03 = Temperature.From(1, TemperatureUnit.DegreeNewton);
+            var quantity03 = Temperature<double>.From(1, TemperatureUnit.DegreeNewton);
             AssertEx.EqualTolerance(1, quantity03.DegreesNewton, DegreesNewtonTolerance);
             Assert.Equal(TemperatureUnit.DegreeNewton, quantity03.Unit);
 
-            var quantity04 = Temperature.From(1, TemperatureUnit.DegreeRankine);
+            var quantity04 = Temperature<double>.From(1, TemperatureUnit.DegreeRankine);
             AssertEx.EqualTolerance(1, quantity04.DegreesRankine, DegreesRankineTolerance);
             Assert.Equal(TemperatureUnit.DegreeRankine, quantity04.Unit);
 
-            var quantity05 = Temperature.From(1, TemperatureUnit.DegreeReaumur);
+            var quantity05 = Temperature<double>.From(1, TemperatureUnit.DegreeReaumur);
             AssertEx.EqualTolerance(1, quantity05.DegreesReaumur, DegreesReaumurTolerance);
             Assert.Equal(TemperatureUnit.DegreeReaumur, quantity05.Unit);
 
-            var quantity06 = Temperature.From(1, TemperatureUnit.DegreeRoemer);
+            var quantity06 = Temperature<double>.From(1, TemperatureUnit.DegreeRoemer);
             AssertEx.EqualTolerance(1, quantity06.DegreesRoemer, DegreesRoemerTolerance);
             Assert.Equal(TemperatureUnit.DegreeRoemer, quantity06.Unit);
 
-            var quantity07 = Temperature.From(1, TemperatureUnit.Kelvin);
+            var quantity07 = Temperature<double>.From(1, TemperatureUnit.Kelvin);
             AssertEx.EqualTolerance(1, quantity07.Kelvins, KelvinsTolerance);
             Assert.Equal(TemperatureUnit.Kelvin, quantity07.Unit);
 
-            var quantity08 = Temperature.From(1, TemperatureUnit.MillidegreeCelsius);
+            var quantity08 = Temperature<double>.From(1, TemperatureUnit.MillidegreeCelsius);
             AssertEx.EqualTolerance(1, quantity08.MillidegreesCelsius, MillidegreesCelsiusTolerance);
             Assert.Equal(TemperatureUnit.MillidegreeCelsius, quantity08.Unit);
 
-            var quantity09 = Temperature.From(1, TemperatureUnit.SolarTemperature);
+            var quantity09 = Temperature<double>.From(1, TemperatureUnit.SolarTemperature);
             AssertEx.EqualTolerance(1, quantity09.SolarTemperatures, SolarTemperaturesTolerance);
             Assert.Equal(TemperatureUnit.SolarTemperature, quantity09.Unit);
 
@@ -193,20 +193,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromKelvins_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Temperature.FromKelvins(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Temperature.FromKelvins(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Temperature<double>.FromKelvins(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Temperature<double>.FromKelvins(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromKelvins_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Temperature.FromKelvins(double.NaN));
+            Assert.Throws<ArgumentException>(() => Temperature<double>.FromKelvins(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var kelvin = Temperature.FromKelvins(1);
+            var kelvin = Temperature<double>.FromKelvins(1);
             AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.As(TemperatureUnit.DegreeCelsius), DegreesCelsiusTolerance);
             AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.As(TemperatureUnit.DegreeDelisle), DegreesDelisleTolerance);
             AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.As(TemperatureUnit.DegreeFahrenheit), DegreesFahrenheitTolerance);
@@ -239,7 +239,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var kelvin = Temperature.FromKelvins(1);
+            var kelvin = Temperature<double>.FromKelvins(1);
 
             var degreecelsiusQuantity = kelvin.ToUnit(TemperatureUnit.DegreeCelsius);
             AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, (double)degreecelsiusQuantity.Value, DegreesCelsiusTolerance);
@@ -292,25 +292,25 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins, MillidegreesCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromSolarTemperatures(kelvin.SolarTemperatures).Kelvins, SolarTemperaturesTolerance);
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins, MillidegreesCelsiusTolerance);
+            AssertEx.EqualTolerance(1, Temperature<double>.FromSolarTemperatures(kelvin.SolarTemperatures).Kelvins, SolarTemperaturesTolerance);
         }
 
 
         [Fact]
         public void ComparisonOperators()
         {
-            Temperature oneKelvin = Temperature.FromKelvins(1);
-            Temperature twoKelvins = Temperature.FromKelvins(2);
+            Temperature<double> oneKelvin = Temperature<double>.FromKelvins(1);
+            Temperature<double> twoKelvins = Temperature<double>.FromKelvins(2);
 
             Assert.True(oneKelvin < twoKelvins);
             Assert.True(oneKelvin <= twoKelvins);
@@ -326,31 +326,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
             Assert.Equal(0, kelvin.CompareTo(kelvin));
-            Assert.True(kelvin.CompareTo(Temperature.Zero) > 0);
-            Assert.True(Temperature.Zero.CompareTo(kelvin) < 0);
+            Assert.True(kelvin.CompareTo(Temperature<double>.Zero) > 0);
+            Assert.True(Temperature<double>.Zero.CompareTo(kelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
             Assert.Throws<ArgumentException>(() => kelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
             Assert.Throws<ArgumentNullException>(() => kelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Temperature.FromKelvins(1);
-            var b = Temperature.FromKelvins(2);
+            var a = Temperature<double>.FromKelvins(1);
+            var b = Temperature<double>.FromKelvins(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -369,8 +369,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Temperature.FromKelvins(1);
-            var b = Temperature.FromKelvins(2);
+            var a = Temperature<double>.FromKelvins(1);
+            var b = Temperature<double>.FromKelvins(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -390,9 +390,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Temperature.FromKelvins(1);
-            Assert.True(v.Equals(Temperature.FromKelvins(1), KelvinsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Temperature.Zero, KelvinsTolerance, ComparisonType.Relative));
+            var v = Temperature<double>.FromKelvins(1);
+            Assert.True(v.Equals(Temperature<double>.FromKelvins(1), KelvinsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Temperature<double>.Zero, KelvinsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -405,21 +405,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
             Assert.False(kelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
+            Temperature<double> kelvin = Temperature<double>.FromKelvins(1);
             Assert.False(kelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(TemperatureUnit.Undefined, Temperature.Units);
+            Assert.DoesNotContain(TemperatureUnit.Undefined, Temperature<double>.Units);
         }
 
         [Fact]
@@ -438,7 +438,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Temperature.BaseDimensions is null);
+            Assert.False(Temperature<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs
index 8d52205d81..1cd5ab17c5 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs
@@ -48,7 +48,7 @@ public abstract partial class ThermalConductivityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ThermalConductivity((double)0.0, ThermalConductivityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>((double)0.0, ThermalConductivityUnit.Undefined));
         }
 
         [Fact]
@@ -63,14 +63,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ThermalConductivity(double.PositiveInfinity, ThermalConductivityUnit.WattPerMeterKelvin));
-            Assert.Throws<ArgumentException>(() => new ThermalConductivity(double.NegativeInfinity, ThermalConductivityUnit.WattPerMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>(double.PositiveInfinity, ThermalConductivityUnit.WattPerMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>(double.NegativeInfinity, ThermalConductivityUnit.WattPerMeterKelvin));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ThermalConductivity(double.NaN, ThermalConductivityUnit.WattPerMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>(double.NaN, ThermalConductivityUnit.WattPerMeterKelvin));
         }
 
         [Fact]
@@ -116,7 +116,7 @@ public void ThermalConductivity_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void WattPerMeterKelvinToThermalConductivityUnits()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.BtusPerHourFootFahrenheit, BtusPerHourFootFahrenheitTolerance);
             AssertEx.EqualTolerance(WattsPerMeterKelvinInOneWattPerMeterKelvin, wattpermeterkelvin.WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
         }
@@ -124,11 +124,11 @@ public void WattPerMeterKelvinToThermalConductivityUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ThermalConductivity.From(1, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
+            var quantity00 = ThermalConductivity<double>.From(1, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
             AssertEx.EqualTolerance(1, quantity00.BtusPerHourFootFahrenheit, BtusPerHourFootFahrenheitTolerance);
             Assert.Equal(ThermalConductivityUnit.BtuPerHourFootFahrenheit, quantity00.Unit);
 
-            var quantity01 = ThermalConductivity.From(1, ThermalConductivityUnit.WattPerMeterKelvin);
+            var quantity01 = ThermalConductivity<double>.From(1, ThermalConductivityUnit.WattPerMeterKelvin);
             AssertEx.EqualTolerance(1, quantity01.WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
             Assert.Equal(ThermalConductivityUnit.WattPerMeterKelvin, quantity01.Unit);
 
@@ -137,20 +137,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromWattsPerMeterKelvin_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ThermalConductivity.FromWattsPerMeterKelvin(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ThermalConductivity.FromWattsPerMeterKelvin(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ThermalConductivity<double>.FromWattsPerMeterKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ThermalConductivity<double>.FromWattsPerMeterKelvin(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromWattsPerMeterKelvin_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ThermalConductivity.FromWattsPerMeterKelvin(double.NaN));
+            Assert.Throws<ArgumentException>(() => ThermalConductivity<double>.FromWattsPerMeterKelvin(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            var wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.As(ThermalConductivityUnit.BtuPerHourFootFahrenheit), BtusPerHourFootFahrenheitTolerance);
             AssertEx.EqualTolerance(WattsPerMeterKelvinInOneWattPerMeterKelvin, wattpermeterkelvin.As(ThermalConductivityUnit.WattPerMeterKelvin), WattsPerMeterKelvinTolerance);
         }
@@ -175,7 +175,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            var wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
 
             var btuperhourfootfahrenheitQuantity = wattpermeterkelvin.ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit);
             AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, (double)btuperhourfootfahrenheitQuantity.Value, BtusPerHourFootFahrenheitTolerance);
@@ -196,29 +196,29 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
-            AssertEx.EqualTolerance(1, ThermalConductivity.FromBtusPerHourFootFahrenheit(wattpermeterkelvin.BtusPerHourFootFahrenheit).WattsPerMeterKelvin, BtusPerHourFootFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, ThermalConductivity.FromWattsPerMeterKelvin(wattpermeterkelvin.WattsPerMeterKelvin).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            AssertEx.EqualTolerance(1, ThermalConductivity<double>.FromBtusPerHourFootFahrenheit(wattpermeterkelvin.BtusPerHourFootFahrenheit).WattsPerMeterKelvin, BtusPerHourFootFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, ThermalConductivity<double>.FromWattsPerMeterKelvin(wattpermeterkelvin.WattsPerMeterKelvin).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ThermalConductivity v = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> v = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             AssertEx.EqualTolerance(-1, -v.WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (ThermalConductivity.FromWattsPerMeterKelvin(3)-v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (ThermalConductivity<double>.FromWattsPerMeterKelvin(3)-v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
             AssertEx.EqualTolerance(2, (v + v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
             AssertEx.EqualTolerance(10, (v*10).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
             AssertEx.EqualTolerance(10, (10*v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (ThermalConductivity.FromWattsPerMeterKelvin(10)/5).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, ThermalConductivity.FromWattsPerMeterKelvin(10)/ThermalConductivity.FromWattsPerMeterKelvin(5), WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (ThermalConductivity<double>.FromWattsPerMeterKelvin(10)/5).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, ThermalConductivity<double>.FromWattsPerMeterKelvin(10)/ThermalConductivity<double>.FromWattsPerMeterKelvin(5), WattsPerMeterKelvinTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ThermalConductivity oneWattPerMeterKelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
-            ThermalConductivity twoWattsPerMeterKelvin = ThermalConductivity.FromWattsPerMeterKelvin(2);
+            ThermalConductivity<double> oneWattPerMeterKelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> twoWattsPerMeterKelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(2);
 
             Assert.True(oneWattPerMeterKelvin < twoWattsPerMeterKelvin);
             Assert.True(oneWattPerMeterKelvin <= twoWattsPerMeterKelvin);
@@ -234,31 +234,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             Assert.Equal(0, wattpermeterkelvin.CompareTo(wattpermeterkelvin));
-            Assert.True(wattpermeterkelvin.CompareTo(ThermalConductivity.Zero) > 0);
-            Assert.True(ThermalConductivity.Zero.CompareTo(wattpermeterkelvin) < 0);
+            Assert.True(wattpermeterkelvin.CompareTo(ThermalConductivity<double>.Zero) > 0);
+            Assert.True(ThermalConductivity<double>.Zero.CompareTo(wattpermeterkelvin) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             Assert.Throws<ArgumentException>(() => wattpermeterkelvin.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             Assert.Throws<ArgumentNullException>(() => wattpermeterkelvin.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ThermalConductivity.FromWattsPerMeterKelvin(1);
-            var b = ThermalConductivity.FromWattsPerMeterKelvin(2);
+            var a = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            var b = ThermalConductivity<double>.FromWattsPerMeterKelvin(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -277,8 +277,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ThermalConductivity.FromWattsPerMeterKelvin(1);
-            var b = ThermalConductivity.FromWattsPerMeterKelvin(2);
+            var a = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            var b = ThermalConductivity<double>.FromWattsPerMeterKelvin(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -298,9 +298,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ThermalConductivity.FromWattsPerMeterKelvin(1);
-            Assert.True(v.Equals(ThermalConductivity.FromWattsPerMeterKelvin(1), WattsPerMeterKelvinTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ThermalConductivity.Zero, WattsPerMeterKelvinTolerance, ComparisonType.Relative));
+            var v = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            Assert.True(v.Equals(ThermalConductivity<double>.FromWattsPerMeterKelvin(1), WattsPerMeterKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ThermalConductivity<double>.Zero, WattsPerMeterKelvinTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -313,21 +313,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             Assert.False(wattpermeterkelvin.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
             Assert.False(wattpermeterkelvin.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ThermalConductivityUnit.Undefined, ThermalConductivity.Units);
+            Assert.DoesNotContain(ThermalConductivityUnit.Undefined, ThermalConductivity<double>.Units);
         }
 
         [Fact]
@@ -346,7 +346,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ThermalConductivity.BaseDimensions is null);
+            Assert.False(ThermalConductivity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs
index da33a0a381..4690474acb 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs
@@ -54,7 +54,7 @@ public abstract partial class ThermalResistanceTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ThermalResistance((double)0.0, ThermalResistanceUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>((double)0.0, ThermalResistanceUnit.Undefined));
         }
 
         [Fact]
@@ -69,14 +69,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ThermalResistance(double.PositiveInfinity, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
-            Assert.Throws<ArgumentException>(() => new ThermalResistance(double.NegativeInfinity, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>(double.PositiveInfinity, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>(double.NegativeInfinity, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new ThermalResistance(double.NaN, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>(double.NaN, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
         }
 
         [Fact]
@@ -122,7 +122,7 @@ public void ThermalResistance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
         [Fact]
         public void SquareMeterKelvinPerKilowattToThermalResistanceUnits()
         {
-            ThermalResistance squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             AssertEx.EqualTolerance(HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.HourSquareFeetDegreesFahrenheitPerBtu, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
             AssertEx.EqualTolerance(SquareCentimeterHourDegreesCelsiusPerKilocalorieInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.SquareCentimeterHourDegreesCelsiusPerKilocalorie, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
             AssertEx.EqualTolerance(SquareCentimeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.SquareCentimeterKelvinsPerWatt, SquareCentimeterKelvinsPerWattTolerance);
@@ -133,23 +133,23 @@ public void SquareMeterKelvinPerKilowattToThermalResistanceUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = ThermalResistance.From(1, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
+            var quantity00 = ThermalResistance<double>.From(1, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
             AssertEx.EqualTolerance(1, quantity00.HourSquareFeetDegreesFahrenheitPerBtu, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
             Assert.Equal(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, quantity00.Unit);
 
-            var quantity01 = ThermalResistance.From(1, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
+            var quantity01 = ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
             AssertEx.EqualTolerance(1, quantity01.SquareCentimeterHourDegreesCelsiusPerKilocalorie, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
             Assert.Equal(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, quantity01.Unit);
 
-            var quantity02 = ThermalResistance.From(1, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
+            var quantity02 = ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
             AssertEx.EqualTolerance(1, quantity02.SquareCentimeterKelvinsPerWatt, SquareCentimeterKelvinsPerWattTolerance);
             Assert.Equal(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, quantity02.Unit);
 
-            var quantity03 = ThermalResistance.From(1, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
+            var quantity03 = ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
             AssertEx.EqualTolerance(1, quantity03.SquareMeterDegreesCelsiusPerWatt, SquareMeterDegreesCelsiusPerWattTolerance);
             Assert.Equal(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, quantity03.Unit);
 
-            var quantity04 = ThermalResistance.From(1, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
+            var quantity04 = ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
             AssertEx.EqualTolerance(1, quantity04.SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
             Assert.Equal(ThermalResistanceUnit.SquareMeterKelvinPerKilowatt, quantity04.Unit);
 
@@ -158,20 +158,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromSquareMeterKelvinsPerKilowatt_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ThermalResistance.FromSquareMeterKelvinsPerKilowatt(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => ThermalResistance.FromSquareMeterKelvinsPerKilowatt(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromSquareMeterKelvinsPerKilowatt_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => ThermalResistance.FromSquareMeterKelvinsPerKilowatt(double.NaN));
+            Assert.Throws<ArgumentException>(() => ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            var squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             AssertEx.EqualTolerance(HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu), HourSquareFeetDegreesFahrenheitPerBtuTolerance);
             AssertEx.EqualTolerance(SquareCentimeterHourDegreesCelsiusPerKilocalorieInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie), SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
             AssertEx.EqualTolerance(SquareCentimeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt), SquareCentimeterKelvinsPerWattTolerance);
@@ -199,7 +199,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            var squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
 
             var hoursquarefeetdegreefahrenheitperbtuQuantity = squaremeterkelvinperkilowatt.ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
             AssertEx.EqualTolerance(HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerKilowatt, (double)hoursquarefeetdegreefahrenheitperbtuQuantity.Value, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
@@ -232,32 +232,32 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            ThermalResistance squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
-            AssertEx.EqualTolerance(1, ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(squaremeterkelvinperkilowatt.HourSquareFeetDegreesFahrenheitPerBtu).SquareMeterKelvinsPerKilowatt, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
-            AssertEx.EqualTolerance(1, ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(squaremeterkelvinperkilowatt.SquareCentimeterHourDegreesCelsiusPerKilocalorie).SquareMeterKelvinsPerKilowatt, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
-            AssertEx.EqualTolerance(1, ThermalResistance.FromSquareCentimeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareCentimeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt, SquareCentimeterKelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(1, ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(squaremeterkelvinperkilowatt.SquareMeterDegreesCelsiusPerWatt).SquareMeterKelvinsPerKilowatt, SquareMeterDegreesCelsiusPerWattTolerance);
-            AssertEx.EqualTolerance(1, ThermalResistance.FromSquareMeterKelvinsPerKilowatt(squaremeterkelvinperkilowatt.SquareMeterKelvinsPerKilowatt).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromHourSquareFeetDegreesFahrenheitPerBtu(squaremeterkelvinperkilowatt.HourSquareFeetDegreesFahrenheitPerBtu).SquareMeterKelvinsPerKilowatt, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(squaremeterkelvinperkilowatt.SquareCentimeterHourDegreesCelsiusPerKilocalorie).SquareMeterKelvinsPerKilowatt, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareCentimeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareCentimeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt, SquareCentimeterKelvinsPerWattTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareMeterDegreesCelsiusPerWatt(squaremeterkelvinperkilowatt.SquareMeterDegreesCelsiusPerWatt).SquareMeterKelvinsPerKilowatt, SquareMeterDegreesCelsiusPerWattTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(squaremeterkelvinperkilowatt.SquareMeterKelvinsPerKilowatt).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            ThermalResistance v = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> v = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             AssertEx.EqualTolerance(-1, -v.SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(2, (ThermalResistance.FromSquareMeterKelvinsPerKilowatt(3)-v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(2, (ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(3)-v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
             AssertEx.EqualTolerance(2, (v + v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
             AssertEx.EqualTolerance(10, (v*10).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
             AssertEx.EqualTolerance(10, (10*v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(2, (ThermalResistance.FromSquareMeterKelvinsPerKilowatt(10)/5).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(2, ThermalResistance.FromSquareMeterKelvinsPerKilowatt(10)/ThermalResistance.FromSquareMeterKelvinsPerKilowatt(5), SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(2, (ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(10)/5).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(2, ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(10)/ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(5), SquareMeterKelvinsPerKilowattTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            ThermalResistance oneSquareMeterKelvinPerKilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
-            ThermalResistance twoSquareMeterKelvinsPerKilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(2);
+            ThermalResistance<double> oneSquareMeterKelvinPerKilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> twoSquareMeterKelvinsPerKilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(2);
 
             Assert.True(oneSquareMeterKelvinPerKilowatt < twoSquareMeterKelvinsPerKilowatt);
             Assert.True(oneSquareMeterKelvinPerKilowatt <= twoSquareMeterKelvinsPerKilowatt);
@@ -273,31 +273,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            ThermalResistance squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             Assert.Equal(0, squaremeterkelvinperkilowatt.CompareTo(squaremeterkelvinperkilowatt));
-            Assert.True(squaremeterkelvinperkilowatt.CompareTo(ThermalResistance.Zero) > 0);
-            Assert.True(ThermalResistance.Zero.CompareTo(squaremeterkelvinperkilowatt) < 0);
+            Assert.True(squaremeterkelvinperkilowatt.CompareTo(ThermalResistance<double>.Zero) > 0);
+            Assert.True(ThermalResistance<double>.Zero.CompareTo(squaremeterkelvinperkilowatt) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            ThermalResistance squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             Assert.Throws<ArgumentException>(() => squaremeterkelvinperkilowatt.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            ThermalResistance squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             Assert.Throws<ArgumentNullException>(() => squaremeterkelvinperkilowatt.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
-            var b = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(2);
+            var a = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            var b = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -316,8 +316,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
-            var b = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(2);
+            var a = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            var b = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -337,9 +337,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
-            Assert.True(v.Equals(ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1), SquareMeterKelvinsPerKilowattTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(ThermalResistance.Zero, SquareMeterKelvinsPerKilowattTolerance, ComparisonType.Relative));
+            var v = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            Assert.True(v.Equals(ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1), SquareMeterKelvinsPerKilowattTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ThermalResistance<double>.Zero, SquareMeterKelvinsPerKilowattTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -352,21 +352,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            ThermalResistance squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             Assert.False(squaremeterkelvinperkilowatt.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            ThermalResistance squaremeterkelvinperkilowatt = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
             Assert.False(squaremeterkelvinperkilowatt.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(ThermalResistanceUnit.Undefined, ThermalResistance.Units);
+            Assert.DoesNotContain(ThermalResistanceUnit.Undefined, ThermalResistance<double>.Units);
         }
 
         [Fact]
@@ -385,7 +385,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(ThermalResistance.BaseDimensions is null);
+            Assert.False(ThermalResistance<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TorquePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TorquePerLengthTestsBase.g.cs
index 17746e4b5e..4e17d773b9 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TorquePerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TorquePerLengthTestsBase.g.cs
@@ -86,7 +86,7 @@ public abstract partial class TorquePerLengthTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TorquePerLength((double)0.0, TorquePerLengthUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new TorquePerLength<double>((double)0.0, TorquePerLengthUnit.Undefined));
         }
 
         [Fact]
@@ -101,14 +101,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TorquePerLength(double.PositiveInfinity, TorquePerLengthUnit.NewtonMeterPerMeter));
-            Assert.Throws<ArgumentException>(() => new TorquePerLength(double.NegativeInfinity, TorquePerLengthUnit.NewtonMeterPerMeter));
+            Assert.Throws<ArgumentException>(() => new TorquePerLength<double>(double.PositiveInfinity, TorquePerLengthUnit.NewtonMeterPerMeter));
+            Assert.Throws<ArgumentException>(() => new TorquePerLength<double>(double.NegativeInfinity, TorquePerLengthUnit.NewtonMeterPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new TorquePerLength(double.NaN, TorquePerLengthUnit.NewtonMeterPerMeter));
+            Assert.Throws<ArgumentException>(() => new TorquePerLength<double>(double.NaN, TorquePerLengthUnit.NewtonMeterPerMeter));
         }
 
         [Fact]
@@ -154,7 +154,7 @@ public void TorquePerLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void NewtonMeterPerMeterToTorquePerLengthUnits()
         {
-            TorquePerLength newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             AssertEx.EqualTolerance(KilogramForceCentimetersPerMeterInOneNewtonMeterPerMeter, newtonmeterpermeter.KilogramForceCentimetersPerMeter, KilogramForceCentimetersPerMeterTolerance);
             AssertEx.EqualTolerance(KilogramForceMetersPerMeterInOneNewtonMeterPerMeter, newtonmeterpermeter.KilogramForceMetersPerMeter, KilogramForceMetersPerMeterTolerance);
             AssertEx.EqualTolerance(KilogramForceMillimetersPerMeterInOneNewtonMeterPerMeter, newtonmeterpermeter.KilogramForceMillimetersPerMeter, KilogramForceMillimetersPerMeterTolerance);
@@ -181,87 +181,87 @@ public void NewtonMeterPerMeterToTorquePerLengthUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = TorquePerLength.From(1, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
+            var quantity00 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity00.KilogramForceCentimetersPerMeter, KilogramForceCentimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.KilogramForceCentimeterPerMeter, quantity00.Unit);
 
-            var quantity01 = TorquePerLength.From(1, TorquePerLengthUnit.KilogramForceMeterPerMeter);
+            var quantity01 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilogramForceMeterPerMeter);
             AssertEx.EqualTolerance(1, quantity01.KilogramForceMetersPerMeter, KilogramForceMetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.KilogramForceMeterPerMeter, quantity01.Unit);
 
-            var quantity02 = TorquePerLength.From(1, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
+            var quantity02 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity02.KilogramForceMillimetersPerMeter, KilogramForceMillimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.KilogramForceMillimeterPerMeter, quantity02.Unit);
 
-            var quantity03 = TorquePerLength.From(1, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
+            var quantity03 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity03.KilonewtonCentimetersPerMeter, KilonewtonCentimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.KilonewtonCentimeterPerMeter, quantity03.Unit);
 
-            var quantity04 = TorquePerLength.From(1, TorquePerLengthUnit.KilonewtonMeterPerMeter);
+            var quantity04 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilonewtonMeterPerMeter);
             AssertEx.EqualTolerance(1, quantity04.KilonewtonMetersPerMeter, KilonewtonMetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.KilonewtonMeterPerMeter, quantity04.Unit);
 
-            var quantity05 = TorquePerLength.From(1, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
+            var quantity05 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity05.KilonewtonMillimetersPerMeter, KilonewtonMillimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.KilonewtonMillimeterPerMeter, quantity05.Unit);
 
-            var quantity06 = TorquePerLength.From(1, TorquePerLengthUnit.KilopoundForceFootPerFoot);
+            var quantity06 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilopoundForceFootPerFoot);
             AssertEx.EqualTolerance(1, quantity06.KilopoundForceFeetPerFoot, KilopoundForceFeetPerFootTolerance);
             Assert.Equal(TorquePerLengthUnit.KilopoundForceFootPerFoot, quantity06.Unit);
 
-            var quantity07 = TorquePerLength.From(1, TorquePerLengthUnit.KilopoundForceInchPerFoot);
+            var quantity07 = TorquePerLength<double>.From(1, TorquePerLengthUnit.KilopoundForceInchPerFoot);
             AssertEx.EqualTolerance(1, quantity07.KilopoundForceInchesPerFoot, KilopoundForceInchesPerFootTolerance);
             Assert.Equal(TorquePerLengthUnit.KilopoundForceInchPerFoot, quantity07.Unit);
 
-            var quantity08 = TorquePerLength.From(1, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
+            var quantity08 = TorquePerLength<double>.From(1, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity08.MeganewtonCentimetersPerMeter, MeganewtonCentimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.MeganewtonCentimeterPerMeter, quantity08.Unit);
 
-            var quantity09 = TorquePerLength.From(1, TorquePerLengthUnit.MeganewtonMeterPerMeter);
+            var quantity09 = TorquePerLength<double>.From(1, TorquePerLengthUnit.MeganewtonMeterPerMeter);
             AssertEx.EqualTolerance(1, quantity09.MeganewtonMetersPerMeter, MeganewtonMetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.MeganewtonMeterPerMeter, quantity09.Unit);
 
-            var quantity10 = TorquePerLength.From(1, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
+            var quantity10 = TorquePerLength<double>.From(1, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity10.MeganewtonMillimetersPerMeter, MeganewtonMillimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.MeganewtonMillimeterPerMeter, quantity10.Unit);
 
-            var quantity11 = TorquePerLength.From(1, TorquePerLengthUnit.MegapoundForceFootPerFoot);
+            var quantity11 = TorquePerLength<double>.From(1, TorquePerLengthUnit.MegapoundForceFootPerFoot);
             AssertEx.EqualTolerance(1, quantity11.MegapoundForceFeetPerFoot, MegapoundForceFeetPerFootTolerance);
             Assert.Equal(TorquePerLengthUnit.MegapoundForceFootPerFoot, quantity11.Unit);
 
-            var quantity12 = TorquePerLength.From(1, TorquePerLengthUnit.MegapoundForceInchPerFoot);
+            var quantity12 = TorquePerLength<double>.From(1, TorquePerLengthUnit.MegapoundForceInchPerFoot);
             AssertEx.EqualTolerance(1, quantity12.MegapoundForceInchesPerFoot, MegapoundForceInchesPerFootTolerance);
             Assert.Equal(TorquePerLengthUnit.MegapoundForceInchPerFoot, quantity12.Unit);
 
-            var quantity13 = TorquePerLength.From(1, TorquePerLengthUnit.NewtonCentimeterPerMeter);
+            var quantity13 = TorquePerLength<double>.From(1, TorquePerLengthUnit.NewtonCentimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity13.NewtonCentimetersPerMeter, NewtonCentimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.NewtonCentimeterPerMeter, quantity13.Unit);
 
-            var quantity14 = TorquePerLength.From(1, TorquePerLengthUnit.NewtonMeterPerMeter);
+            var quantity14 = TorquePerLength<double>.From(1, TorquePerLengthUnit.NewtonMeterPerMeter);
             AssertEx.EqualTolerance(1, quantity14.NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.NewtonMeterPerMeter, quantity14.Unit);
 
-            var quantity15 = TorquePerLength.From(1, TorquePerLengthUnit.NewtonMillimeterPerMeter);
+            var quantity15 = TorquePerLength<double>.From(1, TorquePerLengthUnit.NewtonMillimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity15.NewtonMillimetersPerMeter, NewtonMillimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.NewtonMillimeterPerMeter, quantity15.Unit);
 
-            var quantity16 = TorquePerLength.From(1, TorquePerLengthUnit.PoundForceFootPerFoot);
+            var quantity16 = TorquePerLength<double>.From(1, TorquePerLengthUnit.PoundForceFootPerFoot);
             AssertEx.EqualTolerance(1, quantity16.PoundForceFeetPerFoot, PoundForceFeetPerFootTolerance);
             Assert.Equal(TorquePerLengthUnit.PoundForceFootPerFoot, quantity16.Unit);
 
-            var quantity17 = TorquePerLength.From(1, TorquePerLengthUnit.PoundForceInchPerFoot);
+            var quantity17 = TorquePerLength<double>.From(1, TorquePerLengthUnit.PoundForceInchPerFoot);
             AssertEx.EqualTolerance(1, quantity17.PoundForceInchesPerFoot, PoundForceInchesPerFootTolerance);
             Assert.Equal(TorquePerLengthUnit.PoundForceInchPerFoot, quantity17.Unit);
 
-            var quantity18 = TorquePerLength.From(1, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
+            var quantity18 = TorquePerLength<double>.From(1, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity18.TonneForceCentimetersPerMeter, TonneForceCentimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.TonneForceCentimeterPerMeter, quantity18.Unit);
 
-            var quantity19 = TorquePerLength.From(1, TorquePerLengthUnit.TonneForceMeterPerMeter);
+            var quantity19 = TorquePerLength<double>.From(1, TorquePerLengthUnit.TonneForceMeterPerMeter);
             AssertEx.EqualTolerance(1, quantity19.TonneForceMetersPerMeter, TonneForceMetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.TonneForceMeterPerMeter, quantity19.Unit);
 
-            var quantity20 = TorquePerLength.From(1, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
+            var quantity20 = TorquePerLength<double>.From(1, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
             AssertEx.EqualTolerance(1, quantity20.TonneForceMillimetersPerMeter, TonneForceMillimetersPerMeterTolerance);
             Assert.Equal(TorquePerLengthUnit.TonneForceMillimeterPerMeter, quantity20.Unit);
 
@@ -270,20 +270,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonMetersPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => TorquePerLength.FromNewtonMetersPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => TorquePerLength.FromNewtonMetersPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => TorquePerLength<double>.FromNewtonMetersPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => TorquePerLength<double>.FromNewtonMetersPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonMetersPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => TorquePerLength.FromNewtonMetersPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => TorquePerLength<double>.FromNewtonMetersPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            var newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             AssertEx.EqualTolerance(KilogramForceCentimetersPerMeterInOneNewtonMeterPerMeter, newtonmeterpermeter.As(TorquePerLengthUnit.KilogramForceCentimeterPerMeter), KilogramForceCentimetersPerMeterTolerance);
             AssertEx.EqualTolerance(KilogramForceMetersPerMeterInOneNewtonMeterPerMeter, newtonmeterpermeter.As(TorquePerLengthUnit.KilogramForceMeterPerMeter), KilogramForceMetersPerMeterTolerance);
             AssertEx.EqualTolerance(KilogramForceMillimetersPerMeterInOneNewtonMeterPerMeter, newtonmeterpermeter.As(TorquePerLengthUnit.KilogramForceMillimeterPerMeter), KilogramForceMillimetersPerMeterTolerance);
@@ -327,7 +327,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            var newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
 
             var kilogramforcecentimeterpermeterQuantity = newtonmeterpermeter.ToUnit(TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
             AssertEx.EqualTolerance(KilogramForceCentimetersPerMeterInOneNewtonMeterPerMeter, (double)kilogramforcecentimeterpermeterQuantity.Value, KilogramForceCentimetersPerMeterTolerance);
@@ -424,48 +424,48 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            TorquePerLength newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilogramForceCentimetersPerMeter(newtonmeterpermeter.KilogramForceCentimetersPerMeter).NewtonMetersPerMeter, KilogramForceCentimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilogramForceMetersPerMeter(newtonmeterpermeter.KilogramForceMetersPerMeter).NewtonMetersPerMeter, KilogramForceMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilogramForceMillimetersPerMeter(newtonmeterpermeter.KilogramForceMillimetersPerMeter).NewtonMetersPerMeter, KilogramForceMillimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilonewtonCentimetersPerMeter(newtonmeterpermeter.KilonewtonCentimetersPerMeter).NewtonMetersPerMeter, KilonewtonCentimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilonewtonMetersPerMeter(newtonmeterpermeter.KilonewtonMetersPerMeter).NewtonMetersPerMeter, KilonewtonMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilonewtonMillimetersPerMeter(newtonmeterpermeter.KilonewtonMillimetersPerMeter).NewtonMetersPerMeter, KilonewtonMillimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilopoundForceFeetPerFoot(newtonmeterpermeter.KilopoundForceFeetPerFoot).NewtonMetersPerMeter, KilopoundForceFeetPerFootTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromKilopoundForceInchesPerFoot(newtonmeterpermeter.KilopoundForceInchesPerFoot).NewtonMetersPerMeter, KilopoundForceInchesPerFootTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromMeganewtonCentimetersPerMeter(newtonmeterpermeter.MeganewtonCentimetersPerMeter).NewtonMetersPerMeter, MeganewtonCentimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromMeganewtonMetersPerMeter(newtonmeterpermeter.MeganewtonMetersPerMeter).NewtonMetersPerMeter, MeganewtonMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromMeganewtonMillimetersPerMeter(newtonmeterpermeter.MeganewtonMillimetersPerMeter).NewtonMetersPerMeter, MeganewtonMillimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromMegapoundForceFeetPerFoot(newtonmeterpermeter.MegapoundForceFeetPerFoot).NewtonMetersPerMeter, MegapoundForceFeetPerFootTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromMegapoundForceInchesPerFoot(newtonmeterpermeter.MegapoundForceInchesPerFoot).NewtonMetersPerMeter, MegapoundForceInchesPerFootTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromNewtonCentimetersPerMeter(newtonmeterpermeter.NewtonCentimetersPerMeter).NewtonMetersPerMeter, NewtonCentimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromNewtonMetersPerMeter(newtonmeterpermeter.NewtonMetersPerMeter).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromNewtonMillimetersPerMeter(newtonmeterpermeter.NewtonMillimetersPerMeter).NewtonMetersPerMeter, NewtonMillimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromPoundForceFeetPerFoot(newtonmeterpermeter.PoundForceFeetPerFoot).NewtonMetersPerMeter, PoundForceFeetPerFootTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromPoundForceInchesPerFoot(newtonmeterpermeter.PoundForceInchesPerFoot).NewtonMetersPerMeter, PoundForceInchesPerFootTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromTonneForceCentimetersPerMeter(newtonmeterpermeter.TonneForceCentimetersPerMeter).NewtonMetersPerMeter, TonneForceCentimetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromTonneForceMetersPerMeter(newtonmeterpermeter.TonneForceMetersPerMeter).NewtonMetersPerMeter, TonneForceMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TorquePerLength.FromTonneForceMillimetersPerMeter(newtonmeterpermeter.TonneForceMillimetersPerMeter).NewtonMetersPerMeter, TonneForceMillimetersPerMeterTolerance);
+            TorquePerLength<double> newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilogramForceCentimetersPerMeter(newtonmeterpermeter.KilogramForceCentimetersPerMeter).NewtonMetersPerMeter, KilogramForceCentimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilogramForceMetersPerMeter(newtonmeterpermeter.KilogramForceMetersPerMeter).NewtonMetersPerMeter, KilogramForceMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilogramForceMillimetersPerMeter(newtonmeterpermeter.KilogramForceMillimetersPerMeter).NewtonMetersPerMeter, KilogramForceMillimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilonewtonCentimetersPerMeter(newtonmeterpermeter.KilonewtonCentimetersPerMeter).NewtonMetersPerMeter, KilonewtonCentimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilonewtonMetersPerMeter(newtonmeterpermeter.KilonewtonMetersPerMeter).NewtonMetersPerMeter, KilonewtonMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilonewtonMillimetersPerMeter(newtonmeterpermeter.KilonewtonMillimetersPerMeter).NewtonMetersPerMeter, KilonewtonMillimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilopoundForceFeetPerFoot(newtonmeterpermeter.KilopoundForceFeetPerFoot).NewtonMetersPerMeter, KilopoundForceFeetPerFootTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromKilopoundForceInchesPerFoot(newtonmeterpermeter.KilopoundForceInchesPerFoot).NewtonMetersPerMeter, KilopoundForceInchesPerFootTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromMeganewtonCentimetersPerMeter(newtonmeterpermeter.MeganewtonCentimetersPerMeter).NewtonMetersPerMeter, MeganewtonCentimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromMeganewtonMetersPerMeter(newtonmeterpermeter.MeganewtonMetersPerMeter).NewtonMetersPerMeter, MeganewtonMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromMeganewtonMillimetersPerMeter(newtonmeterpermeter.MeganewtonMillimetersPerMeter).NewtonMetersPerMeter, MeganewtonMillimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromMegapoundForceFeetPerFoot(newtonmeterpermeter.MegapoundForceFeetPerFoot).NewtonMetersPerMeter, MegapoundForceFeetPerFootTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromMegapoundForceInchesPerFoot(newtonmeterpermeter.MegapoundForceInchesPerFoot).NewtonMetersPerMeter, MegapoundForceInchesPerFootTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromNewtonCentimetersPerMeter(newtonmeterpermeter.NewtonCentimetersPerMeter).NewtonMetersPerMeter, NewtonCentimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromNewtonMetersPerMeter(newtonmeterpermeter.NewtonMetersPerMeter).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromNewtonMillimetersPerMeter(newtonmeterpermeter.NewtonMillimetersPerMeter).NewtonMetersPerMeter, NewtonMillimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromPoundForceFeetPerFoot(newtonmeterpermeter.PoundForceFeetPerFoot).NewtonMetersPerMeter, PoundForceFeetPerFootTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromPoundForceInchesPerFoot(newtonmeterpermeter.PoundForceInchesPerFoot).NewtonMetersPerMeter, PoundForceInchesPerFootTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromTonneForceCentimetersPerMeter(newtonmeterpermeter.TonneForceCentimetersPerMeter).NewtonMetersPerMeter, TonneForceCentimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromTonneForceMetersPerMeter(newtonmeterpermeter.TonneForceMetersPerMeter).NewtonMetersPerMeter, TonneForceMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, TorquePerLength<double>.FromTonneForceMillimetersPerMeter(newtonmeterpermeter.TonneForceMillimetersPerMeter).NewtonMetersPerMeter, TonneForceMillimetersPerMeterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            TorquePerLength v = TorquePerLength.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> v = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (TorquePerLength.FromNewtonMetersPerMeter(3)-v).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (TorquePerLength<double>.FromNewtonMetersPerMeter(3)-v).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (TorquePerLength.FromNewtonMetersPerMeter(10)/5).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, TorquePerLength.FromNewtonMetersPerMeter(10)/TorquePerLength.FromNewtonMetersPerMeter(5), NewtonMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (TorquePerLength<double>.FromNewtonMetersPerMeter(10)/5).NewtonMetersPerMeter, NewtonMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, TorquePerLength<double>.FromNewtonMetersPerMeter(10)/TorquePerLength<double>.FromNewtonMetersPerMeter(5), NewtonMetersPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            TorquePerLength oneNewtonMeterPerMeter = TorquePerLength.FromNewtonMetersPerMeter(1);
-            TorquePerLength twoNewtonMetersPerMeter = TorquePerLength.FromNewtonMetersPerMeter(2);
+            TorquePerLength<double> oneNewtonMeterPerMeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> twoNewtonMetersPerMeter = TorquePerLength<double>.FromNewtonMetersPerMeter(2);
 
             Assert.True(oneNewtonMeterPerMeter < twoNewtonMetersPerMeter);
             Assert.True(oneNewtonMeterPerMeter <= twoNewtonMetersPerMeter);
@@ -481,31 +481,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            TorquePerLength newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             Assert.Equal(0, newtonmeterpermeter.CompareTo(newtonmeterpermeter));
-            Assert.True(newtonmeterpermeter.CompareTo(TorquePerLength.Zero) > 0);
-            Assert.True(TorquePerLength.Zero.CompareTo(newtonmeterpermeter) < 0);
+            Assert.True(newtonmeterpermeter.CompareTo(TorquePerLength<double>.Zero) > 0);
+            Assert.True(TorquePerLength<double>.Zero.CompareTo(newtonmeterpermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            TorquePerLength newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             Assert.Throws<ArgumentException>(() => newtonmeterpermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            TorquePerLength newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => newtonmeterpermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = TorquePerLength.FromNewtonMetersPerMeter(1);
-            var b = TorquePerLength.FromNewtonMetersPerMeter(2);
+            var a = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
+            var b = TorquePerLength<double>.FromNewtonMetersPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -524,8 +524,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = TorquePerLength.FromNewtonMetersPerMeter(1);
-            var b = TorquePerLength.FromNewtonMetersPerMeter(2);
+            var a = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
+            var b = TorquePerLength<double>.FromNewtonMetersPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -545,9 +545,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = TorquePerLength.FromNewtonMetersPerMeter(1);
-            Assert.True(v.Equals(TorquePerLength.FromNewtonMetersPerMeter(1), NewtonMetersPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(TorquePerLength.Zero, NewtonMetersPerMeterTolerance, ComparisonType.Relative));
+            var v = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
+            Assert.True(v.Equals(TorquePerLength<double>.FromNewtonMetersPerMeter(1), NewtonMetersPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(TorquePerLength<double>.Zero, NewtonMetersPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -560,21 +560,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            TorquePerLength newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             Assert.False(newtonmeterpermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            TorquePerLength newtonmeterpermeter = TorquePerLength.FromNewtonMetersPerMeter(1);
+            TorquePerLength<double> newtonmeterpermeter = TorquePerLength<double>.FromNewtonMetersPerMeter(1);
             Assert.False(newtonmeterpermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(TorquePerLengthUnit.Undefined, TorquePerLength.Units);
+            Assert.DoesNotContain(TorquePerLengthUnit.Undefined, TorquePerLength<double>.Units);
         }
 
         [Fact]
@@ -593,7 +593,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(TorquePerLength.BaseDimensions is null);
+            Assert.False(TorquePerLength<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
index 3c1d9ac1b2..a6ff614a7f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
@@ -88,7 +88,7 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Torque((double)0.0, TorqueUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Torque<double>((double)0.0, TorqueUnit.Undefined));
         }
 
         [Fact]
@@ -103,14 +103,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Torque(double.PositiveInfinity, TorqueUnit.NewtonMeter));
-            Assert.Throws<ArgumentException>(() => new Torque(double.NegativeInfinity, TorqueUnit.NewtonMeter));
+            Assert.Throws<ArgumentException>(() => new Torque<double>(double.PositiveInfinity, TorqueUnit.NewtonMeter));
+            Assert.Throws<ArgumentException>(() => new Torque<double>(double.NegativeInfinity, TorqueUnit.NewtonMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Torque(double.NaN, TorqueUnit.NewtonMeter));
+            Assert.Throws<ArgumentException>(() => new Torque<double>(double.NaN, TorqueUnit.NewtonMeter));
         }
 
         [Fact]
@@ -156,7 +156,7 @@ public void Torque_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void NewtonMeterToTorqueUnits()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
+            Torque<double> newtonmeter = Torque<double>.FromNewtonMeters(1);
             AssertEx.EqualTolerance(KilogramForceCentimetersInOneNewtonMeter, newtonmeter.KilogramForceCentimeters, KilogramForceCentimetersTolerance);
             AssertEx.EqualTolerance(KilogramForceMetersInOneNewtonMeter, newtonmeter.KilogramForceMeters, KilogramForceMetersTolerance);
             AssertEx.EqualTolerance(KilogramForceMillimetersInOneNewtonMeter, newtonmeter.KilogramForceMillimeters, KilogramForceMillimetersTolerance);
@@ -184,91 +184,91 @@ public void NewtonMeterToTorqueUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Torque.From(1, TorqueUnit.KilogramForceCentimeter);
+            var quantity00 = Torque<double>.From(1, TorqueUnit.KilogramForceCentimeter);
             AssertEx.EqualTolerance(1, quantity00.KilogramForceCentimeters, KilogramForceCentimetersTolerance);
             Assert.Equal(TorqueUnit.KilogramForceCentimeter, quantity00.Unit);
 
-            var quantity01 = Torque.From(1, TorqueUnit.KilogramForceMeter);
+            var quantity01 = Torque<double>.From(1, TorqueUnit.KilogramForceMeter);
             AssertEx.EqualTolerance(1, quantity01.KilogramForceMeters, KilogramForceMetersTolerance);
             Assert.Equal(TorqueUnit.KilogramForceMeter, quantity01.Unit);
 
-            var quantity02 = Torque.From(1, TorqueUnit.KilogramForceMillimeter);
+            var quantity02 = Torque<double>.From(1, TorqueUnit.KilogramForceMillimeter);
             AssertEx.EqualTolerance(1, quantity02.KilogramForceMillimeters, KilogramForceMillimetersTolerance);
             Assert.Equal(TorqueUnit.KilogramForceMillimeter, quantity02.Unit);
 
-            var quantity03 = Torque.From(1, TorqueUnit.KilonewtonCentimeter);
+            var quantity03 = Torque<double>.From(1, TorqueUnit.KilonewtonCentimeter);
             AssertEx.EqualTolerance(1, quantity03.KilonewtonCentimeters, KilonewtonCentimetersTolerance);
             Assert.Equal(TorqueUnit.KilonewtonCentimeter, quantity03.Unit);
 
-            var quantity04 = Torque.From(1, TorqueUnit.KilonewtonMeter);
+            var quantity04 = Torque<double>.From(1, TorqueUnit.KilonewtonMeter);
             AssertEx.EqualTolerance(1, quantity04.KilonewtonMeters, KilonewtonMetersTolerance);
             Assert.Equal(TorqueUnit.KilonewtonMeter, quantity04.Unit);
 
-            var quantity05 = Torque.From(1, TorqueUnit.KilonewtonMillimeter);
+            var quantity05 = Torque<double>.From(1, TorqueUnit.KilonewtonMillimeter);
             AssertEx.EqualTolerance(1, quantity05.KilonewtonMillimeters, KilonewtonMillimetersTolerance);
             Assert.Equal(TorqueUnit.KilonewtonMillimeter, quantity05.Unit);
 
-            var quantity06 = Torque.From(1, TorqueUnit.KilopoundForceFoot);
+            var quantity06 = Torque<double>.From(1, TorqueUnit.KilopoundForceFoot);
             AssertEx.EqualTolerance(1, quantity06.KilopoundForceFeet, KilopoundForceFeetTolerance);
             Assert.Equal(TorqueUnit.KilopoundForceFoot, quantity06.Unit);
 
-            var quantity07 = Torque.From(1, TorqueUnit.KilopoundForceInch);
+            var quantity07 = Torque<double>.From(1, TorqueUnit.KilopoundForceInch);
             AssertEx.EqualTolerance(1, quantity07.KilopoundForceInches, KilopoundForceInchesTolerance);
             Assert.Equal(TorqueUnit.KilopoundForceInch, quantity07.Unit);
 
-            var quantity08 = Torque.From(1, TorqueUnit.MeganewtonCentimeter);
+            var quantity08 = Torque<double>.From(1, TorqueUnit.MeganewtonCentimeter);
             AssertEx.EqualTolerance(1, quantity08.MeganewtonCentimeters, MeganewtonCentimetersTolerance);
             Assert.Equal(TorqueUnit.MeganewtonCentimeter, quantity08.Unit);
 
-            var quantity09 = Torque.From(1, TorqueUnit.MeganewtonMeter);
+            var quantity09 = Torque<double>.From(1, TorqueUnit.MeganewtonMeter);
             AssertEx.EqualTolerance(1, quantity09.MeganewtonMeters, MeganewtonMetersTolerance);
             Assert.Equal(TorqueUnit.MeganewtonMeter, quantity09.Unit);
 
-            var quantity10 = Torque.From(1, TorqueUnit.MeganewtonMillimeter);
+            var quantity10 = Torque<double>.From(1, TorqueUnit.MeganewtonMillimeter);
             AssertEx.EqualTolerance(1, quantity10.MeganewtonMillimeters, MeganewtonMillimetersTolerance);
             Assert.Equal(TorqueUnit.MeganewtonMillimeter, quantity10.Unit);
 
-            var quantity11 = Torque.From(1, TorqueUnit.MegapoundForceFoot);
+            var quantity11 = Torque<double>.From(1, TorqueUnit.MegapoundForceFoot);
             AssertEx.EqualTolerance(1, quantity11.MegapoundForceFeet, MegapoundForceFeetTolerance);
             Assert.Equal(TorqueUnit.MegapoundForceFoot, quantity11.Unit);
 
-            var quantity12 = Torque.From(1, TorqueUnit.MegapoundForceInch);
+            var quantity12 = Torque<double>.From(1, TorqueUnit.MegapoundForceInch);
             AssertEx.EqualTolerance(1, quantity12.MegapoundForceInches, MegapoundForceInchesTolerance);
             Assert.Equal(TorqueUnit.MegapoundForceInch, quantity12.Unit);
 
-            var quantity13 = Torque.From(1, TorqueUnit.NewtonCentimeter);
+            var quantity13 = Torque<double>.From(1, TorqueUnit.NewtonCentimeter);
             AssertEx.EqualTolerance(1, quantity13.NewtonCentimeters, NewtonCentimetersTolerance);
             Assert.Equal(TorqueUnit.NewtonCentimeter, quantity13.Unit);
 
-            var quantity14 = Torque.From(1, TorqueUnit.NewtonMeter);
+            var quantity14 = Torque<double>.From(1, TorqueUnit.NewtonMeter);
             AssertEx.EqualTolerance(1, quantity14.NewtonMeters, NewtonMetersTolerance);
             Assert.Equal(TorqueUnit.NewtonMeter, quantity14.Unit);
 
-            var quantity15 = Torque.From(1, TorqueUnit.NewtonMillimeter);
+            var quantity15 = Torque<double>.From(1, TorqueUnit.NewtonMillimeter);
             AssertEx.EqualTolerance(1, quantity15.NewtonMillimeters, NewtonMillimetersTolerance);
             Assert.Equal(TorqueUnit.NewtonMillimeter, quantity15.Unit);
 
-            var quantity16 = Torque.From(1, TorqueUnit.PoundalFoot);
+            var quantity16 = Torque<double>.From(1, TorqueUnit.PoundalFoot);
             AssertEx.EqualTolerance(1, quantity16.PoundalFeet, PoundalFeetTolerance);
             Assert.Equal(TorqueUnit.PoundalFoot, quantity16.Unit);
 
-            var quantity17 = Torque.From(1, TorqueUnit.PoundForceFoot);
+            var quantity17 = Torque<double>.From(1, TorqueUnit.PoundForceFoot);
             AssertEx.EqualTolerance(1, quantity17.PoundForceFeet, PoundForceFeetTolerance);
             Assert.Equal(TorqueUnit.PoundForceFoot, quantity17.Unit);
 
-            var quantity18 = Torque.From(1, TorqueUnit.PoundForceInch);
+            var quantity18 = Torque<double>.From(1, TorqueUnit.PoundForceInch);
             AssertEx.EqualTolerance(1, quantity18.PoundForceInches, PoundForceInchesTolerance);
             Assert.Equal(TorqueUnit.PoundForceInch, quantity18.Unit);
 
-            var quantity19 = Torque.From(1, TorqueUnit.TonneForceCentimeter);
+            var quantity19 = Torque<double>.From(1, TorqueUnit.TonneForceCentimeter);
             AssertEx.EqualTolerance(1, quantity19.TonneForceCentimeters, TonneForceCentimetersTolerance);
             Assert.Equal(TorqueUnit.TonneForceCentimeter, quantity19.Unit);
 
-            var quantity20 = Torque.From(1, TorqueUnit.TonneForceMeter);
+            var quantity20 = Torque<double>.From(1, TorqueUnit.TonneForceMeter);
             AssertEx.EqualTolerance(1, quantity20.TonneForceMeters, TonneForceMetersTolerance);
             Assert.Equal(TorqueUnit.TonneForceMeter, quantity20.Unit);
 
-            var quantity21 = Torque.From(1, TorqueUnit.TonneForceMillimeter);
+            var quantity21 = Torque<double>.From(1, TorqueUnit.TonneForceMillimeter);
             AssertEx.EqualTolerance(1, quantity21.TonneForceMillimeters, TonneForceMillimetersTolerance);
             Assert.Equal(TorqueUnit.TonneForceMillimeter, quantity21.Unit);
 
@@ -277,20 +277,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNewtonMeters_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Torque.FromNewtonMeters(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Torque.FromNewtonMeters(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Torque<double>.FromNewtonMeters(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Torque<double>.FromNewtonMeters(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNewtonMeters_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Torque.FromNewtonMeters(double.NaN));
+            Assert.Throws<ArgumentException>(() => Torque<double>.FromNewtonMeters(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var newtonmeter = Torque.FromNewtonMeters(1);
+            var newtonmeter = Torque<double>.FromNewtonMeters(1);
             AssertEx.EqualTolerance(KilogramForceCentimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilogramForceCentimeter), KilogramForceCentimetersTolerance);
             AssertEx.EqualTolerance(KilogramForceMetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilogramForceMeter), KilogramForceMetersTolerance);
             AssertEx.EqualTolerance(KilogramForceMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilogramForceMillimeter), KilogramForceMillimetersTolerance);
@@ -335,7 +335,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var newtonmeter = Torque.FromNewtonMeters(1);
+            var newtonmeter = Torque<double>.FromNewtonMeters(1);
 
             var kilogramforcecentimeterQuantity = newtonmeter.ToUnit(TorqueUnit.KilogramForceCentimeter);
             AssertEx.EqualTolerance(KilogramForceCentimetersInOneNewtonMeter, (double)kilogramforcecentimeterQuantity.Value, KilogramForceCentimetersTolerance);
@@ -436,49 +436,49 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
-            AssertEx.EqualTolerance(1, Torque.FromKilogramForceCentimeters(newtonmeter.KilogramForceCentimeters).NewtonMeters, KilogramForceCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilogramForceMeters(newtonmeter.KilogramForceMeters).NewtonMeters, KilogramForceMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilogramForceMillimeters(newtonmeter.KilogramForceMillimeters).NewtonMeters, KilogramForceMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilonewtonCentimeters(newtonmeter.KilonewtonCentimeters).NewtonMeters, KilonewtonCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilonewtonMeters(newtonmeter.KilonewtonMeters).NewtonMeters, KilonewtonMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilonewtonMillimeters(newtonmeter.KilonewtonMillimeters).NewtonMeters, KilonewtonMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilopoundForceFeet(newtonmeter.KilopoundForceFeet).NewtonMeters, KilopoundForceFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilopoundForceInches(newtonmeter.KilopoundForceInches).NewtonMeters, KilopoundForceInchesTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMeganewtonCentimeters(newtonmeter.MeganewtonCentimeters).NewtonMeters, MeganewtonCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMeganewtonMeters(newtonmeter.MeganewtonMeters).NewtonMeters, MeganewtonMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMeganewtonMillimeters(newtonmeter.MeganewtonMillimeters).NewtonMeters, MeganewtonMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMegapoundForceFeet(newtonmeter.MegapoundForceFeet).NewtonMeters, MegapoundForceFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMegapoundForceInches(newtonmeter.MegapoundForceInches).NewtonMeters, MegapoundForceInchesTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromNewtonCentimeters(newtonmeter.NewtonCentimeters).NewtonMeters, NewtonCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromNewtonMeters(newtonmeter.NewtonMeters).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromNewtonMillimeters(newtonmeter.NewtonMillimeters).NewtonMeters, NewtonMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromPoundalFeet(newtonmeter.PoundalFeet).NewtonMeters, PoundalFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromPoundForceFeet(newtonmeter.PoundForceFeet).NewtonMeters, PoundForceFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromPoundForceInches(newtonmeter.PoundForceInches).NewtonMeters, PoundForceInchesTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromTonneForceCentimeters(newtonmeter.TonneForceCentimeters).NewtonMeters, TonneForceCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromTonneForceMeters(newtonmeter.TonneForceMeters).NewtonMeters, TonneForceMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromTonneForceMillimeters(newtonmeter.TonneForceMillimeters).NewtonMeters, TonneForceMillimetersTolerance);
+            Torque<double> newtonmeter = Torque<double>.FromNewtonMeters(1);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilogramForceCentimeters(newtonmeter.KilogramForceCentimeters).NewtonMeters, KilogramForceCentimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilogramForceMeters(newtonmeter.KilogramForceMeters).NewtonMeters, KilogramForceMetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilogramForceMillimeters(newtonmeter.KilogramForceMillimeters).NewtonMeters, KilogramForceMillimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilonewtonCentimeters(newtonmeter.KilonewtonCentimeters).NewtonMeters, KilonewtonCentimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilonewtonMeters(newtonmeter.KilonewtonMeters).NewtonMeters, KilonewtonMetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilonewtonMillimeters(newtonmeter.KilonewtonMillimeters).NewtonMeters, KilonewtonMillimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilopoundForceFeet(newtonmeter.KilopoundForceFeet).NewtonMeters, KilopoundForceFeetTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromKilopoundForceInches(newtonmeter.KilopoundForceInches).NewtonMeters, KilopoundForceInchesTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromMeganewtonCentimeters(newtonmeter.MeganewtonCentimeters).NewtonMeters, MeganewtonCentimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromMeganewtonMeters(newtonmeter.MeganewtonMeters).NewtonMeters, MeganewtonMetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromMeganewtonMillimeters(newtonmeter.MeganewtonMillimeters).NewtonMeters, MeganewtonMillimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromMegapoundForceFeet(newtonmeter.MegapoundForceFeet).NewtonMeters, MegapoundForceFeetTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromMegapoundForceInches(newtonmeter.MegapoundForceInches).NewtonMeters, MegapoundForceInchesTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromNewtonCentimeters(newtonmeter.NewtonCentimeters).NewtonMeters, NewtonCentimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromNewtonMeters(newtonmeter.NewtonMeters).NewtonMeters, NewtonMetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromNewtonMillimeters(newtonmeter.NewtonMillimeters).NewtonMeters, NewtonMillimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromPoundalFeet(newtonmeter.PoundalFeet).NewtonMeters, PoundalFeetTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromPoundForceFeet(newtonmeter.PoundForceFeet).NewtonMeters, PoundForceFeetTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromPoundForceInches(newtonmeter.PoundForceInches).NewtonMeters, PoundForceInchesTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromTonneForceCentimeters(newtonmeter.TonneForceCentimeters).NewtonMeters, TonneForceCentimetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromTonneForceMeters(newtonmeter.TonneForceMeters).NewtonMeters, TonneForceMetersTolerance);
+            AssertEx.EqualTolerance(1, Torque<double>.FromTonneForceMillimeters(newtonmeter.TonneForceMillimeters).NewtonMeters, TonneForceMillimetersTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Torque v = Torque.FromNewtonMeters(1);
+            Torque<double> v = Torque<double>.FromNewtonMeters(1);
             AssertEx.EqualTolerance(-1, -v.NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(2, (Torque.FromNewtonMeters(3)-v).NewtonMeters, NewtonMetersTolerance);
+            AssertEx.EqualTolerance(2, (Torque<double>.FromNewtonMeters(3)-v).NewtonMeters, NewtonMetersTolerance);
             AssertEx.EqualTolerance(2, (v + v).NewtonMeters, NewtonMetersTolerance);
             AssertEx.EqualTolerance(10, (v*10).NewtonMeters, NewtonMetersTolerance);
             AssertEx.EqualTolerance(10, (10*v).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(2, (Torque.FromNewtonMeters(10)/5).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(2, Torque.FromNewtonMeters(10)/Torque.FromNewtonMeters(5), NewtonMetersTolerance);
+            AssertEx.EqualTolerance(2, (Torque<double>.FromNewtonMeters(10)/5).NewtonMeters, NewtonMetersTolerance);
+            AssertEx.EqualTolerance(2, Torque<double>.FromNewtonMeters(10)/Torque<double>.FromNewtonMeters(5), NewtonMetersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Torque oneNewtonMeter = Torque.FromNewtonMeters(1);
-            Torque twoNewtonMeters = Torque.FromNewtonMeters(2);
+            Torque<double> oneNewtonMeter = Torque<double>.FromNewtonMeters(1);
+            Torque<double> twoNewtonMeters = Torque<double>.FromNewtonMeters(2);
 
             Assert.True(oneNewtonMeter < twoNewtonMeters);
             Assert.True(oneNewtonMeter <= twoNewtonMeters);
@@ -494,31 +494,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
+            Torque<double> newtonmeter = Torque<double>.FromNewtonMeters(1);
             Assert.Equal(0, newtonmeter.CompareTo(newtonmeter));
-            Assert.True(newtonmeter.CompareTo(Torque.Zero) > 0);
-            Assert.True(Torque.Zero.CompareTo(newtonmeter) < 0);
+            Assert.True(newtonmeter.CompareTo(Torque<double>.Zero) > 0);
+            Assert.True(Torque<double>.Zero.CompareTo(newtonmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
+            Torque<double> newtonmeter = Torque<double>.FromNewtonMeters(1);
             Assert.Throws<ArgumentException>(() => newtonmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
+            Torque<double> newtonmeter = Torque<double>.FromNewtonMeters(1);
             Assert.Throws<ArgumentNullException>(() => newtonmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Torque.FromNewtonMeters(1);
-            var b = Torque.FromNewtonMeters(2);
+            var a = Torque<double>.FromNewtonMeters(1);
+            var b = Torque<double>.FromNewtonMeters(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -537,8 +537,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Torque.FromNewtonMeters(1);
-            var b = Torque.FromNewtonMeters(2);
+            var a = Torque<double>.FromNewtonMeters(1);
+            var b = Torque<double>.FromNewtonMeters(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -558,9 +558,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Torque.FromNewtonMeters(1);
-            Assert.True(v.Equals(Torque.FromNewtonMeters(1), NewtonMetersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Torque.Zero, NewtonMetersTolerance, ComparisonType.Relative));
+            var v = Torque<double>.FromNewtonMeters(1);
+            Assert.True(v.Equals(Torque<double>.FromNewtonMeters(1), NewtonMetersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Torque<double>.Zero, NewtonMetersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -573,21 +573,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
+            Torque<double> newtonmeter = Torque<double>.FromNewtonMeters(1);
             Assert.False(newtonmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
+            Torque<double> newtonmeter = Torque<double>.FromNewtonMeters(1);
             Assert.False(newtonmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(TorqueUnit.Undefined, Torque.Units);
+            Assert.DoesNotContain(TorqueUnit.Undefined, Torque<double>.Units);
         }
 
         [Fact]
@@ -606,7 +606,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Torque.BaseDimensions is null);
+            Assert.False(Torque<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs
index 7298fce5e8..6b749244f8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class TurbidityTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Turbidity((double)0.0, TurbidityUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Turbidity<double>((double)0.0, TurbidityUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Turbidity(double.PositiveInfinity, TurbidityUnit.NTU));
-            Assert.Throws<ArgumentException>(() => new Turbidity(double.NegativeInfinity, TurbidityUnit.NTU));
+            Assert.Throws<ArgumentException>(() => new Turbidity<double>(double.PositiveInfinity, TurbidityUnit.NTU));
+            Assert.Throws<ArgumentException>(() => new Turbidity<double>(double.NegativeInfinity, TurbidityUnit.NTU));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Turbidity(double.NaN, TurbidityUnit.NTU));
+            Assert.Throws<ArgumentException>(() => new Turbidity<double>(double.NaN, TurbidityUnit.NTU));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void Turbidity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void NTUToTurbidityUnits()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
+            Turbidity<double> ntu = Turbidity<double>.FromNTU(1);
             AssertEx.EqualTolerance(NTUInOneNTU, ntu.NTU, NTUTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Turbidity.From(1, TurbidityUnit.NTU);
+            var quantity00 = Turbidity<double>.From(1, TurbidityUnit.NTU);
             AssertEx.EqualTolerance(1, quantity00.NTU, NTUTolerance);
             Assert.Equal(TurbidityUnit.NTU, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromNTU_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Turbidity.FromNTU(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Turbidity.FromNTU(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Turbidity<double>.FromNTU(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Turbidity<double>.FromNTU(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromNTU_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Turbidity.FromNTU(double.NaN));
+            Assert.Throws<ArgumentException>(() => Turbidity<double>.FromNTU(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var ntu = Turbidity.FromNTU(1);
+            var ntu = Turbidity<double>.FromNTU(1);
             AssertEx.EqualTolerance(NTUInOneNTU, ntu.As(TurbidityUnit.NTU), NTUTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var ntu = Turbidity.FromNTU(1);
+            var ntu = Turbidity<double>.FromNTU(1);
 
             var ntuQuantity = ntu.ToUnit(TurbidityUnit.NTU);
             AssertEx.EqualTolerance(NTUInOneNTU, (double)ntuQuantity.Value, NTUTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
-            AssertEx.EqualTolerance(1, Turbidity.FromNTU(ntu.NTU).NTU, NTUTolerance);
+            Turbidity<double> ntu = Turbidity<double>.FromNTU(1);
+            AssertEx.EqualTolerance(1, Turbidity<double>.FromNTU(ntu.NTU).NTU, NTUTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Turbidity v = Turbidity.FromNTU(1);
+            Turbidity<double> v = Turbidity<double>.FromNTU(1);
             AssertEx.EqualTolerance(-1, -v.NTU, NTUTolerance);
-            AssertEx.EqualTolerance(2, (Turbidity.FromNTU(3)-v).NTU, NTUTolerance);
+            AssertEx.EqualTolerance(2, (Turbidity<double>.FromNTU(3)-v).NTU, NTUTolerance);
             AssertEx.EqualTolerance(2, (v + v).NTU, NTUTolerance);
             AssertEx.EqualTolerance(10, (v*10).NTU, NTUTolerance);
             AssertEx.EqualTolerance(10, (10*v).NTU, NTUTolerance);
-            AssertEx.EqualTolerance(2, (Turbidity.FromNTU(10)/5).NTU, NTUTolerance);
-            AssertEx.EqualTolerance(2, Turbidity.FromNTU(10)/Turbidity.FromNTU(5), NTUTolerance);
+            AssertEx.EqualTolerance(2, (Turbidity<double>.FromNTU(10)/5).NTU, NTUTolerance);
+            AssertEx.EqualTolerance(2, Turbidity<double>.FromNTU(10)/Turbidity<double>.FromNTU(5), NTUTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Turbidity oneNTU = Turbidity.FromNTU(1);
-            Turbidity twoNTU = Turbidity.FromNTU(2);
+            Turbidity<double> oneNTU = Turbidity<double>.FromNTU(1);
+            Turbidity<double> twoNTU = Turbidity<double>.FromNTU(2);
 
             Assert.True(oneNTU < twoNTU);
             Assert.True(oneNTU <= twoNTU);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
+            Turbidity<double> ntu = Turbidity<double>.FromNTU(1);
             Assert.Equal(0, ntu.CompareTo(ntu));
-            Assert.True(ntu.CompareTo(Turbidity.Zero) > 0);
-            Assert.True(Turbidity.Zero.CompareTo(ntu) < 0);
+            Assert.True(ntu.CompareTo(Turbidity<double>.Zero) > 0);
+            Assert.True(Turbidity<double>.Zero.CompareTo(ntu) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
+            Turbidity<double> ntu = Turbidity<double>.FromNTU(1);
             Assert.Throws<ArgumentException>(() => ntu.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
+            Turbidity<double> ntu = Turbidity<double>.FromNTU(1);
             Assert.Throws<ArgumentNullException>(() => ntu.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Turbidity.FromNTU(1);
-            var b = Turbidity.FromNTU(2);
+            var a = Turbidity<double>.FromNTU(1);
+            var b = Turbidity<double>.FromNTU(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Turbidity.FromNTU(1);
-            var b = Turbidity.FromNTU(2);
+            var a = Turbidity<double>.FromNTU(1);
+            var b = Turbidity<double>.FromNTU(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Turbidity.FromNTU(1);
-            Assert.True(v.Equals(Turbidity.FromNTU(1), NTUTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Turbidity.Zero, NTUTolerance, ComparisonType.Relative));
+            var v = Turbidity<double>.FromNTU(1);
+            Assert.True(v.Equals(Turbidity<double>.FromNTU(1), NTUTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Turbidity<double>.Zero, NTUTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
+            Turbidity<double> ntu = Turbidity<double>.FromNTU(1);
             Assert.False(ntu.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
+            Turbidity<double> ntu = Turbidity<double>.FromNTU(1);
             Assert.False(ntu.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(TurbidityUnit.Undefined, Turbidity.Units);
+            Assert.DoesNotContain(TurbidityUnit.Undefined, Turbidity<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Turbidity.BaseDimensions is null);
+            Assert.False(Turbidity<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs
index 27d141fa70..5b97cd9c3b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs
@@ -46,7 +46,7 @@ public abstract partial class VitaminATestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VitaminA((double)0.0, VitaminAUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>((double)0.0, VitaminAUnit.Undefined));
         }
 
         [Fact]
@@ -61,14 +61,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VitaminA(double.PositiveInfinity, VitaminAUnit.InternationalUnit));
-            Assert.Throws<ArgumentException>(() => new VitaminA(double.NegativeInfinity, VitaminAUnit.InternationalUnit));
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>(double.PositiveInfinity, VitaminAUnit.InternationalUnit));
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>(double.NegativeInfinity, VitaminAUnit.InternationalUnit));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VitaminA(double.NaN, VitaminAUnit.InternationalUnit));
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>(double.NaN, VitaminAUnit.InternationalUnit));
         }
 
         [Fact]
@@ -114,14 +114,14 @@ public void VitaminA_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void InternationalUnitToVitaminAUnits()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
             AssertEx.EqualTolerance(InternationalUnitsInOneInternationalUnit, internationalunit.InternationalUnits, InternationalUnitsTolerance);
         }
 
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = VitaminA.From(1, VitaminAUnit.InternationalUnit);
+            var quantity00 = VitaminA<double>.From(1, VitaminAUnit.InternationalUnit);
             AssertEx.EqualTolerance(1, quantity00.InternationalUnits, InternationalUnitsTolerance);
             Assert.Equal(VitaminAUnit.InternationalUnit, quantity00.Unit);
 
@@ -130,20 +130,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromInternationalUnits_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VitaminA.FromInternationalUnits(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => VitaminA.FromInternationalUnits(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => VitaminA<double>.FromInternationalUnits(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => VitaminA<double>.FromInternationalUnits(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromInternationalUnits_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VitaminA.FromInternationalUnits(double.NaN));
+            Assert.Throws<ArgumentException>(() => VitaminA<double>.FromInternationalUnits(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var internationalunit = VitaminA.FromInternationalUnits(1);
+            var internationalunit = VitaminA<double>.FromInternationalUnits(1);
             AssertEx.EqualTolerance(InternationalUnitsInOneInternationalUnit, internationalunit.As(VitaminAUnit.InternationalUnit), InternationalUnitsTolerance);
         }
 
@@ -167,7 +167,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var internationalunit = VitaminA.FromInternationalUnits(1);
+            var internationalunit = VitaminA<double>.FromInternationalUnits(1);
 
             var internationalunitQuantity = internationalunit.ToUnit(VitaminAUnit.InternationalUnit);
             AssertEx.EqualTolerance(InternationalUnitsInOneInternationalUnit, (double)internationalunitQuantity.Value, InternationalUnitsTolerance);
@@ -184,28 +184,28 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
-            AssertEx.EqualTolerance(1, VitaminA.FromInternationalUnits(internationalunit.InternationalUnits).InternationalUnits, InternationalUnitsTolerance);
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            AssertEx.EqualTolerance(1, VitaminA<double>.FromInternationalUnits(internationalunit.InternationalUnits).InternationalUnits, InternationalUnitsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            VitaminA v = VitaminA.FromInternationalUnits(1);
+            VitaminA<double> v = VitaminA<double>.FromInternationalUnits(1);
             AssertEx.EqualTolerance(-1, -v.InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(2, (VitaminA.FromInternationalUnits(3)-v).InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(2, (VitaminA<double>.FromInternationalUnits(3)-v).InternationalUnits, InternationalUnitsTolerance);
             AssertEx.EqualTolerance(2, (v + v).InternationalUnits, InternationalUnitsTolerance);
             AssertEx.EqualTolerance(10, (v*10).InternationalUnits, InternationalUnitsTolerance);
             AssertEx.EqualTolerance(10, (10*v).InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(2, (VitaminA.FromInternationalUnits(10)/5).InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(2, VitaminA.FromInternationalUnits(10)/VitaminA.FromInternationalUnits(5), InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(2, (VitaminA<double>.FromInternationalUnits(10)/5).InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(2, VitaminA<double>.FromInternationalUnits(10)/VitaminA<double>.FromInternationalUnits(5), InternationalUnitsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            VitaminA oneInternationalUnit = VitaminA.FromInternationalUnits(1);
-            VitaminA twoInternationalUnits = VitaminA.FromInternationalUnits(2);
+            VitaminA<double> oneInternationalUnit = VitaminA<double>.FromInternationalUnits(1);
+            VitaminA<double> twoInternationalUnits = VitaminA<double>.FromInternationalUnits(2);
 
             Assert.True(oneInternationalUnit < twoInternationalUnits);
             Assert.True(oneInternationalUnit <= twoInternationalUnits);
@@ -221,31 +221,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
             Assert.Equal(0, internationalunit.CompareTo(internationalunit));
-            Assert.True(internationalunit.CompareTo(VitaminA.Zero) > 0);
-            Assert.True(VitaminA.Zero.CompareTo(internationalunit) < 0);
+            Assert.True(internationalunit.CompareTo(VitaminA<double>.Zero) > 0);
+            Assert.True(VitaminA<double>.Zero.CompareTo(internationalunit) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
             Assert.Throws<ArgumentException>(() => internationalunit.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
             Assert.Throws<ArgumentNullException>(() => internationalunit.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = VitaminA.FromInternationalUnits(1);
-            var b = VitaminA.FromInternationalUnits(2);
+            var a = VitaminA<double>.FromInternationalUnits(1);
+            var b = VitaminA<double>.FromInternationalUnits(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -264,8 +264,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = VitaminA.FromInternationalUnits(1);
-            var b = VitaminA.FromInternationalUnits(2);
+            var a = VitaminA<double>.FromInternationalUnits(1);
+            var b = VitaminA<double>.FromInternationalUnits(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -285,9 +285,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = VitaminA.FromInternationalUnits(1);
-            Assert.True(v.Equals(VitaminA.FromInternationalUnits(1), InternationalUnitsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(VitaminA.Zero, InternationalUnitsTolerance, ComparisonType.Relative));
+            var v = VitaminA<double>.FromInternationalUnits(1);
+            Assert.True(v.Equals(VitaminA<double>.FromInternationalUnits(1), InternationalUnitsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(VitaminA<double>.Zero, InternationalUnitsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -300,21 +300,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
             Assert.False(internationalunit.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
             Assert.False(internationalunit.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(VitaminAUnit.Undefined, VitaminA.Units);
+            Assert.DoesNotContain(VitaminAUnit.Undefined, VitaminA<double>.Units);
         }
 
         [Fact]
@@ -333,7 +333,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(VitaminA.BaseDimensions is null);
+            Assert.False(VitaminA<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs
index 7f3bd7bac2..0c9a6ac852 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs
@@ -84,7 +84,7 @@ public abstract partial class VolumeConcentrationTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumeConcentration((double)0.0, VolumeConcentrationUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new VolumeConcentration<double>((double)0.0, VolumeConcentrationUnit.Undefined));
         }
 
         [Fact]
@@ -99,14 +99,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumeConcentration(double.PositiveInfinity, VolumeConcentrationUnit.DecimalFraction));
-            Assert.Throws<ArgumentException>(() => new VolumeConcentration(double.NegativeInfinity, VolumeConcentrationUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new VolumeConcentration<double>(double.PositiveInfinity, VolumeConcentrationUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new VolumeConcentration<double>(double.NegativeInfinity, VolumeConcentrationUnit.DecimalFraction));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumeConcentration(double.NaN, VolumeConcentrationUnit.DecimalFraction));
+            Assert.Throws<ArgumentException>(() => new VolumeConcentration<double>(double.NaN, VolumeConcentrationUnit.DecimalFraction));
         }
 
         [Fact]
@@ -152,7 +152,7 @@ public void VolumeConcentration_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
         [Fact]
         public void DecimalFractionToVolumeConcentrationUnits()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            VolumeConcentration<double> decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, decimalfraction.CentilitersPerLiter, CentilitersPerLiterTolerance);
             AssertEx.EqualTolerance(CentilitersPerMililiterInOneDecimalFraction, decimalfraction.CentilitersPerMililiter, CentilitersPerMililiterTolerance);
             AssertEx.EqualTolerance(DecilitersPerLiterInOneDecimalFraction, decimalfraction.DecilitersPerLiter, DecilitersPerLiterTolerance);
@@ -178,83 +178,83 @@ public void DecimalFractionToVolumeConcentrationUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentilitersPerLiter);
+            var quantity00 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.CentilitersPerLiter);
             AssertEx.EqualTolerance(1, quantity00.CentilitersPerLiter, CentilitersPerLiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.CentilitersPerLiter, quantity00.Unit);
 
-            var quantity01 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentilitersPerMililiter);
+            var quantity01 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.CentilitersPerMililiter);
             AssertEx.EqualTolerance(1, quantity01.CentilitersPerMililiter, CentilitersPerMililiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.CentilitersPerMililiter, quantity01.Unit);
 
-            var quantity02 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecilitersPerLiter);
+            var quantity02 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.DecilitersPerLiter);
             AssertEx.EqualTolerance(1, quantity02.DecilitersPerLiter, DecilitersPerLiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.DecilitersPerLiter, quantity02.Unit);
 
-            var quantity03 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecilitersPerMililiter);
+            var quantity03 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.DecilitersPerMililiter);
             AssertEx.EqualTolerance(1, quantity03.DecilitersPerMililiter, DecilitersPerMililiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.DecilitersPerMililiter, quantity03.Unit);
 
-            var quantity04 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecimalFraction);
+            var quantity04 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.DecimalFraction);
             AssertEx.EqualTolerance(1, quantity04.DecimalFractions, DecimalFractionsTolerance);
             Assert.Equal(VolumeConcentrationUnit.DecimalFraction, quantity04.Unit);
 
-            var quantity05 = VolumeConcentration.From(1, VolumeConcentrationUnit.LitersPerLiter);
+            var quantity05 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.LitersPerLiter);
             AssertEx.EqualTolerance(1, quantity05.LitersPerLiter, LitersPerLiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.LitersPerLiter, quantity05.Unit);
 
-            var quantity06 = VolumeConcentration.From(1, VolumeConcentrationUnit.LitersPerMililiter);
+            var quantity06 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.LitersPerMililiter);
             AssertEx.EqualTolerance(1, quantity06.LitersPerMililiter, LitersPerMililiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.LitersPerMililiter, quantity06.Unit);
 
-            var quantity07 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicrolitersPerLiter);
+            var quantity07 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.MicrolitersPerLiter);
             AssertEx.EqualTolerance(1, quantity07.MicrolitersPerLiter, MicrolitersPerLiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.MicrolitersPerLiter, quantity07.Unit);
 
-            var quantity08 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicrolitersPerMililiter);
+            var quantity08 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.MicrolitersPerMililiter);
             AssertEx.EqualTolerance(1, quantity08.MicrolitersPerMililiter, MicrolitersPerMililiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMililiter, quantity08.Unit);
 
-            var quantity09 = VolumeConcentration.From(1, VolumeConcentrationUnit.MillilitersPerLiter);
+            var quantity09 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.MillilitersPerLiter);
             AssertEx.EqualTolerance(1, quantity09.MillilitersPerLiter, MillilitersPerLiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.MillilitersPerLiter, quantity09.Unit);
 
-            var quantity10 = VolumeConcentration.From(1, VolumeConcentrationUnit.MillilitersPerMililiter);
+            var quantity10 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.MillilitersPerMililiter);
             AssertEx.EqualTolerance(1, quantity10.MillilitersPerMililiter, MillilitersPerMililiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.MillilitersPerMililiter, quantity10.Unit);
 
-            var quantity11 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanolitersPerLiter);
+            var quantity11 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.NanolitersPerLiter);
             AssertEx.EqualTolerance(1, quantity11.NanolitersPerLiter, NanolitersPerLiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.NanolitersPerLiter, quantity11.Unit);
 
-            var quantity12 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanolitersPerMililiter);
+            var quantity12 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.NanolitersPerMililiter);
             AssertEx.EqualTolerance(1, quantity12.NanolitersPerMililiter, NanolitersPerMililiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.NanolitersPerMililiter, quantity12.Unit);
 
-            var quantity13 = VolumeConcentration.From(1, VolumeConcentrationUnit.PartPerBillion);
+            var quantity13 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.PartPerBillion);
             AssertEx.EqualTolerance(1, quantity13.PartsPerBillion, PartsPerBillionTolerance);
             Assert.Equal(VolumeConcentrationUnit.PartPerBillion, quantity13.Unit);
 
-            var quantity14 = VolumeConcentration.From(1, VolumeConcentrationUnit.PartPerMillion);
+            var quantity14 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.PartPerMillion);
             AssertEx.EqualTolerance(1, quantity14.PartsPerMillion, PartsPerMillionTolerance);
             Assert.Equal(VolumeConcentrationUnit.PartPerMillion, quantity14.Unit);
 
-            var quantity15 = VolumeConcentration.From(1, VolumeConcentrationUnit.PartPerThousand);
+            var quantity15 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.PartPerThousand);
             AssertEx.EqualTolerance(1, quantity15.PartsPerThousand, PartsPerThousandTolerance);
             Assert.Equal(VolumeConcentrationUnit.PartPerThousand, quantity15.Unit);
 
-            var quantity16 = VolumeConcentration.From(1, VolumeConcentrationUnit.PartPerTrillion);
+            var quantity16 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.PartPerTrillion);
             AssertEx.EqualTolerance(1, quantity16.PartsPerTrillion, PartsPerTrillionTolerance);
             Assert.Equal(VolumeConcentrationUnit.PartPerTrillion, quantity16.Unit);
 
-            var quantity17 = VolumeConcentration.From(1, VolumeConcentrationUnit.Percent);
+            var quantity17 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.Percent);
             AssertEx.EqualTolerance(1, quantity17.Percent, PercentTolerance);
             Assert.Equal(VolumeConcentrationUnit.Percent, quantity17.Unit);
 
-            var quantity18 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicolitersPerLiter);
+            var quantity18 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.PicolitersPerLiter);
             AssertEx.EqualTolerance(1, quantity18.PicolitersPerLiter, PicolitersPerLiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.PicolitersPerLiter, quantity18.Unit);
 
-            var quantity19 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicolitersPerMililiter);
+            var quantity19 = VolumeConcentration<double>.From(1, VolumeConcentrationUnit.PicolitersPerMililiter);
             AssertEx.EqualTolerance(1, quantity19.PicolitersPerMililiter, PicolitersPerMililiterTolerance);
             Assert.Equal(VolumeConcentrationUnit.PicolitersPerMililiter, quantity19.Unit);
 
@@ -263,20 +263,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromDecimalFractions_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VolumeConcentration.FromDecimalFractions(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => VolumeConcentration.FromDecimalFractions(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => VolumeConcentration<double>.FromDecimalFractions(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => VolumeConcentration<double>.FromDecimalFractions(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromDecimalFractions_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VolumeConcentration.FromDecimalFractions(double.NaN));
+            Assert.Throws<ArgumentException>(() => VolumeConcentration<double>.FromDecimalFractions(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            var decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentilitersPerLiter), CentilitersPerLiterTolerance);
             AssertEx.EqualTolerance(CentilitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentilitersPerMililiter), CentilitersPerMililiterTolerance);
             AssertEx.EqualTolerance(DecilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecilitersPerLiter), DecilitersPerLiterTolerance);
@@ -319,7 +319,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            var decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
 
             var centilitersperliterQuantity = decimalfraction.ToUnit(VolumeConcentrationUnit.CentilitersPerLiter);
             AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, (double)centilitersperliterQuantity.Value, CentilitersPerLiterTolerance);
@@ -412,47 +412,47 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromCentilitersPerLiter(decimalfraction.CentilitersPerLiter).DecimalFractions, CentilitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromCentilitersPerMililiter(decimalfraction.CentilitersPerMililiter).DecimalFractions, CentilitersPerMililiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromDecilitersPerLiter(decimalfraction.DecilitersPerLiter).DecimalFractions, DecilitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromDecilitersPerMililiter(decimalfraction.DecilitersPerMililiter).DecimalFractions, DecilitersPerMililiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromLitersPerLiter(decimalfraction.LitersPerLiter).DecimalFractions, LitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromLitersPerMililiter(decimalfraction.LitersPerMililiter).DecimalFractions, LitersPerMililiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMicrolitersPerLiter(decimalfraction.MicrolitersPerLiter).DecimalFractions, MicrolitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMicrolitersPerMililiter(decimalfraction.MicrolitersPerMililiter).DecimalFractions, MicrolitersPerMililiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMillilitersPerLiter(decimalfraction.MillilitersPerLiter).DecimalFractions, MillilitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMillilitersPerMililiter(decimalfraction.MillilitersPerMililiter).DecimalFractions, MillilitersPerMililiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromNanolitersPerLiter(decimalfraction.NanolitersPerLiter).DecimalFractions, NanolitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromNanolitersPerMililiter(decimalfraction.NanolitersPerMililiter).DecimalFractions, NanolitersPerMililiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPicolitersPerLiter(decimalfraction.PicolitersPerLiter).DecimalFractions, PicolitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPicolitersPerMililiter(decimalfraction.PicolitersPerMililiter).DecimalFractions, PicolitersPerMililiterTolerance);
+            VolumeConcentration<double> decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromCentilitersPerLiter(decimalfraction.CentilitersPerLiter).DecimalFractions, CentilitersPerLiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromCentilitersPerMililiter(decimalfraction.CentilitersPerMililiter).DecimalFractions, CentilitersPerMililiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromDecilitersPerLiter(decimalfraction.DecilitersPerLiter).DecimalFractions, DecilitersPerLiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromDecilitersPerMililiter(decimalfraction.DecilitersPerMililiter).DecimalFractions, DecilitersPerMililiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromLitersPerLiter(decimalfraction.LitersPerLiter).DecimalFractions, LitersPerLiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromLitersPerMililiter(decimalfraction.LitersPerMililiter).DecimalFractions, LitersPerMililiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromMicrolitersPerLiter(decimalfraction.MicrolitersPerLiter).DecimalFractions, MicrolitersPerLiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromMicrolitersPerMililiter(decimalfraction.MicrolitersPerMililiter).DecimalFractions, MicrolitersPerMililiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromMillilitersPerLiter(decimalfraction.MillilitersPerLiter).DecimalFractions, MillilitersPerLiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromMillilitersPerMililiter(decimalfraction.MillilitersPerMililiter).DecimalFractions, MillilitersPerMililiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromNanolitersPerLiter(decimalfraction.NanolitersPerLiter).DecimalFractions, NanolitersPerLiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromNanolitersPerMililiter(decimalfraction.NanolitersPerMililiter).DecimalFractions, NanolitersPerMililiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromPicolitersPerLiter(decimalfraction.PicolitersPerLiter).DecimalFractions, PicolitersPerLiterTolerance);
+            AssertEx.EqualTolerance(1, VolumeConcentration<double>.FromPicolitersPerMililiter(decimalfraction.PicolitersPerMililiter).DecimalFractions, PicolitersPerMililiterTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            VolumeConcentration v = VolumeConcentration.FromDecimalFractions(1);
+            VolumeConcentration<double> v = VolumeConcentration<double>.FromDecimalFractions(1);
             AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (VolumeConcentration.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (VolumeConcentration<double>.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(10, (v*10).DecimalFractions, DecimalFractionsTolerance);
             AssertEx.EqualTolerance(10, (10*v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (VolumeConcentration.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, VolumeConcentration.FromDecimalFractions(10)/VolumeConcentration.FromDecimalFractions(5), DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, (VolumeConcentration<double>.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
+            AssertEx.EqualTolerance(2, VolumeConcentration<double>.FromDecimalFractions(10)/VolumeConcentration<double>.FromDecimalFractions(5), DecimalFractionsTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            VolumeConcentration oneDecimalFraction = VolumeConcentration.FromDecimalFractions(1);
-            VolumeConcentration twoDecimalFractions = VolumeConcentration.FromDecimalFractions(2);
+            VolumeConcentration<double> oneDecimalFraction = VolumeConcentration<double>.FromDecimalFractions(1);
+            VolumeConcentration<double> twoDecimalFractions = VolumeConcentration<double>.FromDecimalFractions(2);
 
             Assert.True(oneDecimalFraction < twoDecimalFractions);
             Assert.True(oneDecimalFraction <= twoDecimalFractions);
@@ -468,31 +468,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            VolumeConcentration<double> decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
             Assert.Equal(0, decimalfraction.CompareTo(decimalfraction));
-            Assert.True(decimalfraction.CompareTo(VolumeConcentration.Zero) > 0);
-            Assert.True(VolumeConcentration.Zero.CompareTo(decimalfraction) < 0);
+            Assert.True(decimalfraction.CompareTo(VolumeConcentration<double>.Zero) > 0);
+            Assert.True(VolumeConcentration<double>.Zero.CompareTo(decimalfraction) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            VolumeConcentration<double> decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
             Assert.Throws<ArgumentException>(() => decimalfraction.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            VolumeConcentration<double> decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
             Assert.Throws<ArgumentNullException>(() => decimalfraction.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = VolumeConcentration.FromDecimalFractions(1);
-            var b = VolumeConcentration.FromDecimalFractions(2);
+            var a = VolumeConcentration<double>.FromDecimalFractions(1);
+            var b = VolumeConcentration<double>.FromDecimalFractions(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -511,8 +511,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = VolumeConcentration.FromDecimalFractions(1);
-            var b = VolumeConcentration.FromDecimalFractions(2);
+            var a = VolumeConcentration<double>.FromDecimalFractions(1);
+            var b = VolumeConcentration<double>.FromDecimalFractions(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -532,9 +532,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = VolumeConcentration.FromDecimalFractions(1);
-            Assert.True(v.Equals(VolumeConcentration.FromDecimalFractions(1), DecimalFractionsTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(VolumeConcentration.Zero, DecimalFractionsTolerance, ComparisonType.Relative));
+            var v = VolumeConcentration<double>.FromDecimalFractions(1);
+            Assert.True(v.Equals(VolumeConcentration<double>.FromDecimalFractions(1), DecimalFractionsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(VolumeConcentration<double>.Zero, DecimalFractionsTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -547,21 +547,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            VolumeConcentration<double> decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
             Assert.False(decimalfraction.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
+            VolumeConcentration<double> decimalfraction = VolumeConcentration<double>.FromDecimalFractions(1);
             Assert.False(decimalfraction.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(VolumeConcentrationUnit.Undefined, VolumeConcentration.Units);
+            Assert.DoesNotContain(VolumeConcentrationUnit.Undefined, VolumeConcentration<double>.Units);
         }
 
         [Fact]
@@ -580,7 +580,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(VolumeConcentration.BaseDimensions is null);
+            Assert.False(VolumeConcentration<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs
index 27354831f6..4b7aa65f80 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs
@@ -156,7 +156,7 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumeFlow((double)0.0, VolumeFlowUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new VolumeFlow<double>((double)0.0, VolumeFlowUnit.Undefined));
         }
 
         [Fact]
@@ -171,14 +171,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumeFlow(double.PositiveInfinity, VolumeFlowUnit.CubicMeterPerSecond));
-            Assert.Throws<ArgumentException>(() => new VolumeFlow(double.NegativeInfinity, VolumeFlowUnit.CubicMeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new VolumeFlow<double>(double.PositiveInfinity, VolumeFlowUnit.CubicMeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new VolumeFlow<double>(double.NegativeInfinity, VolumeFlowUnit.CubicMeterPerSecond));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumeFlow(double.NaN, VolumeFlowUnit.CubicMeterPerSecond));
+            Assert.Throws<ArgumentException>(() => new VolumeFlow<double>(double.NaN, VolumeFlowUnit.CubicMeterPerSecond));
         }
 
         [Fact]
@@ -224,7 +224,7 @@ public void VolumeFlow_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void CubicMeterPerSecondToVolumeFlowUnits()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             AssertEx.EqualTolerance(AcreFeetPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.AcreFeetPerDay, AcreFeetPerDayTolerance);
             AssertEx.EqualTolerance(AcreFeetPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.AcreFeetPerHour, AcreFeetPerHourTolerance);
             AssertEx.EqualTolerance(AcreFeetPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.AcreFeetPerMinute, AcreFeetPerMinuteTolerance);
@@ -286,227 +286,227 @@ public void CubicMeterPerSecondToVolumeFlowUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = VolumeFlow.From(1, VolumeFlowUnit.AcreFootPerDay);
+            var quantity00 = VolumeFlow<double>.From(1, VolumeFlowUnit.AcreFootPerDay);
             AssertEx.EqualTolerance(1, quantity00.AcreFeetPerDay, AcreFeetPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.AcreFootPerDay, quantity00.Unit);
 
-            var quantity01 = VolumeFlow.From(1, VolumeFlowUnit.AcreFootPerHour);
+            var quantity01 = VolumeFlow<double>.From(1, VolumeFlowUnit.AcreFootPerHour);
             AssertEx.EqualTolerance(1, quantity01.AcreFeetPerHour, AcreFeetPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.AcreFootPerHour, quantity01.Unit);
 
-            var quantity02 = VolumeFlow.From(1, VolumeFlowUnit.AcreFootPerMinute);
+            var quantity02 = VolumeFlow<double>.From(1, VolumeFlowUnit.AcreFootPerMinute);
             AssertEx.EqualTolerance(1, quantity02.AcreFeetPerMinute, AcreFeetPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.AcreFootPerMinute, quantity02.Unit);
 
-            var quantity03 = VolumeFlow.From(1, VolumeFlowUnit.AcreFootPerSecond);
+            var quantity03 = VolumeFlow<double>.From(1, VolumeFlowUnit.AcreFootPerSecond);
             AssertEx.EqualTolerance(1, quantity03.AcreFeetPerSecond, AcreFeetPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.AcreFootPerSecond, quantity03.Unit);
 
-            var quantity04 = VolumeFlow.From(1, VolumeFlowUnit.CentiliterPerDay);
+            var quantity04 = VolumeFlow<double>.From(1, VolumeFlowUnit.CentiliterPerDay);
             AssertEx.EqualTolerance(1, quantity04.CentilitersPerDay, CentilitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.CentiliterPerDay, quantity04.Unit);
 
-            var quantity05 = VolumeFlow.From(1, VolumeFlowUnit.CentiliterPerMinute);
+            var quantity05 = VolumeFlow<double>.From(1, VolumeFlowUnit.CentiliterPerMinute);
             AssertEx.EqualTolerance(1, quantity05.CentilitersPerMinute, CentilitersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.CentiliterPerMinute, quantity05.Unit);
 
-            var quantity06 = VolumeFlow.From(1, VolumeFlowUnit.CentiliterPerSecond);
+            var quantity06 = VolumeFlow<double>.From(1, VolumeFlowUnit.CentiliterPerSecond);
             AssertEx.EqualTolerance(1, quantity06.CentilitersPerSecond, CentilitersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.CentiliterPerSecond, quantity06.Unit);
 
-            var quantity07 = VolumeFlow.From(1, VolumeFlowUnit.CubicCentimeterPerMinute);
+            var quantity07 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicCentimeterPerMinute);
             AssertEx.EqualTolerance(1, quantity07.CubicCentimetersPerMinute, CubicCentimetersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.CubicCentimeterPerMinute, quantity07.Unit);
 
-            var quantity08 = VolumeFlow.From(1, VolumeFlowUnit.CubicDecimeterPerMinute);
+            var quantity08 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicDecimeterPerMinute);
             AssertEx.EqualTolerance(1, quantity08.CubicDecimetersPerMinute, CubicDecimetersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.CubicDecimeterPerMinute, quantity08.Unit);
 
-            var quantity09 = VolumeFlow.From(1, VolumeFlowUnit.CubicFootPerHour);
+            var quantity09 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicFootPerHour);
             AssertEx.EqualTolerance(1, quantity09.CubicFeetPerHour, CubicFeetPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.CubicFootPerHour, quantity09.Unit);
 
-            var quantity10 = VolumeFlow.From(1, VolumeFlowUnit.CubicFootPerMinute);
+            var quantity10 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicFootPerMinute);
             AssertEx.EqualTolerance(1, quantity10.CubicFeetPerMinute, CubicFeetPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.CubicFootPerMinute, quantity10.Unit);
 
-            var quantity11 = VolumeFlow.From(1, VolumeFlowUnit.CubicFootPerSecond);
+            var quantity11 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicFootPerSecond);
             AssertEx.EqualTolerance(1, quantity11.CubicFeetPerSecond, CubicFeetPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.CubicFootPerSecond, quantity11.Unit);
 
-            var quantity12 = VolumeFlow.From(1, VolumeFlowUnit.CubicMeterPerDay);
+            var quantity12 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicMeterPerDay);
             AssertEx.EqualTolerance(1, quantity12.CubicMetersPerDay, CubicMetersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.CubicMeterPerDay, quantity12.Unit);
 
-            var quantity13 = VolumeFlow.From(1, VolumeFlowUnit.CubicMeterPerHour);
+            var quantity13 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicMeterPerHour);
             AssertEx.EqualTolerance(1, quantity13.CubicMetersPerHour, CubicMetersPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.CubicMeterPerHour, quantity13.Unit);
 
-            var quantity14 = VolumeFlow.From(1, VolumeFlowUnit.CubicMeterPerMinute);
+            var quantity14 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicMeterPerMinute);
             AssertEx.EqualTolerance(1, quantity14.CubicMetersPerMinute, CubicMetersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.CubicMeterPerMinute, quantity14.Unit);
 
-            var quantity15 = VolumeFlow.From(1, VolumeFlowUnit.CubicMeterPerSecond);
+            var quantity15 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicMeterPerSecond);
             AssertEx.EqualTolerance(1, quantity15.CubicMetersPerSecond, CubicMetersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.CubicMeterPerSecond, quantity15.Unit);
 
-            var quantity16 = VolumeFlow.From(1, VolumeFlowUnit.CubicMillimeterPerSecond);
+            var quantity16 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicMillimeterPerSecond);
             AssertEx.EqualTolerance(1, quantity16.CubicMillimetersPerSecond, CubicMillimetersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.CubicMillimeterPerSecond, quantity16.Unit);
 
-            var quantity17 = VolumeFlow.From(1, VolumeFlowUnit.CubicYardPerDay);
+            var quantity17 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicYardPerDay);
             AssertEx.EqualTolerance(1, quantity17.CubicYardsPerDay, CubicYardsPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.CubicYardPerDay, quantity17.Unit);
 
-            var quantity18 = VolumeFlow.From(1, VolumeFlowUnit.CubicYardPerHour);
+            var quantity18 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicYardPerHour);
             AssertEx.EqualTolerance(1, quantity18.CubicYardsPerHour, CubicYardsPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.CubicYardPerHour, quantity18.Unit);
 
-            var quantity19 = VolumeFlow.From(1, VolumeFlowUnit.CubicYardPerMinute);
+            var quantity19 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicYardPerMinute);
             AssertEx.EqualTolerance(1, quantity19.CubicYardsPerMinute, CubicYardsPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.CubicYardPerMinute, quantity19.Unit);
 
-            var quantity20 = VolumeFlow.From(1, VolumeFlowUnit.CubicYardPerSecond);
+            var quantity20 = VolumeFlow<double>.From(1, VolumeFlowUnit.CubicYardPerSecond);
             AssertEx.EqualTolerance(1, quantity20.CubicYardsPerSecond, CubicYardsPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.CubicYardPerSecond, quantity20.Unit);
 
-            var quantity21 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerDay);
+            var quantity21 = VolumeFlow<double>.From(1, VolumeFlowUnit.DeciliterPerDay);
             AssertEx.EqualTolerance(1, quantity21.DecilitersPerDay, DecilitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.DeciliterPerDay, quantity21.Unit);
 
-            var quantity22 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerMinute);
+            var quantity22 = VolumeFlow<double>.From(1, VolumeFlowUnit.DeciliterPerMinute);
             AssertEx.EqualTolerance(1, quantity22.DecilitersPerMinute, DecilitersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.DeciliterPerMinute, quantity22.Unit);
 
-            var quantity23 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerSecond);
+            var quantity23 = VolumeFlow<double>.From(1, VolumeFlowUnit.DeciliterPerSecond);
             AssertEx.EqualTolerance(1, quantity23.DecilitersPerSecond, DecilitersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.DeciliterPerSecond, quantity23.Unit);
 
-            var quantity24 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerDay);
+            var quantity24 = VolumeFlow<double>.From(1, VolumeFlowUnit.KiloliterPerDay);
             AssertEx.EqualTolerance(1, quantity24.KilolitersPerDay, KilolitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.KiloliterPerDay, quantity24.Unit);
 
-            var quantity25 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerMinute);
+            var quantity25 = VolumeFlow<double>.From(1, VolumeFlowUnit.KiloliterPerMinute);
             AssertEx.EqualTolerance(1, quantity25.KilolitersPerMinute, KilolitersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.KiloliterPerMinute, quantity25.Unit);
 
-            var quantity26 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerSecond);
+            var quantity26 = VolumeFlow<double>.From(1, VolumeFlowUnit.KiloliterPerSecond);
             AssertEx.EqualTolerance(1, quantity26.KilolitersPerSecond, KilolitersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.KiloliterPerSecond, quantity26.Unit);
 
-            var quantity27 = VolumeFlow.From(1, VolumeFlowUnit.KilousGallonPerMinute);
+            var quantity27 = VolumeFlow<double>.From(1, VolumeFlowUnit.KilousGallonPerMinute);
             AssertEx.EqualTolerance(1, quantity27.KilousGallonsPerMinute, KilousGallonsPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.KilousGallonPerMinute, quantity27.Unit);
 
-            var quantity28 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerDay);
+            var quantity28 = VolumeFlow<double>.From(1, VolumeFlowUnit.LiterPerDay);
             AssertEx.EqualTolerance(1, quantity28.LitersPerDay, LitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.LiterPerDay, quantity28.Unit);
 
-            var quantity29 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerHour);
+            var quantity29 = VolumeFlow<double>.From(1, VolumeFlowUnit.LiterPerHour);
             AssertEx.EqualTolerance(1, quantity29.LitersPerHour, LitersPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.LiterPerHour, quantity29.Unit);
 
-            var quantity30 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerMinute);
+            var quantity30 = VolumeFlow<double>.From(1, VolumeFlowUnit.LiterPerMinute);
             AssertEx.EqualTolerance(1, quantity30.LitersPerMinute, LitersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.LiterPerMinute, quantity30.Unit);
 
-            var quantity31 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerSecond);
+            var quantity31 = VolumeFlow<double>.From(1, VolumeFlowUnit.LiterPerSecond);
             AssertEx.EqualTolerance(1, quantity31.LitersPerSecond, LitersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.LiterPerSecond, quantity31.Unit);
 
-            var quantity32 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerDay);
+            var quantity32 = VolumeFlow<double>.From(1, VolumeFlowUnit.MegaliterPerDay);
             AssertEx.EqualTolerance(1, quantity32.MegalitersPerDay, MegalitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.MegaliterPerDay, quantity32.Unit);
 
-            var quantity33 = VolumeFlow.From(1, VolumeFlowUnit.MegaukGallonPerSecond);
+            var quantity33 = VolumeFlow<double>.From(1, VolumeFlowUnit.MegaukGallonPerSecond);
             AssertEx.EqualTolerance(1, quantity33.MegaukGallonsPerSecond, MegaukGallonsPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.MegaukGallonPerSecond, quantity33.Unit);
 
-            var quantity34 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerDay);
+            var quantity34 = VolumeFlow<double>.From(1, VolumeFlowUnit.MicroliterPerDay);
             AssertEx.EqualTolerance(1, quantity34.MicrolitersPerDay, MicrolitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.MicroliterPerDay, quantity34.Unit);
 
-            var quantity35 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerMinute);
+            var quantity35 = VolumeFlow<double>.From(1, VolumeFlowUnit.MicroliterPerMinute);
             AssertEx.EqualTolerance(1, quantity35.MicrolitersPerMinute, MicrolitersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.MicroliterPerMinute, quantity35.Unit);
 
-            var quantity36 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerSecond);
+            var quantity36 = VolumeFlow<double>.From(1, VolumeFlowUnit.MicroliterPerSecond);
             AssertEx.EqualTolerance(1, quantity36.MicrolitersPerSecond, MicrolitersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.MicroliterPerSecond, quantity36.Unit);
 
-            var quantity37 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerDay);
+            var quantity37 = VolumeFlow<double>.From(1, VolumeFlowUnit.MilliliterPerDay);
             AssertEx.EqualTolerance(1, quantity37.MillilitersPerDay, MillilitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.MilliliterPerDay, quantity37.Unit);
 
-            var quantity38 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerMinute);
+            var quantity38 = VolumeFlow<double>.From(1, VolumeFlowUnit.MilliliterPerMinute);
             AssertEx.EqualTolerance(1, quantity38.MillilitersPerMinute, MillilitersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.MilliliterPerMinute, quantity38.Unit);
 
-            var quantity39 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerSecond);
+            var quantity39 = VolumeFlow<double>.From(1, VolumeFlowUnit.MilliliterPerSecond);
             AssertEx.EqualTolerance(1, quantity39.MillilitersPerSecond, MillilitersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.MilliliterPerSecond, quantity39.Unit);
 
-            var quantity40 = VolumeFlow.From(1, VolumeFlowUnit.MillionUsGallonsPerDay);
+            var quantity40 = VolumeFlow<double>.From(1, VolumeFlowUnit.MillionUsGallonsPerDay);
             AssertEx.EqualTolerance(1, quantity40.MillionUsGallonsPerDay, MillionUsGallonsPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.MillionUsGallonsPerDay, quantity40.Unit);
 
-            var quantity41 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerDay);
+            var quantity41 = VolumeFlow<double>.From(1, VolumeFlowUnit.NanoliterPerDay);
             AssertEx.EqualTolerance(1, quantity41.NanolitersPerDay, NanolitersPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.NanoliterPerDay, quantity41.Unit);
 
-            var quantity42 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerMinute);
+            var quantity42 = VolumeFlow<double>.From(1, VolumeFlowUnit.NanoliterPerMinute);
             AssertEx.EqualTolerance(1, quantity42.NanolitersPerMinute, NanolitersPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.NanoliterPerMinute, quantity42.Unit);
 
-            var quantity43 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerSecond);
+            var quantity43 = VolumeFlow<double>.From(1, VolumeFlowUnit.NanoliterPerSecond);
             AssertEx.EqualTolerance(1, quantity43.NanolitersPerSecond, NanolitersPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.NanoliterPerSecond, quantity43.Unit);
 
-            var quantity44 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerDay);
+            var quantity44 = VolumeFlow<double>.From(1, VolumeFlowUnit.OilBarrelPerDay);
             AssertEx.EqualTolerance(1, quantity44.OilBarrelsPerDay, OilBarrelsPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.OilBarrelPerDay, quantity44.Unit);
 
-            var quantity45 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerHour);
+            var quantity45 = VolumeFlow<double>.From(1, VolumeFlowUnit.OilBarrelPerHour);
             AssertEx.EqualTolerance(1, quantity45.OilBarrelsPerHour, OilBarrelsPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.OilBarrelPerHour, quantity45.Unit);
 
-            var quantity46 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerMinute);
+            var quantity46 = VolumeFlow<double>.From(1, VolumeFlowUnit.OilBarrelPerMinute);
             AssertEx.EqualTolerance(1, quantity46.OilBarrelsPerMinute, OilBarrelsPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.OilBarrelPerMinute, quantity46.Unit);
 
-            var quantity47 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerSecond);
+            var quantity47 = VolumeFlow<double>.From(1, VolumeFlowUnit.OilBarrelPerSecond);
             AssertEx.EqualTolerance(1, quantity47.OilBarrelsPerSecond, OilBarrelsPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.OilBarrelPerSecond, quantity47.Unit);
 
-            var quantity48 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerDay);
+            var quantity48 = VolumeFlow<double>.From(1, VolumeFlowUnit.UkGallonPerDay);
             AssertEx.EqualTolerance(1, quantity48.UkGallonsPerDay, UkGallonsPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.UkGallonPerDay, quantity48.Unit);
 
-            var quantity49 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerHour);
+            var quantity49 = VolumeFlow<double>.From(1, VolumeFlowUnit.UkGallonPerHour);
             AssertEx.EqualTolerance(1, quantity49.UkGallonsPerHour, UkGallonsPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.UkGallonPerHour, quantity49.Unit);
 
-            var quantity50 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerMinute);
+            var quantity50 = VolumeFlow<double>.From(1, VolumeFlowUnit.UkGallonPerMinute);
             AssertEx.EqualTolerance(1, quantity50.UkGallonsPerMinute, UkGallonsPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.UkGallonPerMinute, quantity50.Unit);
 
-            var quantity51 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerSecond);
+            var quantity51 = VolumeFlow<double>.From(1, VolumeFlowUnit.UkGallonPerSecond);
             AssertEx.EqualTolerance(1, quantity51.UkGallonsPerSecond, UkGallonsPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.UkGallonPerSecond, quantity51.Unit);
 
-            var quantity52 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerDay);
+            var quantity52 = VolumeFlow<double>.From(1, VolumeFlowUnit.UsGallonPerDay);
             AssertEx.EqualTolerance(1, quantity52.UsGallonsPerDay, UsGallonsPerDayTolerance);
             Assert.Equal(VolumeFlowUnit.UsGallonPerDay, quantity52.Unit);
 
-            var quantity53 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerHour);
+            var quantity53 = VolumeFlow<double>.From(1, VolumeFlowUnit.UsGallonPerHour);
             AssertEx.EqualTolerance(1, quantity53.UsGallonsPerHour, UsGallonsPerHourTolerance);
             Assert.Equal(VolumeFlowUnit.UsGallonPerHour, quantity53.Unit);
 
-            var quantity54 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerMinute);
+            var quantity54 = VolumeFlow<double>.From(1, VolumeFlowUnit.UsGallonPerMinute);
             AssertEx.EqualTolerance(1, quantity54.UsGallonsPerMinute, UsGallonsPerMinuteTolerance);
             Assert.Equal(VolumeFlowUnit.UsGallonPerMinute, quantity54.Unit);
 
-            var quantity55 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerSecond);
+            var quantity55 = VolumeFlow<double>.From(1, VolumeFlowUnit.UsGallonPerSecond);
             AssertEx.EqualTolerance(1, quantity55.UsGallonsPerSecond, UsGallonsPerSecondTolerance);
             Assert.Equal(VolumeFlowUnit.UsGallonPerSecond, quantity55.Unit);
 
@@ -515,20 +515,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCubicMetersPerSecond_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VolumeFlow.FromCubicMetersPerSecond(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => VolumeFlow.FromCubicMetersPerSecond(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => VolumeFlow<double>.FromCubicMetersPerSecond(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => VolumeFlow<double>.FromCubicMetersPerSecond(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCubicMetersPerSecond_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VolumeFlow.FromCubicMetersPerSecond(double.NaN));
+            Assert.Throws<ArgumentException>(() => VolumeFlow<double>.FromCubicMetersPerSecond(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            var cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             AssertEx.EqualTolerance(AcreFeetPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.AcreFootPerDay), AcreFeetPerDayTolerance);
             AssertEx.EqualTolerance(AcreFeetPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.AcreFootPerHour), AcreFeetPerHourTolerance);
             AssertEx.EqualTolerance(AcreFeetPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.AcreFootPerMinute), AcreFeetPerMinuteTolerance);
@@ -607,7 +607,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            var cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
 
             var acrefootperdayQuantity = cubicmeterpersecond.ToUnit(VolumeFlowUnit.AcreFootPerDay);
             AssertEx.EqualTolerance(AcreFeetPerDayInOneCubicMeterPerSecond, (double)acrefootperdayQuantity.Value, AcreFeetPerDayTolerance);
@@ -844,83 +844,83 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerDay(cubicmeterpersecond.AcreFeetPerDay).CubicMetersPerSecond, AcreFeetPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerHour(cubicmeterpersecond.AcreFeetPerHour).CubicMetersPerSecond, AcreFeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerMinute(cubicmeterpersecond.AcreFeetPerMinute).CubicMetersPerSecond, AcreFeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerSecond(cubicmeterpersecond.AcreFeetPerSecond).CubicMetersPerSecond, AcreFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCentilitersPerDay(cubicmeterpersecond.CentilitersPerDay).CubicMetersPerSecond, CentilitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCentilitersPerMinute(cubicmeterpersecond.CentilitersPerMinute).CubicMetersPerSecond, CentilitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCentilitersPerSecond(cubicmeterpersecond.CentilitersPerSecond).CubicMetersPerSecond, CentilitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicCentimetersPerMinute(cubicmeterpersecond.CubicCentimetersPerMinute).CubicMetersPerSecond, CubicCentimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicDecimetersPerMinute(cubicmeterpersecond.CubicDecimetersPerMinute).CubicMetersPerSecond, CubicDecimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicFeetPerHour(cubicmeterpersecond.CubicFeetPerHour).CubicMetersPerSecond, CubicFeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicFeetPerMinute(cubicmeterpersecond.CubicFeetPerMinute).CubicMetersPerSecond, CubicFeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicFeetPerSecond(cubicmeterpersecond.CubicFeetPerSecond).CubicMetersPerSecond, CubicFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerDay(cubicmeterpersecond.CubicMetersPerDay).CubicMetersPerSecond, CubicMetersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerHour(cubicmeterpersecond.CubicMetersPerHour).CubicMetersPerSecond, CubicMetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerMinute(cubicmeterpersecond.CubicMetersPerMinute).CubicMetersPerSecond, CubicMetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerSecond(cubicmeterpersecond.CubicMetersPerSecond).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMillimetersPerSecond(cubicmeterpersecond.CubicMillimetersPerSecond).CubicMetersPerSecond, CubicMillimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerDay(cubicmeterpersecond.CubicYardsPerDay).CubicMetersPerSecond, CubicYardsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerHour(cubicmeterpersecond.CubicYardsPerHour).CubicMetersPerSecond, CubicYardsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerMinute(cubicmeterpersecond.CubicYardsPerMinute).CubicMetersPerSecond, CubicYardsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerSecond(cubicmeterpersecond.CubicYardsPerSecond).CubicMetersPerSecond, CubicYardsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerDay(cubicmeterpersecond.DecilitersPerDay).CubicMetersPerSecond, DecilitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerMinute(cubicmeterpersecond.DecilitersPerMinute).CubicMetersPerSecond, DecilitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerSecond(cubicmeterpersecond.DecilitersPerSecond).CubicMetersPerSecond, DecilitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerDay(cubicmeterpersecond.KilolitersPerDay).CubicMetersPerSecond, KilolitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerMinute(cubicmeterpersecond.KilolitersPerMinute).CubicMetersPerSecond, KilolitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerSecond(cubicmeterpersecond.KilolitersPerSecond).CubicMetersPerSecond, KilolitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilousGallonsPerMinute(cubicmeterpersecond.KilousGallonsPerMinute).CubicMetersPerSecond, KilousGallonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerDay(cubicmeterpersecond.LitersPerDay).CubicMetersPerSecond, LitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerHour(cubicmeterpersecond.LitersPerHour).CubicMetersPerSecond, LitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerMinute(cubicmeterpersecond.LitersPerMinute).CubicMetersPerSecond, LitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerSecond(cubicmeterpersecond.LitersPerSecond).CubicMetersPerSecond, LitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegalitersPerDay(cubicmeterpersecond.MegalitersPerDay).CubicMetersPerSecond, MegalitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegaukGallonsPerSecond(cubicmeterpersecond.MegaukGallonsPerSecond).CubicMetersPerSecond, MegaukGallonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMicrolitersPerDay(cubicmeterpersecond.MicrolitersPerDay).CubicMetersPerSecond, MicrolitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMicrolitersPerMinute(cubicmeterpersecond.MicrolitersPerMinute).CubicMetersPerSecond, MicrolitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMicrolitersPerSecond(cubicmeterpersecond.MicrolitersPerSecond).CubicMetersPerSecond, MicrolitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillilitersPerDay(cubicmeterpersecond.MillilitersPerDay).CubicMetersPerSecond, MillilitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillilitersPerMinute(cubicmeterpersecond.MillilitersPerMinute).CubicMetersPerSecond, MillilitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillilitersPerSecond(cubicmeterpersecond.MillilitersPerSecond).CubicMetersPerSecond, MillilitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillionUsGallonsPerDay(cubicmeterpersecond.MillionUsGallonsPerDay).CubicMetersPerSecond, MillionUsGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromNanolitersPerDay(cubicmeterpersecond.NanolitersPerDay).CubicMetersPerSecond, NanolitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromNanolitersPerMinute(cubicmeterpersecond.NanolitersPerMinute).CubicMetersPerSecond, NanolitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromNanolitersPerSecond(cubicmeterpersecond.NanolitersPerSecond).CubicMetersPerSecond, NanolitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerDay(cubicmeterpersecond.OilBarrelsPerDay).CubicMetersPerSecond, OilBarrelsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerHour(cubicmeterpersecond.OilBarrelsPerHour).CubicMetersPerSecond, OilBarrelsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerMinute(cubicmeterpersecond.OilBarrelsPerMinute).CubicMetersPerSecond, OilBarrelsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerSecond(cubicmeterpersecond.OilBarrelsPerSecond).CubicMetersPerSecond, OilBarrelsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerDay(cubicmeterpersecond.UkGallonsPerDay).CubicMetersPerSecond, UkGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerHour(cubicmeterpersecond.UkGallonsPerHour).CubicMetersPerSecond, UkGallonsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerMinute(cubicmeterpersecond.UkGallonsPerMinute).CubicMetersPerSecond, UkGallonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerSecond(cubicmeterpersecond.UkGallonsPerSecond).CubicMetersPerSecond, UkGallonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerDay(cubicmeterpersecond.UsGallonsPerDay).CubicMetersPerSecond, UsGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerHour(cubicmeterpersecond.UsGallonsPerHour).CubicMetersPerSecond, UsGallonsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerMinute(cubicmeterpersecond.UsGallonsPerMinute).CubicMetersPerSecond, UsGallonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerSecond(cubicmeterpersecond.UsGallonsPerSecond).CubicMetersPerSecond, UsGallonsPerSecondTolerance);
+            VolumeFlow<double> cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromAcreFeetPerDay(cubicmeterpersecond.AcreFeetPerDay).CubicMetersPerSecond, AcreFeetPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromAcreFeetPerHour(cubicmeterpersecond.AcreFeetPerHour).CubicMetersPerSecond, AcreFeetPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromAcreFeetPerMinute(cubicmeterpersecond.AcreFeetPerMinute).CubicMetersPerSecond, AcreFeetPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromAcreFeetPerSecond(cubicmeterpersecond.AcreFeetPerSecond).CubicMetersPerSecond, AcreFeetPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCentilitersPerDay(cubicmeterpersecond.CentilitersPerDay).CubicMetersPerSecond, CentilitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCentilitersPerMinute(cubicmeterpersecond.CentilitersPerMinute).CubicMetersPerSecond, CentilitersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCentilitersPerSecond(cubicmeterpersecond.CentilitersPerSecond).CubicMetersPerSecond, CentilitersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicCentimetersPerMinute(cubicmeterpersecond.CubicCentimetersPerMinute).CubicMetersPerSecond, CubicCentimetersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicDecimetersPerMinute(cubicmeterpersecond.CubicDecimetersPerMinute).CubicMetersPerSecond, CubicDecimetersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicFeetPerHour(cubicmeterpersecond.CubicFeetPerHour).CubicMetersPerSecond, CubicFeetPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicFeetPerMinute(cubicmeterpersecond.CubicFeetPerMinute).CubicMetersPerSecond, CubicFeetPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicFeetPerSecond(cubicmeterpersecond.CubicFeetPerSecond).CubicMetersPerSecond, CubicFeetPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicMetersPerDay(cubicmeterpersecond.CubicMetersPerDay).CubicMetersPerSecond, CubicMetersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicMetersPerHour(cubicmeterpersecond.CubicMetersPerHour).CubicMetersPerSecond, CubicMetersPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicMetersPerMinute(cubicmeterpersecond.CubicMetersPerMinute).CubicMetersPerSecond, CubicMetersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicMetersPerSecond(cubicmeterpersecond.CubicMetersPerSecond).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicMillimetersPerSecond(cubicmeterpersecond.CubicMillimetersPerSecond).CubicMetersPerSecond, CubicMillimetersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicYardsPerDay(cubicmeterpersecond.CubicYardsPerDay).CubicMetersPerSecond, CubicYardsPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicYardsPerHour(cubicmeterpersecond.CubicYardsPerHour).CubicMetersPerSecond, CubicYardsPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicYardsPerMinute(cubicmeterpersecond.CubicYardsPerMinute).CubicMetersPerSecond, CubicYardsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromCubicYardsPerSecond(cubicmeterpersecond.CubicYardsPerSecond).CubicMetersPerSecond, CubicYardsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromDecilitersPerDay(cubicmeterpersecond.DecilitersPerDay).CubicMetersPerSecond, DecilitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromDecilitersPerMinute(cubicmeterpersecond.DecilitersPerMinute).CubicMetersPerSecond, DecilitersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromDecilitersPerSecond(cubicmeterpersecond.DecilitersPerSecond).CubicMetersPerSecond, DecilitersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromKilolitersPerDay(cubicmeterpersecond.KilolitersPerDay).CubicMetersPerSecond, KilolitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromKilolitersPerMinute(cubicmeterpersecond.KilolitersPerMinute).CubicMetersPerSecond, KilolitersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromKilolitersPerSecond(cubicmeterpersecond.KilolitersPerSecond).CubicMetersPerSecond, KilolitersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromKilousGallonsPerMinute(cubicmeterpersecond.KilousGallonsPerMinute).CubicMetersPerSecond, KilousGallonsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromLitersPerDay(cubicmeterpersecond.LitersPerDay).CubicMetersPerSecond, LitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromLitersPerHour(cubicmeterpersecond.LitersPerHour).CubicMetersPerSecond, LitersPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromLitersPerMinute(cubicmeterpersecond.LitersPerMinute).CubicMetersPerSecond, LitersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromLitersPerSecond(cubicmeterpersecond.LitersPerSecond).CubicMetersPerSecond, LitersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMegalitersPerDay(cubicmeterpersecond.MegalitersPerDay).CubicMetersPerSecond, MegalitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMegaukGallonsPerSecond(cubicmeterpersecond.MegaukGallonsPerSecond).CubicMetersPerSecond, MegaukGallonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMicrolitersPerDay(cubicmeterpersecond.MicrolitersPerDay).CubicMetersPerSecond, MicrolitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMicrolitersPerMinute(cubicmeterpersecond.MicrolitersPerMinute).CubicMetersPerSecond, MicrolitersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMicrolitersPerSecond(cubicmeterpersecond.MicrolitersPerSecond).CubicMetersPerSecond, MicrolitersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMillilitersPerDay(cubicmeterpersecond.MillilitersPerDay).CubicMetersPerSecond, MillilitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMillilitersPerMinute(cubicmeterpersecond.MillilitersPerMinute).CubicMetersPerSecond, MillilitersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMillilitersPerSecond(cubicmeterpersecond.MillilitersPerSecond).CubicMetersPerSecond, MillilitersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromMillionUsGallonsPerDay(cubicmeterpersecond.MillionUsGallonsPerDay).CubicMetersPerSecond, MillionUsGallonsPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromNanolitersPerDay(cubicmeterpersecond.NanolitersPerDay).CubicMetersPerSecond, NanolitersPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromNanolitersPerMinute(cubicmeterpersecond.NanolitersPerMinute).CubicMetersPerSecond, NanolitersPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromNanolitersPerSecond(cubicmeterpersecond.NanolitersPerSecond).CubicMetersPerSecond, NanolitersPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromOilBarrelsPerDay(cubicmeterpersecond.OilBarrelsPerDay).CubicMetersPerSecond, OilBarrelsPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromOilBarrelsPerHour(cubicmeterpersecond.OilBarrelsPerHour).CubicMetersPerSecond, OilBarrelsPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromOilBarrelsPerMinute(cubicmeterpersecond.OilBarrelsPerMinute).CubicMetersPerSecond, OilBarrelsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromOilBarrelsPerSecond(cubicmeterpersecond.OilBarrelsPerSecond).CubicMetersPerSecond, OilBarrelsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUkGallonsPerDay(cubicmeterpersecond.UkGallonsPerDay).CubicMetersPerSecond, UkGallonsPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUkGallonsPerHour(cubicmeterpersecond.UkGallonsPerHour).CubicMetersPerSecond, UkGallonsPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUkGallonsPerMinute(cubicmeterpersecond.UkGallonsPerMinute).CubicMetersPerSecond, UkGallonsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUkGallonsPerSecond(cubicmeterpersecond.UkGallonsPerSecond).CubicMetersPerSecond, UkGallonsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUsGallonsPerDay(cubicmeterpersecond.UsGallonsPerDay).CubicMetersPerSecond, UsGallonsPerDayTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUsGallonsPerHour(cubicmeterpersecond.UsGallonsPerHour).CubicMetersPerSecond, UsGallonsPerHourTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUsGallonsPerMinute(cubicmeterpersecond.UsGallonsPerMinute).CubicMetersPerSecond, UsGallonsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, VolumeFlow<double>.FromUsGallonsPerSecond(cubicmeterpersecond.UsGallonsPerSecond).CubicMetersPerSecond, UsGallonsPerSecondTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            VolumeFlow v = VolumeFlow.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> v = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             AssertEx.EqualTolerance(-1, -v.CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (VolumeFlow.FromCubicMetersPerSecond(3)-v).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (VolumeFlow<double>.FromCubicMetersPerSecond(3)-v).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
             AssertEx.EqualTolerance(2, (v + v).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
             AssertEx.EqualTolerance(10, (v*10).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
             AssertEx.EqualTolerance(10, (10*v).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (VolumeFlow.FromCubicMetersPerSecond(10)/5).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, VolumeFlow.FromCubicMetersPerSecond(10)/VolumeFlow.FromCubicMetersPerSecond(5), CubicMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, (VolumeFlow<double>.FromCubicMetersPerSecond(10)/5).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(2, VolumeFlow<double>.FromCubicMetersPerSecond(10)/VolumeFlow<double>.FromCubicMetersPerSecond(5), CubicMetersPerSecondTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            VolumeFlow oneCubicMeterPerSecond = VolumeFlow.FromCubicMetersPerSecond(1);
-            VolumeFlow twoCubicMetersPerSecond = VolumeFlow.FromCubicMetersPerSecond(2);
+            VolumeFlow<double> oneCubicMeterPerSecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> twoCubicMetersPerSecond = VolumeFlow<double>.FromCubicMetersPerSecond(2);
 
             Assert.True(oneCubicMeterPerSecond < twoCubicMetersPerSecond);
             Assert.True(oneCubicMeterPerSecond <= twoCubicMetersPerSecond);
@@ -936,31 +936,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             Assert.Equal(0, cubicmeterpersecond.CompareTo(cubicmeterpersecond));
-            Assert.True(cubicmeterpersecond.CompareTo(VolumeFlow.Zero) > 0);
-            Assert.True(VolumeFlow.Zero.CompareTo(cubicmeterpersecond) < 0);
+            Assert.True(cubicmeterpersecond.CompareTo(VolumeFlow<double>.Zero) > 0);
+            Assert.True(VolumeFlow<double>.Zero.CompareTo(cubicmeterpersecond) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             Assert.Throws<ArgumentException>(() => cubicmeterpersecond.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             Assert.Throws<ArgumentNullException>(() => cubicmeterpersecond.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = VolumeFlow.FromCubicMetersPerSecond(1);
-            var b = VolumeFlow.FromCubicMetersPerSecond(2);
+            var a = VolumeFlow<double>.FromCubicMetersPerSecond(1);
+            var b = VolumeFlow<double>.FromCubicMetersPerSecond(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -979,8 +979,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = VolumeFlow.FromCubicMetersPerSecond(1);
-            var b = VolumeFlow.FromCubicMetersPerSecond(2);
+            var a = VolumeFlow<double>.FromCubicMetersPerSecond(1);
+            var b = VolumeFlow<double>.FromCubicMetersPerSecond(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -1000,9 +1000,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = VolumeFlow.FromCubicMetersPerSecond(1);
-            Assert.True(v.Equals(VolumeFlow.FromCubicMetersPerSecond(1), CubicMetersPerSecondTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(VolumeFlow.Zero, CubicMetersPerSecondTolerance, ComparisonType.Relative));
+            var v = VolumeFlow<double>.FromCubicMetersPerSecond(1);
+            Assert.True(v.Equals(VolumeFlow<double>.FromCubicMetersPerSecond(1), CubicMetersPerSecondTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(VolumeFlow<double>.Zero, CubicMetersPerSecondTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -1015,21 +1015,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             Assert.False(cubicmeterpersecond.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
+            VolumeFlow<double> cubicmeterpersecond = VolumeFlow<double>.FromCubicMetersPerSecond(1);
             Assert.False(cubicmeterpersecond.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(VolumeFlowUnit.Undefined, VolumeFlow.Units);
+            Assert.DoesNotContain(VolumeFlowUnit.Undefined, VolumeFlow<double>.Units);
         }
 
         [Fact]
@@ -1048,7 +1048,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(VolumeFlow.BaseDimensions is null);
+            Assert.False(VolumeFlow<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs
index 3a8412b8fc..85cb0aedd2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs
@@ -58,7 +58,7 @@ public abstract partial class VolumePerLengthTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumePerLength((double)0.0, VolumePerLengthUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>((double)0.0, VolumePerLengthUnit.Undefined));
         }
 
         [Fact]
@@ -73,14 +73,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumePerLength(double.PositiveInfinity, VolumePerLengthUnit.CubicMeterPerMeter));
-            Assert.Throws<ArgumentException>(() => new VolumePerLength(double.NegativeInfinity, VolumePerLengthUnit.CubicMeterPerMeter));
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>(double.PositiveInfinity, VolumePerLengthUnit.CubicMeterPerMeter));
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>(double.NegativeInfinity, VolumePerLengthUnit.CubicMeterPerMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new VolumePerLength(double.NaN, VolumePerLengthUnit.CubicMeterPerMeter));
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>(double.NaN, VolumePerLengthUnit.CubicMeterPerMeter));
         }
 
         [Fact]
@@ -126,7 +126,7 @@ public void VolumePerLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void CubicMeterPerMeterToVolumePerLengthUnits()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.CubicMetersPerMeter, CubicMetersPerMeterTolerance);
             AssertEx.EqualTolerance(CubicYardsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.CubicYardsPerFoot, CubicYardsPerFootTolerance);
             AssertEx.EqualTolerance(CubicYardsPerUsSurveyFootInOneCubicMeterPerMeter, cubicmeterpermeter.CubicYardsPerUsSurveyFoot, CubicYardsPerUsSurveyFootTolerance);
@@ -139,31 +139,31 @@ public void CubicMeterPerMeterToVolumePerLengthUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = VolumePerLength.From(1, VolumePerLengthUnit.CubicMeterPerMeter);
+            var quantity00 = VolumePerLength<double>.From(1, VolumePerLengthUnit.CubicMeterPerMeter);
             AssertEx.EqualTolerance(1, quantity00.CubicMetersPerMeter, CubicMetersPerMeterTolerance);
             Assert.Equal(VolumePerLengthUnit.CubicMeterPerMeter, quantity00.Unit);
 
-            var quantity01 = VolumePerLength.From(1, VolumePerLengthUnit.CubicYardPerFoot);
+            var quantity01 = VolumePerLength<double>.From(1, VolumePerLengthUnit.CubicYardPerFoot);
             AssertEx.EqualTolerance(1, quantity01.CubicYardsPerFoot, CubicYardsPerFootTolerance);
             Assert.Equal(VolumePerLengthUnit.CubicYardPerFoot, quantity01.Unit);
 
-            var quantity02 = VolumePerLength.From(1, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+            var quantity02 = VolumePerLength<double>.From(1, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
             AssertEx.EqualTolerance(1, quantity02.CubicYardsPerUsSurveyFoot, CubicYardsPerUsSurveyFootTolerance);
             Assert.Equal(VolumePerLengthUnit.CubicYardPerUsSurveyFoot, quantity02.Unit);
 
-            var quantity03 = VolumePerLength.From(1, VolumePerLengthUnit.LiterPerKilometer);
+            var quantity03 = VolumePerLength<double>.From(1, VolumePerLengthUnit.LiterPerKilometer);
             AssertEx.EqualTolerance(1, quantity03.LitersPerKilometer, LitersPerKilometerTolerance);
             Assert.Equal(VolumePerLengthUnit.LiterPerKilometer, quantity03.Unit);
 
-            var quantity04 = VolumePerLength.From(1, VolumePerLengthUnit.LiterPerMeter);
+            var quantity04 = VolumePerLength<double>.From(1, VolumePerLengthUnit.LiterPerMeter);
             AssertEx.EqualTolerance(1, quantity04.LitersPerMeter, LitersPerMeterTolerance);
             Assert.Equal(VolumePerLengthUnit.LiterPerMeter, quantity04.Unit);
 
-            var quantity05 = VolumePerLength.From(1, VolumePerLengthUnit.LiterPerMillimeter);
+            var quantity05 = VolumePerLength<double>.From(1, VolumePerLengthUnit.LiterPerMillimeter);
             AssertEx.EqualTolerance(1, quantity05.LitersPerMillimeter, LitersPerMillimeterTolerance);
             Assert.Equal(VolumePerLengthUnit.LiterPerMillimeter, quantity05.Unit);
 
-            var quantity06 = VolumePerLength.From(1, VolumePerLengthUnit.OilBarrelPerFoot);
+            var quantity06 = VolumePerLength<double>.From(1, VolumePerLengthUnit.OilBarrelPerFoot);
             AssertEx.EqualTolerance(1, quantity06.OilBarrelsPerFoot, OilBarrelsPerFootTolerance);
             Assert.Equal(VolumePerLengthUnit.OilBarrelPerFoot, quantity06.Unit);
 
@@ -172,20 +172,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCubicMetersPerMeter_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VolumePerLength.FromCubicMetersPerMeter(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => VolumePerLength.FromCubicMetersPerMeter(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => VolumePerLength<double>.FromCubicMetersPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => VolumePerLength<double>.FromCubicMetersPerMeter(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCubicMetersPerMeter_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => VolumePerLength.FromCubicMetersPerMeter(double.NaN));
+            Assert.Throws<ArgumentException>(() => VolumePerLength<double>.FromCubicMetersPerMeter(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            var cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.CubicMeterPerMeter), CubicMetersPerMeterTolerance);
             AssertEx.EqualTolerance(CubicYardsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.CubicYardPerFoot), CubicYardsPerFootTolerance);
             AssertEx.EqualTolerance(CubicYardsPerUsSurveyFootInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot), CubicYardsPerUsSurveyFootTolerance);
@@ -215,7 +215,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            var cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
 
             var cubicmeterpermeterQuantity = cubicmeterpermeter.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter);
             AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, (double)cubicmeterpermeterQuantity.Value, CubicMetersPerMeterTolerance);
@@ -256,34 +256,34 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicMetersPerMeter(cubicmeterpermeter.CubicMetersPerMeter).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicYardsPerFoot(cubicmeterpermeter.CubicYardsPerFoot).CubicMetersPerMeter, CubicYardsPerFootTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicYardsPerUsSurveyFoot(cubicmeterpermeter.CubicYardsPerUsSurveyFoot).CubicMetersPerMeter, CubicYardsPerUsSurveyFootTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromLitersPerKilometer(cubicmeterpermeter.LitersPerKilometer).CubicMetersPerMeter, LitersPerKilometerTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromLitersPerMeter(cubicmeterpermeter.LitersPerMeter).CubicMetersPerMeter, LitersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromLitersPerMillimeter(cubicmeterpermeter.LitersPerMillimeter).CubicMetersPerMeter, LitersPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromOilBarrelsPerFoot(cubicmeterpermeter.OilBarrelsPerFoot).CubicMetersPerMeter, OilBarrelsPerFootTolerance);
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromCubicMetersPerMeter(cubicmeterpermeter.CubicMetersPerMeter).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromCubicYardsPerFoot(cubicmeterpermeter.CubicYardsPerFoot).CubicMetersPerMeter, CubicYardsPerFootTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromCubicYardsPerUsSurveyFoot(cubicmeterpermeter.CubicYardsPerUsSurveyFoot).CubicMetersPerMeter, CubicYardsPerUsSurveyFootTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromLitersPerKilometer(cubicmeterpermeter.LitersPerKilometer).CubicMetersPerMeter, LitersPerKilometerTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromLitersPerMeter(cubicmeterpermeter.LitersPerMeter).CubicMetersPerMeter, LitersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromLitersPerMillimeter(cubicmeterpermeter.LitersPerMillimeter).CubicMetersPerMeter, LitersPerMillimeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromOilBarrelsPerFoot(cubicmeterpermeter.OilBarrelsPerFoot).CubicMetersPerMeter, OilBarrelsPerFootTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            VolumePerLength v = VolumePerLength.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> v = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             AssertEx.EqualTolerance(-1, -v.CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (VolumePerLength.FromCubicMetersPerMeter(3)-v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (VolumePerLength<double>.FromCubicMetersPerMeter(3)-v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
             AssertEx.EqualTolerance(2, (v + v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
             AssertEx.EqualTolerance(10, (v*10).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
             AssertEx.EqualTolerance(10, (10*v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (VolumePerLength.FromCubicMetersPerMeter(10)/5).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, VolumePerLength.FromCubicMetersPerMeter(10)/VolumePerLength.FromCubicMetersPerMeter(5), CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (VolumePerLength<double>.FromCubicMetersPerMeter(10)/5).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, VolumePerLength<double>.FromCubicMetersPerMeter(10)/VolumePerLength<double>.FromCubicMetersPerMeter(5), CubicMetersPerMeterTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            VolumePerLength oneCubicMeterPerMeter = VolumePerLength.FromCubicMetersPerMeter(1);
-            VolumePerLength twoCubicMetersPerMeter = VolumePerLength.FromCubicMetersPerMeter(2);
+            VolumePerLength<double> oneCubicMeterPerMeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> twoCubicMetersPerMeter = VolumePerLength<double>.FromCubicMetersPerMeter(2);
 
             Assert.True(oneCubicMeterPerMeter < twoCubicMetersPerMeter);
             Assert.True(oneCubicMeterPerMeter <= twoCubicMetersPerMeter);
@@ -299,31 +299,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             Assert.Equal(0, cubicmeterpermeter.CompareTo(cubicmeterpermeter));
-            Assert.True(cubicmeterpermeter.CompareTo(VolumePerLength.Zero) > 0);
-            Assert.True(VolumePerLength.Zero.CompareTo(cubicmeterpermeter) < 0);
+            Assert.True(cubicmeterpermeter.CompareTo(VolumePerLength<double>.Zero) > 0);
+            Assert.True(VolumePerLength<double>.Zero.CompareTo(cubicmeterpermeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             Assert.Throws<ArgumentException>(() => cubicmeterpermeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             Assert.Throws<ArgumentNullException>(() => cubicmeterpermeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = VolumePerLength.FromCubicMetersPerMeter(1);
-            var b = VolumePerLength.FromCubicMetersPerMeter(2);
+            var a = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            var b = VolumePerLength<double>.FromCubicMetersPerMeter(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -342,8 +342,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = VolumePerLength.FromCubicMetersPerMeter(1);
-            var b = VolumePerLength.FromCubicMetersPerMeter(2);
+            var a = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            var b = VolumePerLength<double>.FromCubicMetersPerMeter(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -363,9 +363,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = VolumePerLength.FromCubicMetersPerMeter(1);
-            Assert.True(v.Equals(VolumePerLength.FromCubicMetersPerMeter(1), CubicMetersPerMeterTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(VolumePerLength.Zero, CubicMetersPerMeterTolerance, ComparisonType.Relative));
+            var v = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            Assert.True(v.Equals(VolumePerLength<double>.FromCubicMetersPerMeter(1), CubicMetersPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(VolumePerLength<double>.Zero, CubicMetersPerMeterTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -378,21 +378,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             Assert.False(cubicmeterpermeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
             Assert.False(cubicmeterpermeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(VolumePerLengthUnit.Undefined, VolumePerLength.Units);
+            Assert.DoesNotContain(VolumePerLengthUnit.Undefined, VolumePerLength<double>.Units);
         }
 
         [Fact]
@@ -411,7 +411,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(VolumePerLength.BaseDimensions is null);
+            Assert.False(VolumePerLength<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs
index 641d95c65d..89a67f257a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs
@@ -146,7 +146,7 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Volume((double)0.0, VolumeUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new Volume<double>((double)0.0, VolumeUnit.Undefined));
         }
 
         [Fact]
@@ -161,14 +161,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Volume(double.PositiveInfinity, VolumeUnit.CubicMeter));
-            Assert.Throws<ArgumentException>(() => new Volume(double.NegativeInfinity, VolumeUnit.CubicMeter));
+            Assert.Throws<ArgumentException>(() => new Volume<double>(double.PositiveInfinity, VolumeUnit.CubicMeter));
+            Assert.Throws<ArgumentException>(() => new Volume<double>(double.NegativeInfinity, VolumeUnit.CubicMeter));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new Volume(double.NaN, VolumeUnit.CubicMeter));
+            Assert.Throws<ArgumentException>(() => new Volume<double>(double.NaN, VolumeUnit.CubicMeter));
         }
 
         [Fact]
@@ -214,7 +214,7 @@ public void Volume_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
         [Fact]
         public void CubicMeterToVolumeUnits()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
+            Volume<double> cubicmeter = Volume<double>.FromCubicMeters(1);
             AssertEx.EqualTolerance(AcreFeetInOneCubicMeter, cubicmeter.AcreFeet, AcreFeetTolerance);
             AssertEx.EqualTolerance(AuTablespoonsInOneCubicMeter, cubicmeter.AuTablespoons, AuTablespoonsTolerance);
             AssertEx.EqualTolerance(BoardFeetInOneCubicMeter, cubicmeter.BoardFeet, BoardFeetTolerance);
@@ -271,207 +271,207 @@ public void CubicMeterToVolumeUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = Volume.From(1, VolumeUnit.AcreFoot);
+            var quantity00 = Volume<double>.From(1, VolumeUnit.AcreFoot);
             AssertEx.EqualTolerance(1, quantity00.AcreFeet, AcreFeetTolerance);
             Assert.Equal(VolumeUnit.AcreFoot, quantity00.Unit);
 
-            var quantity01 = Volume.From(1, VolumeUnit.AuTablespoon);
+            var quantity01 = Volume<double>.From(1, VolumeUnit.AuTablespoon);
             AssertEx.EqualTolerance(1, quantity01.AuTablespoons, AuTablespoonsTolerance);
             Assert.Equal(VolumeUnit.AuTablespoon, quantity01.Unit);
 
-            var quantity02 = Volume.From(1, VolumeUnit.BoardFoot);
+            var quantity02 = Volume<double>.From(1, VolumeUnit.BoardFoot);
             AssertEx.EqualTolerance(1, quantity02.BoardFeet, BoardFeetTolerance);
             Assert.Equal(VolumeUnit.BoardFoot, quantity02.Unit);
 
-            var quantity03 = Volume.From(1, VolumeUnit.Centiliter);
+            var quantity03 = Volume<double>.From(1, VolumeUnit.Centiliter);
             AssertEx.EqualTolerance(1, quantity03.Centiliters, CentilitersTolerance);
             Assert.Equal(VolumeUnit.Centiliter, quantity03.Unit);
 
-            var quantity04 = Volume.From(1, VolumeUnit.CubicCentimeter);
+            var quantity04 = Volume<double>.From(1, VolumeUnit.CubicCentimeter);
             AssertEx.EqualTolerance(1, quantity04.CubicCentimeters, CubicCentimetersTolerance);
             Assert.Equal(VolumeUnit.CubicCentimeter, quantity04.Unit);
 
-            var quantity05 = Volume.From(1, VolumeUnit.CubicDecimeter);
+            var quantity05 = Volume<double>.From(1, VolumeUnit.CubicDecimeter);
             AssertEx.EqualTolerance(1, quantity05.CubicDecimeters, CubicDecimetersTolerance);
             Assert.Equal(VolumeUnit.CubicDecimeter, quantity05.Unit);
 
-            var quantity06 = Volume.From(1, VolumeUnit.CubicFoot);
+            var quantity06 = Volume<double>.From(1, VolumeUnit.CubicFoot);
             AssertEx.EqualTolerance(1, quantity06.CubicFeet, CubicFeetTolerance);
             Assert.Equal(VolumeUnit.CubicFoot, quantity06.Unit);
 
-            var quantity07 = Volume.From(1, VolumeUnit.CubicHectometer);
+            var quantity07 = Volume<double>.From(1, VolumeUnit.CubicHectometer);
             AssertEx.EqualTolerance(1, quantity07.CubicHectometers, CubicHectometersTolerance);
             Assert.Equal(VolumeUnit.CubicHectometer, quantity07.Unit);
 
-            var quantity08 = Volume.From(1, VolumeUnit.CubicInch);
+            var quantity08 = Volume<double>.From(1, VolumeUnit.CubicInch);
             AssertEx.EqualTolerance(1, quantity08.CubicInches, CubicInchesTolerance);
             Assert.Equal(VolumeUnit.CubicInch, quantity08.Unit);
 
-            var quantity09 = Volume.From(1, VolumeUnit.CubicKilometer);
+            var quantity09 = Volume<double>.From(1, VolumeUnit.CubicKilometer);
             AssertEx.EqualTolerance(1, quantity09.CubicKilometers, CubicKilometersTolerance);
             Assert.Equal(VolumeUnit.CubicKilometer, quantity09.Unit);
 
-            var quantity10 = Volume.From(1, VolumeUnit.CubicMeter);
+            var quantity10 = Volume<double>.From(1, VolumeUnit.CubicMeter);
             AssertEx.EqualTolerance(1, quantity10.CubicMeters, CubicMetersTolerance);
             Assert.Equal(VolumeUnit.CubicMeter, quantity10.Unit);
 
-            var quantity11 = Volume.From(1, VolumeUnit.CubicMicrometer);
+            var quantity11 = Volume<double>.From(1, VolumeUnit.CubicMicrometer);
             AssertEx.EqualTolerance(1, quantity11.CubicMicrometers, CubicMicrometersTolerance);
             Assert.Equal(VolumeUnit.CubicMicrometer, quantity11.Unit);
 
-            var quantity12 = Volume.From(1, VolumeUnit.CubicMile);
+            var quantity12 = Volume<double>.From(1, VolumeUnit.CubicMile);
             AssertEx.EqualTolerance(1, quantity12.CubicMiles, CubicMilesTolerance);
             Assert.Equal(VolumeUnit.CubicMile, quantity12.Unit);
 
-            var quantity13 = Volume.From(1, VolumeUnit.CubicMillimeter);
+            var quantity13 = Volume<double>.From(1, VolumeUnit.CubicMillimeter);
             AssertEx.EqualTolerance(1, quantity13.CubicMillimeters, CubicMillimetersTolerance);
             Assert.Equal(VolumeUnit.CubicMillimeter, quantity13.Unit);
 
-            var quantity14 = Volume.From(1, VolumeUnit.CubicYard);
+            var quantity14 = Volume<double>.From(1, VolumeUnit.CubicYard);
             AssertEx.EqualTolerance(1, quantity14.CubicYards, CubicYardsTolerance);
             Assert.Equal(VolumeUnit.CubicYard, quantity14.Unit);
 
-            var quantity15 = Volume.From(1, VolumeUnit.DecausGallon);
+            var quantity15 = Volume<double>.From(1, VolumeUnit.DecausGallon);
             AssertEx.EqualTolerance(1, quantity15.DecausGallons, DecausGallonsTolerance);
             Assert.Equal(VolumeUnit.DecausGallon, quantity15.Unit);
 
-            var quantity16 = Volume.From(1, VolumeUnit.Deciliter);
+            var quantity16 = Volume<double>.From(1, VolumeUnit.Deciliter);
             AssertEx.EqualTolerance(1, quantity16.Deciliters, DecilitersTolerance);
             Assert.Equal(VolumeUnit.Deciliter, quantity16.Unit);
 
-            var quantity17 = Volume.From(1, VolumeUnit.DeciusGallon);
+            var quantity17 = Volume<double>.From(1, VolumeUnit.DeciusGallon);
             AssertEx.EqualTolerance(1, quantity17.DeciusGallons, DeciusGallonsTolerance);
             Assert.Equal(VolumeUnit.DeciusGallon, quantity17.Unit);
 
-            var quantity18 = Volume.From(1, VolumeUnit.HectocubicFoot);
+            var quantity18 = Volume<double>.From(1, VolumeUnit.HectocubicFoot);
             AssertEx.EqualTolerance(1, quantity18.HectocubicFeet, HectocubicFeetTolerance);
             Assert.Equal(VolumeUnit.HectocubicFoot, quantity18.Unit);
 
-            var quantity19 = Volume.From(1, VolumeUnit.HectocubicMeter);
+            var quantity19 = Volume<double>.From(1, VolumeUnit.HectocubicMeter);
             AssertEx.EqualTolerance(1, quantity19.HectocubicMeters, HectocubicMetersTolerance);
             Assert.Equal(VolumeUnit.HectocubicMeter, quantity19.Unit);
 
-            var quantity20 = Volume.From(1, VolumeUnit.Hectoliter);
+            var quantity20 = Volume<double>.From(1, VolumeUnit.Hectoliter);
             AssertEx.EqualTolerance(1, quantity20.Hectoliters, HectolitersTolerance);
             Assert.Equal(VolumeUnit.Hectoliter, quantity20.Unit);
 
-            var quantity21 = Volume.From(1, VolumeUnit.HectousGallon);
+            var quantity21 = Volume<double>.From(1, VolumeUnit.HectousGallon);
             AssertEx.EqualTolerance(1, quantity21.HectousGallons, HectousGallonsTolerance);
             Assert.Equal(VolumeUnit.HectousGallon, quantity21.Unit);
 
-            var quantity22 = Volume.From(1, VolumeUnit.ImperialBeerBarrel);
+            var quantity22 = Volume<double>.From(1, VolumeUnit.ImperialBeerBarrel);
             AssertEx.EqualTolerance(1, quantity22.ImperialBeerBarrels, ImperialBeerBarrelsTolerance);
             Assert.Equal(VolumeUnit.ImperialBeerBarrel, quantity22.Unit);
 
-            var quantity23 = Volume.From(1, VolumeUnit.ImperialGallon);
+            var quantity23 = Volume<double>.From(1, VolumeUnit.ImperialGallon);
             AssertEx.EqualTolerance(1, quantity23.ImperialGallons, ImperialGallonsTolerance);
             Assert.Equal(VolumeUnit.ImperialGallon, quantity23.Unit);
 
-            var quantity24 = Volume.From(1, VolumeUnit.ImperialOunce);
+            var quantity24 = Volume<double>.From(1, VolumeUnit.ImperialOunce);
             AssertEx.EqualTolerance(1, quantity24.ImperialOunces, ImperialOuncesTolerance);
             Assert.Equal(VolumeUnit.ImperialOunce, quantity24.Unit);
 
-            var quantity25 = Volume.From(1, VolumeUnit.ImperialPint);
+            var quantity25 = Volume<double>.From(1, VolumeUnit.ImperialPint);
             AssertEx.EqualTolerance(1, quantity25.ImperialPints, ImperialPintsTolerance);
             Assert.Equal(VolumeUnit.ImperialPint, quantity25.Unit);
 
-            var quantity26 = Volume.From(1, VolumeUnit.KilocubicFoot);
+            var quantity26 = Volume<double>.From(1, VolumeUnit.KilocubicFoot);
             AssertEx.EqualTolerance(1, quantity26.KilocubicFeet, KilocubicFeetTolerance);
             Assert.Equal(VolumeUnit.KilocubicFoot, quantity26.Unit);
 
-            var quantity27 = Volume.From(1, VolumeUnit.KilocubicMeter);
+            var quantity27 = Volume<double>.From(1, VolumeUnit.KilocubicMeter);
             AssertEx.EqualTolerance(1, quantity27.KilocubicMeters, KilocubicMetersTolerance);
             Assert.Equal(VolumeUnit.KilocubicMeter, quantity27.Unit);
 
-            var quantity28 = Volume.From(1, VolumeUnit.KiloimperialGallon);
+            var quantity28 = Volume<double>.From(1, VolumeUnit.KiloimperialGallon);
             AssertEx.EqualTolerance(1, quantity28.KiloimperialGallons, KiloimperialGallonsTolerance);
             Assert.Equal(VolumeUnit.KiloimperialGallon, quantity28.Unit);
 
-            var quantity29 = Volume.From(1, VolumeUnit.Kiloliter);
+            var quantity29 = Volume<double>.From(1, VolumeUnit.Kiloliter);
             AssertEx.EqualTolerance(1, quantity29.Kiloliters, KilolitersTolerance);
             Assert.Equal(VolumeUnit.Kiloliter, quantity29.Unit);
 
-            var quantity30 = Volume.From(1, VolumeUnit.KilousGallon);
+            var quantity30 = Volume<double>.From(1, VolumeUnit.KilousGallon);
             AssertEx.EqualTolerance(1, quantity30.KilousGallons, KilousGallonsTolerance);
             Assert.Equal(VolumeUnit.KilousGallon, quantity30.Unit);
 
-            var quantity31 = Volume.From(1, VolumeUnit.Liter);
+            var quantity31 = Volume<double>.From(1, VolumeUnit.Liter);
             AssertEx.EqualTolerance(1, quantity31.Liters, LitersTolerance);
             Assert.Equal(VolumeUnit.Liter, quantity31.Unit);
 
-            var quantity32 = Volume.From(1, VolumeUnit.MegacubicFoot);
+            var quantity32 = Volume<double>.From(1, VolumeUnit.MegacubicFoot);
             AssertEx.EqualTolerance(1, quantity32.MegacubicFeet, MegacubicFeetTolerance);
             Assert.Equal(VolumeUnit.MegacubicFoot, quantity32.Unit);
 
-            var quantity33 = Volume.From(1, VolumeUnit.MegaimperialGallon);
+            var quantity33 = Volume<double>.From(1, VolumeUnit.MegaimperialGallon);
             AssertEx.EqualTolerance(1, quantity33.MegaimperialGallons, MegaimperialGallonsTolerance);
             Assert.Equal(VolumeUnit.MegaimperialGallon, quantity33.Unit);
 
-            var quantity34 = Volume.From(1, VolumeUnit.Megaliter);
+            var quantity34 = Volume<double>.From(1, VolumeUnit.Megaliter);
             AssertEx.EqualTolerance(1, quantity34.Megaliters, MegalitersTolerance);
             Assert.Equal(VolumeUnit.Megaliter, quantity34.Unit);
 
-            var quantity35 = Volume.From(1, VolumeUnit.MegausGallon);
+            var quantity35 = Volume<double>.From(1, VolumeUnit.MegausGallon);
             AssertEx.EqualTolerance(1, quantity35.MegausGallons, MegausGallonsTolerance);
             Assert.Equal(VolumeUnit.MegausGallon, quantity35.Unit);
 
-            var quantity36 = Volume.From(1, VolumeUnit.MetricCup);
+            var quantity36 = Volume<double>.From(1, VolumeUnit.MetricCup);
             AssertEx.EqualTolerance(1, quantity36.MetricCups, MetricCupsTolerance);
             Assert.Equal(VolumeUnit.MetricCup, quantity36.Unit);
 
-            var quantity37 = Volume.From(1, VolumeUnit.MetricTeaspoon);
+            var quantity37 = Volume<double>.From(1, VolumeUnit.MetricTeaspoon);
             AssertEx.EqualTolerance(1, quantity37.MetricTeaspoons, MetricTeaspoonsTolerance);
             Assert.Equal(VolumeUnit.MetricTeaspoon, quantity37.Unit);
 
-            var quantity38 = Volume.From(1, VolumeUnit.Microliter);
+            var quantity38 = Volume<double>.From(1, VolumeUnit.Microliter);
             AssertEx.EqualTolerance(1, quantity38.Microliters, MicrolitersTolerance);
             Assert.Equal(VolumeUnit.Microliter, quantity38.Unit);
 
-            var quantity39 = Volume.From(1, VolumeUnit.Milliliter);
+            var quantity39 = Volume<double>.From(1, VolumeUnit.Milliliter);
             AssertEx.EqualTolerance(1, quantity39.Milliliters, MillilitersTolerance);
             Assert.Equal(VolumeUnit.Milliliter, quantity39.Unit);
 
-            var quantity40 = Volume.From(1, VolumeUnit.OilBarrel);
+            var quantity40 = Volume<double>.From(1, VolumeUnit.OilBarrel);
             AssertEx.EqualTolerance(1, quantity40.OilBarrels, OilBarrelsTolerance);
             Assert.Equal(VolumeUnit.OilBarrel, quantity40.Unit);
 
-            var quantity41 = Volume.From(1, VolumeUnit.UkTablespoon);
+            var quantity41 = Volume<double>.From(1, VolumeUnit.UkTablespoon);
             AssertEx.EqualTolerance(1, quantity41.UkTablespoons, UkTablespoonsTolerance);
             Assert.Equal(VolumeUnit.UkTablespoon, quantity41.Unit);
 
-            var quantity42 = Volume.From(1, VolumeUnit.UsBeerBarrel);
+            var quantity42 = Volume<double>.From(1, VolumeUnit.UsBeerBarrel);
             AssertEx.EqualTolerance(1, quantity42.UsBeerBarrels, UsBeerBarrelsTolerance);
             Assert.Equal(VolumeUnit.UsBeerBarrel, quantity42.Unit);
 
-            var quantity43 = Volume.From(1, VolumeUnit.UsCustomaryCup);
+            var quantity43 = Volume<double>.From(1, VolumeUnit.UsCustomaryCup);
             AssertEx.EqualTolerance(1, quantity43.UsCustomaryCups, UsCustomaryCupsTolerance);
             Assert.Equal(VolumeUnit.UsCustomaryCup, quantity43.Unit);
 
-            var quantity44 = Volume.From(1, VolumeUnit.UsGallon);
+            var quantity44 = Volume<double>.From(1, VolumeUnit.UsGallon);
             AssertEx.EqualTolerance(1, quantity44.UsGallons, UsGallonsTolerance);
             Assert.Equal(VolumeUnit.UsGallon, quantity44.Unit);
 
-            var quantity45 = Volume.From(1, VolumeUnit.UsLegalCup);
+            var quantity45 = Volume<double>.From(1, VolumeUnit.UsLegalCup);
             AssertEx.EqualTolerance(1, quantity45.UsLegalCups, UsLegalCupsTolerance);
             Assert.Equal(VolumeUnit.UsLegalCup, quantity45.Unit);
 
-            var quantity46 = Volume.From(1, VolumeUnit.UsOunce);
+            var quantity46 = Volume<double>.From(1, VolumeUnit.UsOunce);
             AssertEx.EqualTolerance(1, quantity46.UsOunces, UsOuncesTolerance);
             Assert.Equal(VolumeUnit.UsOunce, quantity46.Unit);
 
-            var quantity47 = Volume.From(1, VolumeUnit.UsPint);
+            var quantity47 = Volume<double>.From(1, VolumeUnit.UsPint);
             AssertEx.EqualTolerance(1, quantity47.UsPints, UsPintsTolerance);
             Assert.Equal(VolumeUnit.UsPint, quantity47.Unit);
 
-            var quantity48 = Volume.From(1, VolumeUnit.UsQuart);
+            var quantity48 = Volume<double>.From(1, VolumeUnit.UsQuart);
             AssertEx.EqualTolerance(1, quantity48.UsQuarts, UsQuartsTolerance);
             Assert.Equal(VolumeUnit.UsQuart, quantity48.Unit);
 
-            var quantity49 = Volume.From(1, VolumeUnit.UsTablespoon);
+            var quantity49 = Volume<double>.From(1, VolumeUnit.UsTablespoon);
             AssertEx.EqualTolerance(1, quantity49.UsTablespoons, UsTablespoonsTolerance);
             Assert.Equal(VolumeUnit.UsTablespoon, quantity49.Unit);
 
-            var quantity50 = Volume.From(1, VolumeUnit.UsTeaspoon);
+            var quantity50 = Volume<double>.From(1, VolumeUnit.UsTeaspoon);
             AssertEx.EqualTolerance(1, quantity50.UsTeaspoons, UsTeaspoonsTolerance);
             Assert.Equal(VolumeUnit.UsTeaspoon, quantity50.Unit);
 
@@ -480,20 +480,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromCubicMeters_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Volume.FromCubicMeters(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => Volume.FromCubicMeters(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => Volume<double>.FromCubicMeters(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => Volume<double>.FromCubicMeters(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromCubicMeters_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Volume.FromCubicMeters(double.NaN));
+            Assert.Throws<ArgumentException>(() => Volume<double>.FromCubicMeters(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var cubicmeter = Volume.FromCubicMeters(1);
+            var cubicmeter = Volume<double>.FromCubicMeters(1);
             AssertEx.EqualTolerance(AcreFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.AcreFoot), AcreFeetTolerance);
             AssertEx.EqualTolerance(AuTablespoonsInOneCubicMeter, cubicmeter.As(VolumeUnit.AuTablespoon), AuTablespoonsTolerance);
             AssertEx.EqualTolerance(BoardFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.BoardFoot), BoardFeetTolerance);
@@ -567,7 +567,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var cubicmeter = Volume.FromCubicMeters(1);
+            var cubicmeter = Volume<double>.FromCubicMeters(1);
 
             var acrefootQuantity = cubicmeter.ToUnit(VolumeUnit.AcreFoot);
             AssertEx.EqualTolerance(AcreFeetInOneCubicMeter, (double)acrefootQuantity.Value, AcreFeetTolerance);
@@ -784,78 +784,78 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
-            AssertEx.EqualTolerance(1, Volume.FromAcreFeet(cubicmeter.AcreFeet).CubicMeters, AcreFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromAuTablespoons(cubicmeter.AuTablespoons).CubicMeters, AuTablespoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromBoardFeet(cubicmeter.BoardFeet).CubicMeters, BoardFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCentiliters(cubicmeter.Centiliters).CubicMeters, CentilitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicCentimeters(cubicmeter.CubicCentimeters).CubicMeters, CubicCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicDecimeters(cubicmeter.CubicDecimeters).CubicMeters, CubicDecimetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicFeet(cubicmeter.CubicFeet).CubicMeters, CubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicHectometers(cubicmeter.CubicHectometers).CubicMeters, CubicHectometersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicInches(cubicmeter.CubicInches).CubicMeters, CubicInchesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicKilometers(cubicmeter.CubicKilometers).CubicMeters, CubicKilometersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMeters(cubicmeter.CubicMeters).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMicrometers(cubicmeter.CubicMicrometers).CubicMeters, CubicMicrometersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMiles(cubicmeter.CubicMiles).CubicMeters, CubicMilesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMillimeters(cubicmeter.CubicMillimeters).CubicMeters, CubicMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicYards(cubicmeter.CubicYards).CubicMeters, CubicYardsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromDecausGallons(cubicmeter.DecausGallons).CubicMeters, DecausGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromDeciliters(cubicmeter.Deciliters).CubicMeters, DecilitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromDeciusGallons(cubicmeter.DeciusGallons).CubicMeters, DeciusGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectocubicFeet(cubicmeter.HectocubicFeet).CubicMeters, HectocubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectocubicMeters(cubicmeter.HectocubicMeters).CubicMeters, HectocubicMetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectoliters(cubicmeter.Hectoliters).CubicMeters, HectolitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectousGallons(cubicmeter.HectousGallons).CubicMeters, HectousGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialBeerBarrels(cubicmeter.ImperialBeerBarrels).CubicMeters, ImperialBeerBarrelsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialGallons(cubicmeter.ImperialGallons).CubicMeters, ImperialGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialOunces(cubicmeter.ImperialOunces).CubicMeters, ImperialOuncesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialPints(cubicmeter.ImperialPints).CubicMeters, ImperialPintsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKilocubicFeet(cubicmeter.KilocubicFeet).CubicMeters, KilocubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKilocubicMeters(cubicmeter.KilocubicMeters).CubicMeters, KilocubicMetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKiloimperialGallons(cubicmeter.KiloimperialGallons).CubicMeters, KiloimperialGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKiloliters(cubicmeter.Kiloliters).CubicMeters, KilolitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKilousGallons(cubicmeter.KilousGallons).CubicMeters, KilousGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromLiters(cubicmeter.Liters).CubicMeters, LitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegacubicFeet(cubicmeter.MegacubicFeet).CubicMeters, MegacubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegaimperialGallons(cubicmeter.MegaimperialGallons).CubicMeters, MegaimperialGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegaliters(cubicmeter.Megaliters).CubicMeters, MegalitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegausGallons(cubicmeter.MegausGallons).CubicMeters, MegausGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMetricCups(cubicmeter.MetricCups).CubicMeters, MetricCupsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMetricTeaspoons(cubicmeter.MetricTeaspoons).CubicMeters, MetricTeaspoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMicroliters(cubicmeter.Microliters).CubicMeters, MicrolitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMilliliters(cubicmeter.Milliliters).CubicMeters, MillilitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromOilBarrels(cubicmeter.OilBarrels).CubicMeters, OilBarrelsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUkTablespoons(cubicmeter.UkTablespoons).CubicMeters, UkTablespoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsBeerBarrels(cubicmeter.UsBeerBarrels).CubicMeters, UsBeerBarrelsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsCustomaryCups(cubicmeter.UsCustomaryCups).CubicMeters, UsCustomaryCupsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsGallons(cubicmeter.UsGallons).CubicMeters, UsGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsLegalCups(cubicmeter.UsLegalCups).CubicMeters, UsLegalCupsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsOunces(cubicmeter.UsOunces).CubicMeters, UsOuncesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsPints(cubicmeter.UsPints).CubicMeters, UsPintsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsQuarts(cubicmeter.UsQuarts).CubicMeters, UsQuartsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsTablespoons(cubicmeter.UsTablespoons).CubicMeters, UsTablespoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsTeaspoons(cubicmeter.UsTeaspoons).CubicMeters, UsTeaspoonsTolerance);
+            Volume<double> cubicmeter = Volume<double>.FromCubicMeters(1);
+            AssertEx.EqualTolerance(1, Volume<double>.FromAcreFeet(cubicmeter.AcreFeet).CubicMeters, AcreFeetTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromAuTablespoons(cubicmeter.AuTablespoons).CubicMeters, AuTablespoonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromBoardFeet(cubicmeter.BoardFeet).CubicMeters, BoardFeetTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCentiliters(cubicmeter.Centiliters).CubicMeters, CentilitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicCentimeters(cubicmeter.CubicCentimeters).CubicMeters, CubicCentimetersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicDecimeters(cubicmeter.CubicDecimeters).CubicMeters, CubicDecimetersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicFeet(cubicmeter.CubicFeet).CubicMeters, CubicFeetTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicHectometers(cubicmeter.CubicHectometers).CubicMeters, CubicHectometersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicInches(cubicmeter.CubicInches).CubicMeters, CubicInchesTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicKilometers(cubicmeter.CubicKilometers).CubicMeters, CubicKilometersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicMeters(cubicmeter.CubicMeters).CubicMeters, CubicMetersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicMicrometers(cubicmeter.CubicMicrometers).CubicMeters, CubicMicrometersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicMiles(cubicmeter.CubicMiles).CubicMeters, CubicMilesTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicMillimeters(cubicmeter.CubicMillimeters).CubicMeters, CubicMillimetersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromCubicYards(cubicmeter.CubicYards).CubicMeters, CubicYardsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromDecausGallons(cubicmeter.DecausGallons).CubicMeters, DecausGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromDeciliters(cubicmeter.Deciliters).CubicMeters, DecilitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromDeciusGallons(cubicmeter.DeciusGallons).CubicMeters, DeciusGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromHectocubicFeet(cubicmeter.HectocubicFeet).CubicMeters, HectocubicFeetTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromHectocubicMeters(cubicmeter.HectocubicMeters).CubicMeters, HectocubicMetersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromHectoliters(cubicmeter.Hectoliters).CubicMeters, HectolitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromHectousGallons(cubicmeter.HectousGallons).CubicMeters, HectousGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromImperialBeerBarrels(cubicmeter.ImperialBeerBarrels).CubicMeters, ImperialBeerBarrelsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromImperialGallons(cubicmeter.ImperialGallons).CubicMeters, ImperialGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromImperialOunces(cubicmeter.ImperialOunces).CubicMeters, ImperialOuncesTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromImperialPints(cubicmeter.ImperialPints).CubicMeters, ImperialPintsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromKilocubicFeet(cubicmeter.KilocubicFeet).CubicMeters, KilocubicFeetTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromKilocubicMeters(cubicmeter.KilocubicMeters).CubicMeters, KilocubicMetersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromKiloimperialGallons(cubicmeter.KiloimperialGallons).CubicMeters, KiloimperialGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromKiloliters(cubicmeter.Kiloliters).CubicMeters, KilolitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromKilousGallons(cubicmeter.KilousGallons).CubicMeters, KilousGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromLiters(cubicmeter.Liters).CubicMeters, LitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMegacubicFeet(cubicmeter.MegacubicFeet).CubicMeters, MegacubicFeetTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMegaimperialGallons(cubicmeter.MegaimperialGallons).CubicMeters, MegaimperialGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMegaliters(cubicmeter.Megaliters).CubicMeters, MegalitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMegausGallons(cubicmeter.MegausGallons).CubicMeters, MegausGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMetricCups(cubicmeter.MetricCups).CubicMeters, MetricCupsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMetricTeaspoons(cubicmeter.MetricTeaspoons).CubicMeters, MetricTeaspoonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMicroliters(cubicmeter.Microliters).CubicMeters, MicrolitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromMilliliters(cubicmeter.Milliliters).CubicMeters, MillilitersTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromOilBarrels(cubicmeter.OilBarrels).CubicMeters, OilBarrelsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUkTablespoons(cubicmeter.UkTablespoons).CubicMeters, UkTablespoonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsBeerBarrels(cubicmeter.UsBeerBarrels).CubicMeters, UsBeerBarrelsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsCustomaryCups(cubicmeter.UsCustomaryCups).CubicMeters, UsCustomaryCupsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsGallons(cubicmeter.UsGallons).CubicMeters, UsGallonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsLegalCups(cubicmeter.UsLegalCups).CubicMeters, UsLegalCupsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsOunces(cubicmeter.UsOunces).CubicMeters, UsOuncesTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsPints(cubicmeter.UsPints).CubicMeters, UsPintsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsQuarts(cubicmeter.UsQuarts).CubicMeters, UsQuartsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsTablespoons(cubicmeter.UsTablespoons).CubicMeters, UsTablespoonsTolerance);
+            AssertEx.EqualTolerance(1, Volume<double>.FromUsTeaspoons(cubicmeter.UsTeaspoons).CubicMeters, UsTeaspoonsTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Volume v = Volume.FromCubicMeters(1);
+            Volume<double> v = Volume<double>.FromCubicMeters(1);
             AssertEx.EqualTolerance(-1, -v.CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(2, (Volume.FromCubicMeters(3)-v).CubicMeters, CubicMetersTolerance);
+            AssertEx.EqualTolerance(2, (Volume<double>.FromCubicMeters(3)-v).CubicMeters, CubicMetersTolerance);
             AssertEx.EqualTolerance(2, (v + v).CubicMeters, CubicMetersTolerance);
             AssertEx.EqualTolerance(10, (v*10).CubicMeters, CubicMetersTolerance);
             AssertEx.EqualTolerance(10, (10*v).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(2, (Volume.FromCubicMeters(10)/5).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(2, Volume.FromCubicMeters(10)/Volume.FromCubicMeters(5), CubicMetersTolerance);
+            AssertEx.EqualTolerance(2, (Volume<double>.FromCubicMeters(10)/5).CubicMeters, CubicMetersTolerance);
+            AssertEx.EqualTolerance(2, Volume<double>.FromCubicMeters(10)/Volume<double>.FromCubicMeters(5), CubicMetersTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Volume oneCubicMeter = Volume.FromCubicMeters(1);
-            Volume twoCubicMeters = Volume.FromCubicMeters(2);
+            Volume<double> oneCubicMeter = Volume<double>.FromCubicMeters(1);
+            Volume<double> twoCubicMeters = Volume<double>.FromCubicMeters(2);
 
             Assert.True(oneCubicMeter < twoCubicMeters);
             Assert.True(oneCubicMeter <= twoCubicMeters);
@@ -871,31 +871,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
+            Volume<double> cubicmeter = Volume<double>.FromCubicMeters(1);
             Assert.Equal(0, cubicmeter.CompareTo(cubicmeter));
-            Assert.True(cubicmeter.CompareTo(Volume.Zero) > 0);
-            Assert.True(Volume.Zero.CompareTo(cubicmeter) < 0);
+            Assert.True(cubicmeter.CompareTo(Volume<double>.Zero) > 0);
+            Assert.True(Volume<double>.Zero.CompareTo(cubicmeter) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
+            Volume<double> cubicmeter = Volume<double>.FromCubicMeters(1);
             Assert.Throws<ArgumentException>(() => cubicmeter.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
+            Volume<double> cubicmeter = Volume<double>.FromCubicMeters(1);
             Assert.Throws<ArgumentNullException>(() => cubicmeter.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = Volume.FromCubicMeters(1);
-            var b = Volume.FromCubicMeters(2);
+            var a = Volume<double>.FromCubicMeters(1);
+            var b = Volume<double>.FromCubicMeters(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -914,8 +914,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = Volume.FromCubicMeters(1);
-            var b = Volume.FromCubicMeters(2);
+            var a = Volume<double>.FromCubicMeters(1);
+            var b = Volume<double>.FromCubicMeters(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -935,9 +935,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = Volume.FromCubicMeters(1);
-            Assert.True(v.Equals(Volume.FromCubicMeters(1), CubicMetersTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(Volume.Zero, CubicMetersTolerance, ComparisonType.Relative));
+            var v = Volume<double>.FromCubicMeters(1);
+            Assert.True(v.Equals(Volume<double>.FromCubicMeters(1), CubicMetersTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(Volume<double>.Zero, CubicMetersTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -950,21 +950,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
+            Volume<double> cubicmeter = Volume<double>.FromCubicMeters(1);
             Assert.False(cubicmeter.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
+            Volume<double> cubicmeter = Volume<double>.FromCubicMeters(1);
             Assert.False(cubicmeter.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(VolumeUnit.Undefined, Volume.Units);
+            Assert.DoesNotContain(VolumeUnit.Undefined, Volume<double>.Units);
         }
 
         [Fact]
@@ -983,7 +983,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(Volume.BaseDimensions is null);
+            Assert.False(Volume<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs
index 8f2f874b69..b379b58a2b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs
@@ -56,7 +56,7 @@ public abstract partial class WarpingMomentOfInertiaTestsBase : QuantityTestsBas
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia((double)0.0, WarpingMomentOfInertiaUnit.Undefined));
+            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia<double>((double)0.0, WarpingMomentOfInertiaUnit.Undefined));
         }
 
         [Fact]
@@ -71,14 +71,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia(double.PositiveInfinity, WarpingMomentOfInertiaUnit.MeterToTheSixth));
-            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia(double.NegativeInfinity, WarpingMomentOfInertiaUnit.MeterToTheSixth));
+            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia<double>(double.PositiveInfinity, WarpingMomentOfInertiaUnit.MeterToTheSixth));
+            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia<double>(double.NegativeInfinity, WarpingMomentOfInertiaUnit.MeterToTheSixth));
         }
 
         [Fact]
         public void Ctor_WithNaNValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia(double.NaN, WarpingMomentOfInertiaUnit.MeterToTheSixth));
+            Assert.Throws<ArgumentException>(() => new WarpingMomentOfInertia<double>(double.NaN, WarpingMomentOfInertiaUnit.MeterToTheSixth));
         }
 
         [Fact]
@@ -124,7 +124,7 @@ public void WarpingMomentOfInertia_QuantityInfo_ReturnsQuantityInfoDescribingQua
         [Fact]
         public void MeterToTheSixthToWarpingMomentOfInertiaUnits()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             AssertEx.EqualTolerance(CentimetersToTheSixthInOneMeterToTheSixth, metertothesixth.CentimetersToTheSixth, CentimetersToTheSixthTolerance);
             AssertEx.EqualTolerance(DecimetersToTheSixthInOneMeterToTheSixth, metertothesixth.DecimetersToTheSixth, DecimetersToTheSixthTolerance);
             AssertEx.EqualTolerance(FeetToTheSixthInOneMeterToTheSixth, metertothesixth.FeetToTheSixth, FeetToTheSixthTolerance);
@@ -136,27 +136,27 @@ public void MeterToTheSixthToWarpingMomentOfInertiaUnits()
         [Fact]
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {
-            var quantity00 = WarpingMomentOfInertia.From(1, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
+            var quantity00 = WarpingMomentOfInertia<double>.From(1, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
             AssertEx.EqualTolerance(1, quantity00.CentimetersToTheSixth, CentimetersToTheSixthTolerance);
             Assert.Equal(WarpingMomentOfInertiaUnit.CentimeterToTheSixth, quantity00.Unit);
 
-            var quantity01 = WarpingMomentOfInertia.From(1, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
+            var quantity01 = WarpingMomentOfInertia<double>.From(1, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
             AssertEx.EqualTolerance(1, quantity01.DecimetersToTheSixth, DecimetersToTheSixthTolerance);
             Assert.Equal(WarpingMomentOfInertiaUnit.DecimeterToTheSixth, quantity01.Unit);
 
-            var quantity02 = WarpingMomentOfInertia.From(1, WarpingMomentOfInertiaUnit.FootToTheSixth);
+            var quantity02 = WarpingMomentOfInertia<double>.From(1, WarpingMomentOfInertiaUnit.FootToTheSixth);
             AssertEx.EqualTolerance(1, quantity02.FeetToTheSixth, FeetToTheSixthTolerance);
             Assert.Equal(WarpingMomentOfInertiaUnit.FootToTheSixth, quantity02.Unit);
 
-            var quantity03 = WarpingMomentOfInertia.From(1, WarpingMomentOfInertiaUnit.InchToTheSixth);
+            var quantity03 = WarpingMomentOfInertia<double>.From(1, WarpingMomentOfInertiaUnit.InchToTheSixth);
             AssertEx.EqualTolerance(1, quantity03.InchesToTheSixth, InchesToTheSixthTolerance);
             Assert.Equal(WarpingMomentOfInertiaUnit.InchToTheSixth, quantity03.Unit);
 
-            var quantity04 = WarpingMomentOfInertia.From(1, WarpingMomentOfInertiaUnit.MeterToTheSixth);
+            var quantity04 = WarpingMomentOfInertia<double>.From(1, WarpingMomentOfInertiaUnit.MeterToTheSixth);
             AssertEx.EqualTolerance(1, quantity04.MetersToTheSixth, MetersToTheSixthTolerance);
             Assert.Equal(WarpingMomentOfInertiaUnit.MeterToTheSixth, quantity04.Unit);
 
-            var quantity05 = WarpingMomentOfInertia.From(1, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
+            var quantity05 = WarpingMomentOfInertia<double>.From(1, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
             AssertEx.EqualTolerance(1, quantity05.MillimetersToTheSixth, MillimetersToTheSixthTolerance);
             Assert.Equal(WarpingMomentOfInertiaUnit.MillimeterToTheSixth, quantity05.Unit);
 
@@ -165,20 +165,20 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         [Fact]
         public void FromMetersToTheSixth_WithInfinityValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => WarpingMomentOfInertia.FromMetersToTheSixth(double.PositiveInfinity));
-            Assert.Throws<ArgumentException>(() => WarpingMomentOfInertia.FromMetersToTheSixth(double.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => WarpingMomentOfInertia<double>.FromMetersToTheSixth(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => WarpingMomentOfInertia<double>.FromMetersToTheSixth(double.NegativeInfinity));
         }
 
         [Fact]
         public void FromMetersToTheSixth_WithNanValue_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => WarpingMomentOfInertia.FromMetersToTheSixth(double.NaN));
+            Assert.Throws<ArgumentException>(() => WarpingMomentOfInertia<double>.FromMetersToTheSixth(double.NaN));
         }
 
         [Fact]
         public void As()
         {
-            var metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            var metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             AssertEx.EqualTolerance(CentimetersToTheSixthInOneMeterToTheSixth, metertothesixth.As(WarpingMomentOfInertiaUnit.CentimeterToTheSixth), CentimetersToTheSixthTolerance);
             AssertEx.EqualTolerance(DecimetersToTheSixthInOneMeterToTheSixth, metertothesixth.As(WarpingMomentOfInertiaUnit.DecimeterToTheSixth), DecimetersToTheSixthTolerance);
             AssertEx.EqualTolerance(FeetToTheSixthInOneMeterToTheSixth, metertothesixth.As(WarpingMomentOfInertiaUnit.FootToTheSixth), FeetToTheSixthTolerance);
@@ -207,7 +207,7 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [Fact]
         public void ToUnit()
         {
-            var metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            var metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
 
             var centimetertothesixthQuantity = metertothesixth.ToUnit(WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
             AssertEx.EqualTolerance(CentimetersToTheSixthInOneMeterToTheSixth, (double)centimetertothesixthQuantity.Value, CentimetersToTheSixthTolerance);
@@ -244,33 +244,33 @@ public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
         [Fact]
         public void ConversionRoundTrip()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromCentimetersToTheSixth(metertothesixth.CentimetersToTheSixth).MetersToTheSixth, CentimetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromDecimetersToTheSixth(metertothesixth.DecimetersToTheSixth).MetersToTheSixth, DecimetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromFeetToTheSixth(metertothesixth.FeetToTheSixth).MetersToTheSixth, FeetToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromInchesToTheSixth(metertothesixth.InchesToTheSixth).MetersToTheSixth, InchesToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromMetersToTheSixth(metertothesixth.MetersToTheSixth).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromMillimetersToTheSixth(metertothesixth.MillimetersToTheSixth).MetersToTheSixth, MillimetersToTheSixthTolerance);
+            WarpingMomentOfInertia<double> metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
+            AssertEx.EqualTolerance(1, WarpingMomentOfInertia<double>.FromCentimetersToTheSixth(metertothesixth.CentimetersToTheSixth).MetersToTheSixth, CentimetersToTheSixthTolerance);
+            AssertEx.EqualTolerance(1, WarpingMomentOfInertia<double>.FromDecimetersToTheSixth(metertothesixth.DecimetersToTheSixth).MetersToTheSixth, DecimetersToTheSixthTolerance);
+            AssertEx.EqualTolerance(1, WarpingMomentOfInertia<double>.FromFeetToTheSixth(metertothesixth.FeetToTheSixth).MetersToTheSixth, FeetToTheSixthTolerance);
+            AssertEx.EqualTolerance(1, WarpingMomentOfInertia<double>.FromInchesToTheSixth(metertothesixth.InchesToTheSixth).MetersToTheSixth, InchesToTheSixthTolerance);
+            AssertEx.EqualTolerance(1, WarpingMomentOfInertia<double>.FromMetersToTheSixth(metertothesixth.MetersToTheSixth).MetersToTheSixth, MetersToTheSixthTolerance);
+            AssertEx.EqualTolerance(1, WarpingMomentOfInertia<double>.FromMillimetersToTheSixth(metertothesixth.MillimetersToTheSixth).MetersToTheSixth, MillimetersToTheSixthTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            WarpingMomentOfInertia v = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> v = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             AssertEx.EqualTolerance(-1, -v.MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(2, (WarpingMomentOfInertia.FromMetersToTheSixth(3)-v).MetersToTheSixth, MetersToTheSixthTolerance);
+            AssertEx.EqualTolerance(2, (WarpingMomentOfInertia<double>.FromMetersToTheSixth(3)-v).MetersToTheSixth, MetersToTheSixthTolerance);
             AssertEx.EqualTolerance(2, (v + v).MetersToTheSixth, MetersToTheSixthTolerance);
             AssertEx.EqualTolerance(10, (v*10).MetersToTheSixth, MetersToTheSixthTolerance);
             AssertEx.EqualTolerance(10, (10*v).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(2, (WarpingMomentOfInertia.FromMetersToTheSixth(10)/5).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(2, WarpingMomentOfInertia.FromMetersToTheSixth(10)/WarpingMomentOfInertia.FromMetersToTheSixth(5), MetersToTheSixthTolerance);
+            AssertEx.EqualTolerance(2, (WarpingMomentOfInertia<double>.FromMetersToTheSixth(10)/5).MetersToTheSixth, MetersToTheSixthTolerance);
+            AssertEx.EqualTolerance(2, WarpingMomentOfInertia<double>.FromMetersToTheSixth(10)/WarpingMomentOfInertia<double>.FromMetersToTheSixth(5), MetersToTheSixthTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            WarpingMomentOfInertia oneMeterToTheSixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
-            WarpingMomentOfInertia twoMetersToTheSixth = WarpingMomentOfInertia.FromMetersToTheSixth(2);
+            WarpingMomentOfInertia<double> oneMeterToTheSixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> twoMetersToTheSixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(2);
 
             Assert.True(oneMeterToTheSixth < twoMetersToTheSixth);
             Assert.True(oneMeterToTheSixth <= twoMetersToTheSixth);
@@ -286,31 +286,31 @@ public void ComparisonOperators()
         [Fact]
         public void CompareToIsImplemented()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             Assert.Equal(0, metertothesixth.CompareTo(metertothesixth));
-            Assert.True(metertothesixth.CompareTo(WarpingMomentOfInertia.Zero) > 0);
-            Assert.True(WarpingMomentOfInertia.Zero.CompareTo(metertothesixth) < 0);
+            Assert.True(metertothesixth.CompareTo(WarpingMomentOfInertia<double>.Zero) > 0);
+            Assert.True(WarpingMomentOfInertia<double>.Zero.CompareTo(metertothesixth) < 0);
         }
 
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             Assert.Throws<ArgumentException>(() => metertothesixth.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             Assert.Throws<ArgumentNullException>(() => metertothesixth.CompareTo(null));
         }
 
         [Fact]
         public void EqualityOperators()
         {
-            var a = WarpingMomentOfInertia.FromMetersToTheSixth(1);
-            var b = WarpingMomentOfInertia.FromMetersToTheSixth(2);
+            var a = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
+            var b = WarpingMomentOfInertia<double>.FromMetersToTheSixth(2);
 
  // ReSharper disable EqualExpressionComparison
 
@@ -329,8 +329,8 @@ public void EqualityOperators()
         [Fact]
         public void Equals_SameType_IsImplemented()
         {
-            var a = WarpingMomentOfInertia.FromMetersToTheSixth(1);
-            var b = WarpingMomentOfInertia.FromMetersToTheSixth(2);
+            var a = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
+            var b = WarpingMomentOfInertia<double>.FromMetersToTheSixth(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
@@ -350,9 +350,9 @@ public void Equals_QuantityAsObject_IsImplemented()
         [Fact]
         public void Equals_RelativeTolerance_IsImplemented()
         {
-            var v = WarpingMomentOfInertia.FromMetersToTheSixth(1);
-            Assert.True(v.Equals(WarpingMomentOfInertia.FromMetersToTheSixth(1), MetersToTheSixthTolerance, ComparisonType.Relative));
-            Assert.False(v.Equals(WarpingMomentOfInertia.Zero, MetersToTheSixthTolerance, ComparisonType.Relative));
+            var v = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
+            Assert.True(v.Equals(WarpingMomentOfInertia<double>.FromMetersToTheSixth(1), MetersToTheSixthTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(WarpingMomentOfInertia<double>.Zero, MetersToTheSixthTolerance, ComparisonType.Relative));
         }
 
         [Fact]
@@ -365,21 +365,21 @@ public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             Assert.False(metertothesixth.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
+            WarpingMomentOfInertia<double> metertothesixth = WarpingMomentOfInertia<double>.FromMetersToTheSixth(1);
             Assert.False(metertothesixth.Equals(null));
         }
 
         [Fact]
         public void UnitsDoesNotContainUndefined()
         {
-            Assert.DoesNotContain(WarpingMomentOfInertiaUnit.Undefined, WarpingMomentOfInertia.Units);
+            Assert.DoesNotContain(WarpingMomentOfInertiaUnit.Undefined, WarpingMomentOfInertia<double>.Units);
         }
 
         [Fact]
@@ -398,7 +398,7 @@ public void HasAtLeastOneAbbreviationSpecified()
         [Fact]
         public void BaseDimensionsShouldNeverBeNull()
         {
-            Assert.False(WarpingMomentOfInertia.BaseDimensions is null);
+            Assert.False(WarpingMomentOfInertia<double>.BaseDimensions is null);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ThermalConductivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ThermalConductivityTestsBase.g.cs
new file mode 100644
index 0000000000..7913a5c81c
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ThermalConductivityTestsBase.g.cs
@@ -0,0 +1,253 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ThermalConductivity.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ThermalConductivityTestsBase
+    {
+        protected abstract double BtusPerHourFootFahrenheitInOneWattPerMeterKelvin { get; }
+        protected abstract double WattsPerMeterKelvinInOneWattPerMeterKelvin { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double BtusPerHourFootFahrenheitTolerance { get { return 1e-5; } }
+        protected virtual double WattsPerMeterKelvinTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>((double)0.0, ThermalConductivityUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>(double.PositiveInfinity, ThermalConductivityUnit.WattPerMeterKelvin));
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>(double.NegativeInfinity, ThermalConductivityUnit.WattPerMeterKelvin));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ThermalConductivity<double>(double.NaN, ThermalConductivityUnit.WattPerMeterKelvin));
+        }
+
+        [Fact]
+        public void WattPerMeterKelvinToThermalConductivityUnits()
+        {
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.BtusPerHourFootFahrenheit, BtusPerHourFootFahrenheitTolerance);
+            AssertEx.EqualTolerance(WattsPerMeterKelvinInOneWattPerMeterKelvin, wattpermeterkelvin.WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ThermalConductivity<double>.From(1, ThermalConductivityUnit.BtuPerHourFootFahrenheit).BtusPerHourFootFahrenheit, BtusPerHourFootFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, ThermalConductivity<double>.From(1, ThermalConductivityUnit.WattPerMeterKelvin).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void FromWattsPerMeterKelvin_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ThermalConductivity<double>.FromWattsPerMeterKelvin(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ThermalConductivity<double>.FromWattsPerMeterKelvin(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromWattsPerMeterKelvin_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ThermalConductivity<double>.FromWattsPerMeterKelvin(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.As(ThermalConductivityUnit.BtuPerHourFootFahrenheit), BtusPerHourFootFahrenheitTolerance);
+            AssertEx.EqualTolerance(WattsPerMeterKelvinInOneWattPerMeterKelvin, wattpermeterkelvin.As(ThermalConductivityUnit.WattPerMeterKelvin), WattsPerMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+
+            var btuperhourfootfahrenheitQuantity = wattpermeterkelvin.ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit);
+            AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, (double)btuperhourfootfahrenheitQuantity.Value, BtusPerHourFootFahrenheitTolerance);
+            Assert.Equal(ThermalConductivityUnit.BtuPerHourFootFahrenheit, btuperhourfootfahrenheitQuantity.Unit);
+
+            var wattpermeterkelvinQuantity = wattpermeterkelvin.ToUnit(ThermalConductivityUnit.WattPerMeterKelvin);
+            AssertEx.EqualTolerance(WattsPerMeterKelvinInOneWattPerMeterKelvin, (double)wattpermeterkelvinQuantity.Value, WattsPerMeterKelvinTolerance);
+            Assert.Equal(ThermalConductivityUnit.WattPerMeterKelvin, wattpermeterkelvinQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            AssertEx.EqualTolerance(1, ThermalConductivity<double>.FromBtusPerHourFootFahrenheit(wattpermeterkelvin.BtusPerHourFootFahrenheit).WattsPerMeterKelvin, BtusPerHourFootFahrenheitTolerance);
+            AssertEx.EqualTolerance(1, ThermalConductivity<double>.FromWattsPerMeterKelvin(wattpermeterkelvin.WattsPerMeterKelvin).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ThermalConductivity<double> v = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            AssertEx.EqualTolerance(-1, -v.WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (ThermalConductivity<double>.FromWattsPerMeterKelvin(3)-v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (v + v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(10, (v*10).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(10, (10*v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, (ThermalConductivity<double>.FromWattsPerMeterKelvin(10)/5).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            AssertEx.EqualTolerance(2, ThermalConductivity<double>.FromWattsPerMeterKelvin(10)/ThermalConductivity<double>.FromWattsPerMeterKelvin(5), WattsPerMeterKelvinTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ThermalConductivity<double> oneWattPerMeterKelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            ThermalConductivity<double> twoWattsPerMeterKelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(2);
+
+            Assert.True(oneWattPerMeterKelvin < twoWattsPerMeterKelvin);
+            Assert.True(oneWattPerMeterKelvin <= twoWattsPerMeterKelvin);
+            Assert.True(twoWattsPerMeterKelvin > oneWattPerMeterKelvin);
+            Assert.True(twoWattsPerMeterKelvin >= oneWattPerMeterKelvin);
+
+            Assert.False(oneWattPerMeterKelvin > twoWattsPerMeterKelvin);
+            Assert.False(oneWattPerMeterKelvin >= twoWattsPerMeterKelvin);
+            Assert.False(twoWattsPerMeterKelvin < oneWattPerMeterKelvin);
+            Assert.False(twoWattsPerMeterKelvin <= oneWattPerMeterKelvin);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            Assert.Equal(0, wattpermeterkelvin.CompareTo(wattpermeterkelvin));
+            Assert.True(wattpermeterkelvin.CompareTo(ThermalConductivity<double>.Zero) > 0);
+            Assert.True(ThermalConductivity<double>.Zero.CompareTo(wattpermeterkelvin) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            Assert.Throws<ArgumentException>(() => wattpermeterkelvin.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            Assert.Throws<ArgumentNullException>(() => wattpermeterkelvin.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            var b = ThermalConductivity<double>.FromWattsPerMeterKelvin(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            var b = ThermalConductivity<double>.FromWattsPerMeterKelvin(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            Assert.True(v.Equals(ThermalConductivity<double>.FromWattsPerMeterKelvin(1), WattsPerMeterKelvinTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ThermalConductivity<double>.Zero, WattsPerMeterKelvinTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            Assert.False(wattpermeterkelvin.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ThermalConductivity<double> wattpermeterkelvin = ThermalConductivity<double>.FromWattsPerMeterKelvin(1);
+            Assert.False(wattpermeterkelvin.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ThermalConductivityUnit.Undefined, ThermalConductivity<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ThermalConductivityUnit)).Cast<ThermalConductivityUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ThermalConductivityUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ThermalConductivity<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/ThermalResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ThermalResistanceTestsBase.g.cs
new file mode 100644
index 0000000000..0a4472745c
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/ThermalResistanceTestsBase.g.cs
@@ -0,0 +1,283 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of ThermalResistance.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class ThermalResistanceTestsBase
+    {
+        protected abstract double HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerKilowatt { get; }
+        protected abstract double SquareCentimeterHourDegreesCelsiusPerKilocalorieInOneSquareMeterKelvinPerKilowatt { get; }
+        protected abstract double SquareCentimeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt { get; }
+        protected abstract double SquareMeterDegreesCelsiusPerWattInOneSquareMeterKelvinPerKilowatt { get; }
+        protected abstract double SquareMeterKelvinsPerKilowattInOneSquareMeterKelvinPerKilowatt { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double HourSquareFeetDegreesFahrenheitPerBtuTolerance { get { return 1e-5; } }
+        protected virtual double SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance { get { return 1e-5; } }
+        protected virtual double SquareCentimeterKelvinsPerWattTolerance { get { return 1e-5; } }
+        protected virtual double SquareMeterDegreesCelsiusPerWattTolerance { get { return 1e-5; } }
+        protected virtual double SquareMeterKelvinsPerKilowattTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>((double)0.0, ThermalResistanceUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>(double.PositiveInfinity, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>(double.NegativeInfinity, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new ThermalResistance<double>(double.NaN, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt));
+        }
+
+        [Fact]
+        public void SquareMeterKelvinPerKilowattToThermalResistanceUnits()
+        {
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            AssertEx.EqualTolerance(HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.HourSquareFeetDegreesFahrenheitPerBtu, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
+            AssertEx.EqualTolerance(SquareCentimeterHourDegreesCelsiusPerKilocalorieInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.SquareCentimeterHourDegreesCelsiusPerKilocalorie, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
+            AssertEx.EqualTolerance(SquareCentimeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.SquareCentimeterKelvinsPerWatt, SquareCentimeterKelvinsPerWattTolerance);
+            AssertEx.EqualTolerance(SquareMeterDegreesCelsiusPerWattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.SquareMeterDegreesCelsiusPerWatt, SquareMeterDegreesCelsiusPerWattTolerance);
+            AssertEx.EqualTolerance(SquareMeterKelvinsPerKilowattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.From(1, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu).HourSquareFeetDegreesFahrenheitPerBtu, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie).SquareCentimeterHourDegreesCelsiusPerKilocalorie, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt).SquareCentimeterKelvinsPerWatt, SquareCentimeterKelvinsPerWattTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt).SquareMeterDegreesCelsiusPerWatt, SquareMeterDegreesCelsiusPerWattTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.From(1, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+        }
+
+        [Fact]
+        public void FromSquareMeterKelvinsPerKilowatt_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromSquareMeterKelvinsPerKilowatt_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            AssertEx.EqualTolerance(HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu), HourSquareFeetDegreesFahrenheitPerBtuTolerance);
+            AssertEx.EqualTolerance(SquareCentimeterHourDegreesCelsiusPerKilocalorieInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie), SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
+            AssertEx.EqualTolerance(SquareCentimeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt), SquareCentimeterKelvinsPerWattTolerance);
+            AssertEx.EqualTolerance(SquareMeterDegreesCelsiusPerWattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt), SquareMeterDegreesCelsiusPerWattTolerance);
+            AssertEx.EqualTolerance(SquareMeterKelvinsPerKilowattInOneSquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowatt.As(ThermalResistanceUnit.SquareMeterKelvinPerKilowatt), SquareMeterKelvinsPerKilowattTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+
+            var hoursquarefeetdegreefahrenheitperbtuQuantity = squaremeterkelvinperkilowatt.ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
+            AssertEx.EqualTolerance(HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerKilowatt, (double)hoursquarefeetdegreefahrenheitperbtuQuantity.Value, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
+            Assert.Equal(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, hoursquarefeetdegreefahrenheitperbtuQuantity.Unit);
+
+            var squarecentimeterhourdegreecelsiusperkilocalorieQuantity = squaremeterkelvinperkilowatt.ToUnit(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
+            AssertEx.EqualTolerance(SquareCentimeterHourDegreesCelsiusPerKilocalorieInOneSquareMeterKelvinPerKilowatt, (double)squarecentimeterhourdegreecelsiusperkilocalorieQuantity.Value, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
+            Assert.Equal(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, squarecentimeterhourdegreecelsiusperkilocalorieQuantity.Unit);
+
+            var squarecentimeterkelvinperwattQuantity = squaremeterkelvinperkilowatt.ToUnit(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
+            AssertEx.EqualTolerance(SquareCentimeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt, (double)squarecentimeterkelvinperwattQuantity.Value, SquareCentimeterKelvinsPerWattTolerance);
+            Assert.Equal(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, squarecentimeterkelvinperwattQuantity.Unit);
+
+            var squaremeterdegreecelsiusperwattQuantity = squaremeterkelvinperkilowatt.ToUnit(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
+            AssertEx.EqualTolerance(SquareMeterDegreesCelsiusPerWattInOneSquareMeterKelvinPerKilowatt, (double)squaremeterdegreecelsiusperwattQuantity.Value, SquareMeterDegreesCelsiusPerWattTolerance);
+            Assert.Equal(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, squaremeterdegreecelsiusperwattQuantity.Unit);
+
+            var squaremeterkelvinperkilowattQuantity = squaremeterkelvinperkilowatt.ToUnit(ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
+            AssertEx.EqualTolerance(SquareMeterKelvinsPerKilowattInOneSquareMeterKelvinPerKilowatt, (double)squaremeterkelvinperkilowattQuantity.Value, SquareMeterKelvinsPerKilowattTolerance);
+            Assert.Equal(ThermalResistanceUnit.SquareMeterKelvinPerKilowatt, squaremeterkelvinperkilowattQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromHourSquareFeetDegreesFahrenheitPerBtu(squaremeterkelvinperkilowatt.HourSquareFeetDegreesFahrenheitPerBtu).SquareMeterKelvinsPerKilowatt, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(squaremeterkelvinperkilowatt.SquareCentimeterHourDegreesCelsiusPerKilocalorie).SquareMeterKelvinsPerKilowatt, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareCentimeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareCentimeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt, SquareCentimeterKelvinsPerWattTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareMeterDegreesCelsiusPerWatt(squaremeterkelvinperkilowatt.SquareMeterDegreesCelsiusPerWatt).SquareMeterKelvinsPerKilowatt, SquareMeterDegreesCelsiusPerWattTolerance);
+            AssertEx.EqualTolerance(1, ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(squaremeterkelvinperkilowatt.SquareMeterKelvinsPerKilowatt).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            ThermalResistance<double> v = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            AssertEx.EqualTolerance(-1, -v.SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(2, (ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(3)-v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(2, (v + v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(10, (v*10).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(10, (10*v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(2, (ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(10)/5).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
+            AssertEx.EqualTolerance(2, ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(10)/ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(5), SquareMeterKelvinsPerKilowattTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            ThermalResistance<double> oneSquareMeterKelvinPerKilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            ThermalResistance<double> twoSquareMeterKelvinsPerKilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(2);
+
+            Assert.True(oneSquareMeterKelvinPerKilowatt < twoSquareMeterKelvinsPerKilowatt);
+            Assert.True(oneSquareMeterKelvinPerKilowatt <= twoSquareMeterKelvinsPerKilowatt);
+            Assert.True(twoSquareMeterKelvinsPerKilowatt > oneSquareMeterKelvinPerKilowatt);
+            Assert.True(twoSquareMeterKelvinsPerKilowatt >= oneSquareMeterKelvinPerKilowatt);
+
+            Assert.False(oneSquareMeterKelvinPerKilowatt > twoSquareMeterKelvinsPerKilowatt);
+            Assert.False(oneSquareMeterKelvinPerKilowatt >= twoSquareMeterKelvinsPerKilowatt);
+            Assert.False(twoSquareMeterKelvinsPerKilowatt < oneSquareMeterKelvinPerKilowatt);
+            Assert.False(twoSquareMeterKelvinsPerKilowatt <= oneSquareMeterKelvinPerKilowatt);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            Assert.Equal(0, squaremeterkelvinperkilowatt.CompareTo(squaremeterkelvinperkilowatt));
+            Assert.True(squaremeterkelvinperkilowatt.CompareTo(ThermalResistance<double>.Zero) > 0);
+            Assert.True(ThermalResistance<double>.Zero.CompareTo(squaremeterkelvinperkilowatt) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            Assert.Throws<ArgumentException>(() => squaremeterkelvinperkilowatt.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            Assert.Throws<ArgumentNullException>(() => squaremeterkelvinperkilowatt.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            var b = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            var b = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            Assert.True(v.Equals(ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1), SquareMeterKelvinsPerKilowattTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(ThermalResistance<double>.Zero, SquareMeterKelvinsPerKilowattTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            Assert.False(squaremeterkelvinperkilowatt.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            ThermalResistance<double> squaremeterkelvinperkilowatt = ThermalResistance<double>.FromSquareMeterKelvinsPerKilowatt(1);
+            Assert.False(squaremeterkelvinperkilowatt.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(ThermalResistanceUnit.Undefined, ThermalResistance<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(ThermalResistanceUnit)).Cast<ThermalResistanceUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == ThermalResistanceUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(ThermalResistance<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs
new file mode 100644
index 0000000000..a280bd08d6
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs
@@ -0,0 +1,243 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of VitaminA.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class VitaminATestsBase
+    {
+        protected abstract double InternationalUnitsInOneInternationalUnit { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double InternationalUnitsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>((double)0.0, VitaminAUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>(double.PositiveInfinity, VitaminAUnit.InternationalUnit));
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>(double.NegativeInfinity, VitaminAUnit.InternationalUnit));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new VitaminA<double>(double.NaN, VitaminAUnit.InternationalUnit));
+        }
+
+        [Fact]
+        public void InternationalUnitToVitaminAUnits()
+        {
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            AssertEx.EqualTolerance(InternationalUnitsInOneInternationalUnit, internationalunit.InternationalUnits, InternationalUnitsTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, VitaminA<double>.From(1, VitaminAUnit.InternationalUnit).InternationalUnits, InternationalUnitsTolerance);
+        }
+
+        [Fact]
+        public void FromInternationalUnits_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => VitaminA<double>.FromInternationalUnits(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => VitaminA<double>.FromInternationalUnits(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromInternationalUnits_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => VitaminA<double>.FromInternationalUnits(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            AssertEx.EqualTolerance(InternationalUnitsInOneInternationalUnit, internationalunit.As(VitaminAUnit.InternationalUnit), InternationalUnitsTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var internationalunit = VitaminA<double>.FromInternationalUnits(1);
+
+            var internationalunitQuantity = internationalunit.ToUnit(VitaminAUnit.InternationalUnit);
+            AssertEx.EqualTolerance(InternationalUnitsInOneInternationalUnit, (double)internationalunitQuantity.Value, InternationalUnitsTolerance);
+            Assert.Equal(VitaminAUnit.InternationalUnit, internationalunitQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            AssertEx.EqualTolerance(1, VitaminA<double>.FromInternationalUnits(internationalunit.InternationalUnits).InternationalUnits, InternationalUnitsTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            VitaminA<double> v = VitaminA<double>.FromInternationalUnits(1);
+            AssertEx.EqualTolerance(-1, -v.InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(2, (VitaminA<double>.FromInternationalUnits(3)-v).InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(2, (v + v).InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(10, (v*10).InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(10, (10*v).InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(2, (VitaminA<double>.FromInternationalUnits(10)/5).InternationalUnits, InternationalUnitsTolerance);
+            AssertEx.EqualTolerance(2, VitaminA<double>.FromInternationalUnits(10)/VitaminA<double>.FromInternationalUnits(5), InternationalUnitsTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            VitaminA<double> oneInternationalUnit = VitaminA<double>.FromInternationalUnits(1);
+            VitaminA<double> twoInternationalUnits = VitaminA<double>.FromInternationalUnits(2);
+
+            Assert.True(oneInternationalUnit < twoInternationalUnits);
+            Assert.True(oneInternationalUnit <= twoInternationalUnits);
+            Assert.True(twoInternationalUnits > oneInternationalUnit);
+            Assert.True(twoInternationalUnits >= oneInternationalUnit);
+
+            Assert.False(oneInternationalUnit > twoInternationalUnits);
+            Assert.False(oneInternationalUnit >= twoInternationalUnits);
+            Assert.False(twoInternationalUnits < oneInternationalUnit);
+            Assert.False(twoInternationalUnits <= oneInternationalUnit);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            Assert.Equal(0, internationalunit.CompareTo(internationalunit));
+            Assert.True(internationalunit.CompareTo(VitaminA<double>.Zero) > 0);
+            Assert.True(VitaminA<double>.Zero.CompareTo(internationalunit) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            Assert.Throws<ArgumentException>(() => internationalunit.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            Assert.Throws<ArgumentNullException>(() => internationalunit.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = VitaminA<double>.FromInternationalUnits(1);
+            var b = VitaminA<double>.FromInternationalUnits(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = VitaminA<double>.FromInternationalUnits(1);
+            var b = VitaminA<double>.FromInternationalUnits(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = VitaminA<double>.FromInternationalUnits(1);
+            Assert.True(v.Equals(VitaminA<double>.FromInternationalUnits(1), InternationalUnitsTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(VitaminA<double>.Zero, InternationalUnitsTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            Assert.False(internationalunit.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            VitaminA<double> internationalunit = VitaminA<double>.FromInternationalUnits(1);
+            Assert.False(internationalunit.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(VitaminAUnit.Undefined, VitaminA<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(VitaminAUnit)).Cast<VitaminAUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == VitaminAUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(VitaminA<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/VolumePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumePerLengthTestsBase.g.cs
new file mode 100644
index 0000000000..aa114de110
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/VolumePerLengthTestsBase.g.cs
@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of VolumePerLength.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class VolumePerLengthTestsBase
+    {
+        protected abstract double CubicMetersPerMeterInOneCubicMeterPerMeter { get; }
+        protected abstract double LitersPerMeterInOneCubicMeterPerMeter { get; }
+        protected abstract double OilBarrelsPerFootInOneCubicMeterPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double CubicMetersPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double LitersPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double OilBarrelsPerFootTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Fact]
+        public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>((double)0.0, VolumePerLengthUnit.Undefined));
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>(double.PositiveInfinity, VolumePerLengthUnit.CubicMeterPerMeter));
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>(double.NegativeInfinity, VolumePerLengthUnit.CubicMeterPerMeter));
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => new VolumePerLength<double>(double.NaN, VolumePerLengthUnit.CubicMeterPerMeter));
+        }
+
+        [Fact]
+        public void CubicMeterPerMeterToVolumePerLengthUnits()
+        {
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(LitersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.LitersPerMeter, LitersPerMeterTolerance);
+            AssertEx.EqualTolerance(OilBarrelsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.OilBarrelsPerFoot, OilBarrelsPerFootTolerance);
+        }
+
+        [Fact]
+        public void FromValueAndUnit()
+        {
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.From(1, VolumePerLengthUnit.CubicMeterPerMeter).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.From(1, VolumePerLengthUnit.LiterPerMeter).LitersPerMeter, LitersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.From(1, VolumePerLengthUnit.OilBarrelPerFoot).OilBarrelsPerFoot, OilBarrelsPerFootTolerance);
+        }
+
+        [Fact]
+        public void FromCubicMetersPerMeter_WithInfinityValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => VolumePerLength<double>.FromCubicMetersPerMeter(double.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => VolumePerLength<double>.FromCubicMetersPerMeter(double.NegativeInfinity));
+        }
+
+        [Fact]
+        public void FromCubicMetersPerMeter_WithNanValue_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => VolumePerLength<double>.FromCubicMetersPerMeter(double.NaN));
+        }
+
+        [Fact]
+        public void As()
+        {
+            var cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.CubicMeterPerMeter), CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(LitersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.LiterPerMeter), LitersPerMeterTolerance);
+            AssertEx.EqualTolerance(OilBarrelsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.OilBarrelPerFoot), OilBarrelsPerFootTolerance);
+        }
+
+        [Fact]
+        public void ToUnit()
+        {
+            var cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+
+            var cubicmeterpermeterQuantity = cubicmeterpermeter.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter);
+            AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, (double)cubicmeterpermeterQuantity.Value, CubicMetersPerMeterTolerance);
+            Assert.Equal(VolumePerLengthUnit.CubicMeterPerMeter, cubicmeterpermeterQuantity.Unit);
+
+            var literpermeterQuantity = cubicmeterpermeter.ToUnit(VolumePerLengthUnit.LiterPerMeter);
+            AssertEx.EqualTolerance(LitersPerMeterInOneCubicMeterPerMeter, (double)literpermeterQuantity.Value, LitersPerMeterTolerance);
+            Assert.Equal(VolumePerLengthUnit.LiterPerMeter, literpermeterQuantity.Unit);
+
+            var oilbarrelperfootQuantity = cubicmeterpermeter.ToUnit(VolumePerLengthUnit.OilBarrelPerFoot);
+            AssertEx.EqualTolerance(OilBarrelsPerFootInOneCubicMeterPerMeter, (double)oilbarrelperfootQuantity.Value, OilBarrelsPerFootTolerance);
+            Assert.Equal(VolumePerLengthUnit.OilBarrelPerFoot, oilbarrelperfootQuantity.Unit);
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromCubicMetersPerMeter(cubicmeterpermeter.CubicMetersPerMeter).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromLitersPerMeter(cubicmeterpermeter.LitersPerMeter).CubicMetersPerMeter, LitersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength<double>.FromOilBarrelsPerFoot(cubicmeterpermeter.OilBarrelsPerFoot).CubicMetersPerMeter, OilBarrelsPerFootTolerance);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            VolumePerLength<double> v = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            AssertEx.EqualTolerance(-1, -v.CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (VolumePerLength<double>.FromCubicMetersPerMeter(3)-v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (v + v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (v*10).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(10, (10*v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, (VolumePerLength<double>.FromCubicMetersPerMeter(10)/5).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(2, VolumePerLength<double>.FromCubicMetersPerMeter(10)/VolumePerLength<double>.FromCubicMetersPerMeter(5), CubicMetersPerMeterTolerance);
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            VolumePerLength<double> oneCubicMeterPerMeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            VolumePerLength<double> twoCubicMetersPerMeter = VolumePerLength<double>.FromCubicMetersPerMeter(2);
+
+            Assert.True(oneCubicMeterPerMeter < twoCubicMetersPerMeter);
+            Assert.True(oneCubicMeterPerMeter <= twoCubicMetersPerMeter);
+            Assert.True(twoCubicMetersPerMeter > oneCubicMeterPerMeter);
+            Assert.True(twoCubicMetersPerMeter >= oneCubicMeterPerMeter);
+
+            Assert.False(oneCubicMeterPerMeter > twoCubicMetersPerMeter);
+            Assert.False(oneCubicMeterPerMeter >= twoCubicMetersPerMeter);
+            Assert.False(twoCubicMetersPerMeter < oneCubicMeterPerMeter);
+            Assert.False(twoCubicMetersPerMeter <= oneCubicMeterPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            Assert.Equal(0, cubicmeterpermeter.CompareTo(cubicmeterpermeter));
+            Assert.True(cubicmeterpermeter.CompareTo(VolumePerLength<double>.Zero) > 0);
+            Assert.True(VolumePerLength<double>.Zero.CompareTo(cubicmeterpermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            Assert.Throws<ArgumentException>(() => cubicmeterpermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => cubicmeterpermeter.CompareTo(null));
+        }
+
+        [Fact]
+        public void EqualityOperators()
+        {
+            var a = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            var b = VolumePerLength<double>.FromCubicMetersPerMeter(2);
+
+ // ReSharper disable EqualExpressionComparison
+
+            Assert.True(a == a);
+            Assert.False(a != a);
+
+            Assert.True(a != b);
+            Assert.False(a == b);
+
+            Assert.False(a == null);
+            Assert.False(null == a);
+
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Fact]
+        public void EqualsIsImplemented()
+        {
+            var a = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            var b = VolumePerLength<double>.FromCubicMetersPerMeter(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals(null));
+        }
+
+        [Fact]
+        public void EqualsRelativeToleranceIsImplemented()
+        {
+            var v = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            Assert.True(v.Equals(VolumePerLength<double>.FromCubicMetersPerMeter(1), CubicMetersPerMeterTolerance, ComparisonType.Relative));
+            Assert.False(v.Equals(VolumePerLength<double>.Zero, CubicMetersPerMeterTolerance, ComparisonType.Relative));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            Assert.False(cubicmeterpermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            VolumePerLength<double> cubicmeterpermeter = VolumePerLength<double>.FromCubicMetersPerMeter(1);
+            Assert.False(cubicmeterpermeter.Equals(null));
+        }
+
+        [Fact]
+        public void UnitsDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(VolumePerLengthUnit.Undefined, VolumePerLength<double>.Units);
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = Enum.GetValues(typeof(VolumePerLengthUnit)).Cast<VolumePerLengthUnit>();
+            foreach(var unit in units)
+            {
+                if(unit == VolumePerLengthUnit.Undefined)
+                    continue;
+
+                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(VolumePerLength<double>.BaseDimensions is null);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedQuantityCodeTests.cs b/UnitsNet.Tests/GeneratedQuantityCodeTests.cs
index d02428161f..15ff3404d5 100644
--- a/UnitsNet.Tests/GeneratedQuantityCodeTests.cs
+++ b/UnitsNet.Tests/GeneratedQuantityCodeTests.cs
@@ -23,12 +23,12 @@ public void LengthEquals_GivenMaxError_ReturnsTrueIfWithinError()
             {
                 var smallError = 1e-5;
 
-                Assert.True(Length.FromMeters(1).Equals(Length.FromMeters(1), 0, ComparisonType.Relative), "Integer values have zero difference.");
-                Assert.True(Length.FromMeters(1).Equals(Length.FromMeters(1), smallError, ComparisonType.Relative), "Using a max difference value should not change that fact.");
+                Assert.True(Length<double>.FromMeters(1).Equals(Length<double>.FromMeters(1), 0, ComparisonType.Relative), "Integer values have zero difference.");
+                Assert.True(Length<double>.FromMeters(1).Equals(Length<double>.FromMeters(1), smallError, ComparisonType.Relative), "Using a max difference value should not change that fact.");
 
-                Assert.False(Length.FromMeters(1 + 0.39).Equals(Length.FromMeters(1.39), 0, ComparisonType.Relative),
+                Assert.False(Length<double>.FromMeters(1 + 0.39).Equals(Length<double>.FromMeters(1.39), 0, ComparisonType.Relative),
                     "Example of floating precision arithmetic that produces slightly different results.");
-                Assert.True(Length.FromMeters(1 + 0.39).Equals(Length.FromMeters(1.39), smallError, ComparisonType.Relative), "But the difference is very small");
+                Assert.True(Length<double>.FromMeters(1 + 0.39).Equals(Length<double>.FromMeters(1.39), smallError, ComparisonType.Relative), "But the difference is very small");
             }
 
             [Fact]
diff --git a/UnitsNet.Tests/IntOverloadTests.cs b/UnitsNet.Tests/IntOverloadTests.cs
index bf63007ba7..afcd9cbe1d 100644
--- a/UnitsNet.Tests/IntOverloadTests.cs
+++ b/UnitsNet.Tests/IntOverloadTests.cs
@@ -10,14 +10,14 @@ public class IntOverloadTests
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromIntReturnsCorrectValue()
         {
-            Acceleration acceleration = Acceleration.FromMetersPerSecondSquared(1);
+            var acceleration = Acceleration<double>.FromMetersPerSecondSquared(1);
             Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithIntBackingFieldFromIntReturnsCorrectValue()
         {
-            Power power = Power.FromWatts(1);
+            var power = Power<double>.FromWatts(1);
             Assert.Equal(1.0, power.Watts);
         }
     }
diff --git a/UnitsNet.Tests/InterUnitConversionTests.cs b/UnitsNet.Tests/InterUnitConversionTests.cs
index d19bd70de0..f503906657 100644
--- a/UnitsNet.Tests/InterUnitConversionTests.cs
+++ b/UnitsNet.Tests/InterUnitConversionTests.cs
@@ -10,16 +10,16 @@ public class InterUnitConversionTests
         [Fact]
         public void KilogramForceToKilogram()
         {
-            Force force = Force.FromKilogramsForce(1);
-            Mass mass = Mass.FromGravitationalForce(force);
+            var force = Force<double>.FromKilogramsForce(1);
+            var mass = Mass<double>.FromGravitationalForce(force);
             Assert.Equal(mass.Kilograms, force.KilogramsForce);
         }
 
         [Fact]
         public void KilogramToKilogramForce()
         {
-            Mass mass = Mass.FromKilograms(1);
-            Force force = Force.FromKilogramsForce(mass.Kilograms);
+            var mass = Mass<double>.FromKilograms(1);
+            var force = Force<double>.FromKilogramsForce(mass.Kilograms);
             Assert.Equal(mass.Kilograms, force.KilogramsForce);
         }
     }
diff --git a/UnitsNet.Tests/LongOverloadTests.cs b/UnitsNet.Tests/LongOverloadTests.cs
index fd54377f08..445aec8780 100644
--- a/UnitsNet.Tests/LongOverloadTests.cs
+++ b/UnitsNet.Tests/LongOverloadTests.cs
@@ -10,14 +10,14 @@ public class LongOverloadTests
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromLongReturnsCorrectValue()
         {
-            Acceleration acceleration = Acceleration.FromMetersPerSecondSquared(1L);
+            var acceleration = Acceleration<double>.FromMetersPerSecondSquared(1L);
             Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithLongBackingFieldFromLongReturnsCorrectValue()
         {
-            Power power = Power.FromWatts(1L);
+            var power = Power<double>.FromWatts(1L);
             Assert.Equal(1.0, power.Watts);
         }
     }
diff --git a/UnitsNet.Tests/QuantityIConvertibleTests.cs b/UnitsNet.Tests/QuantityIConvertibleTests.cs
index 5c5f7983a5..6d0947d676 100644
--- a/UnitsNet.Tests/QuantityIConvertibleTests.cs
+++ b/UnitsNet.Tests/QuantityIConvertibleTests.cs
@@ -7,8 +7,8 @@ namespace UnitsNet.Tests
 {
     public class QuantityIConvertibleTests
     {
-        private static Length length = Length.FromMeters(3.0);
-        private static IConvertible lengthAsIConvertible = Length.FromMeters(3.0);
+        private static Length<double> length = Length<double>.FromMeters(3.0);
+        private static IConvertible lengthAsIConvertible = Length<double>.FromMeters(3.0);
 
         [Fact]
         public void GetTypeCodeTest()
@@ -126,32 +126,32 @@ public void ToStringTest()
         public void ToTypeTest()
         {
             // Same quantity type
-            Assert.Equal(length, lengthAsIConvertible.ToType(typeof(Length), null));
-            Assert.Equal(length, Convert.ChangeType(length, typeof(Length)));
+            Assert.Equal(length, lengthAsIConvertible.ToType(typeof(Length<double>), null));
+            Assert.Equal(length, Convert.ChangeType(length, typeof(Length<double>)));
 
             // Same unit type
             Assert.Equal(length.Unit, lengthAsIConvertible.ToType(typeof(LengthUnit), null));
             Assert.Equal(length.Unit, Convert.ChangeType(length, typeof(LengthUnit)));
 
             // Different type
-            Assert.Throws<InvalidCastException>(() => lengthAsIConvertible.ToType(typeof(Duration), null));
-            Assert.Throws<InvalidCastException>(() => Convert.ChangeType(length, typeof(Duration)));
+            Assert.Throws<InvalidCastException>(() => lengthAsIConvertible.ToType(typeof(Duration<double>), null));
+            Assert.Throws<InvalidCastException>(() => Convert.ChangeType(length, typeof(Duration<double>)));
 
             // Different unit type
             Assert.Throws<InvalidCastException>(() => lengthAsIConvertible.ToType(typeof(DurationUnit), null));
             Assert.Throws<InvalidCastException>(() => Convert.ChangeType(length, typeof(DurationUnit)));
 
             // QuantityType
-            Assert.Equal(Length.QuantityType, lengthAsIConvertible.ToType(typeof(QuantityType), null));
-            Assert.Equal(Length.QuantityType, Convert.ChangeType(length, typeof(QuantityType)));
+            Assert.Equal(Length<double>.QuantityType, lengthAsIConvertible.ToType(typeof(QuantityType), null));
+            Assert.Equal(Length<double>.QuantityType, Convert.ChangeType(length, typeof(QuantityType)));
 
             // QuantityInfo
             Assert.Equal(Length.Info, lengthAsIConvertible.ToType(typeof(QuantityInfo), null));
             Assert.Equal(Length.Info, Convert.ChangeType(length, typeof(QuantityInfo)));
 
             // BaseDimensions
-            Assert.Equal(Length.BaseDimensions, lengthAsIConvertible.ToType(typeof(BaseDimensions), null));
-            Assert.Equal(Length.BaseDimensions, Convert.ChangeType(length, typeof(BaseDimensions)));
+            Assert.Equal(Length<double>.BaseDimensions, lengthAsIConvertible.ToType(typeof(BaseDimensions), null));
+            Assert.Equal(Length<double>.BaseDimensions, Convert.ChangeType(length, typeof(BaseDimensions)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/QuantityIFormattableTests.cs b/UnitsNet.Tests/QuantityIFormattableTests.cs
index 059b5b22e2..504b0f59fd 100644
--- a/UnitsNet.Tests/QuantityIFormattableTests.cs
+++ b/UnitsNet.Tests/QuantityIFormattableTests.cs
@@ -9,7 +9,7 @@ namespace UnitsNet.Tests
 {
     public class QuantityIFormattableTests
     {
-        private static Length length = Length.FromFeet(1.2345678);
+        private static Length<double> length = Length<double>.FromFeet(1.2345678);
 
         [Fact]
         public void GFormatStringEqualsToString()
@@ -49,7 +49,7 @@ public void VFormatEqualsValueToString()
         [Fact]
         public void QFormatEqualsQuantityName()
         {
-            Assert.Equal(Length.Info.Name, length.ToString("q"));
+            Assert.Equal(Length<double>.Info.Name, length.ToString("q"));
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/QuantityInfoTest.cs b/UnitsNet.Tests/QuantityInfoTest.cs
index 690912aa56..2a84450938 100644
--- a/UnitsNet.Tests/QuantityInfoTest.cs
+++ b/UnitsNet.Tests/QuantityInfoTest.cs
@@ -14,14 +14,14 @@ public class QuantityInfoTest
         [Fact]
         public void Constructor_AssignsProperties()
         {
-            var expectedZero = Length.FromCentimeters(10);
+            var expectedZero = Length<double>.FromCentimeters(10);
             var expectedUnitInfos = new UnitInfo[]{
                 new UnitInfo(LengthUnit.Centimeter, new BaseUnits(LengthUnit.Centimeter)),
                 new UnitInfo(LengthUnit.Kilometer, new BaseUnits(LengthUnit.Kilometer))
             };
             var expectedBaseUnit = LengthUnit.Centimeter;
             var expectedQuantityType = QuantityType.Length;
-            var expectedBaseDimensions = Length.BaseDimensions;
+            var expectedBaseDimensions = Length<double>.BaseDimensions;
 
             var info = new QuantityInfo(expectedQuantityType, expectedUnitInfos,
                 expectedBaseUnit, expectedZero, expectedBaseDimensions);
@@ -40,14 +40,14 @@ public void Constructor_AssignsProperties()
         [Fact]
         public void GenericsConstructor_AssignsProperties()
         {
-            var expectedZero = Length.FromCentimeters(10);
+            var expectedZero = Length<double>.FromCentimeters(10);
             var expectedUnitInfos = new UnitInfo<LengthUnit>[]{
                 new UnitInfo<LengthUnit>(LengthUnit.Centimeter, new BaseUnits(LengthUnit.Centimeter)),
                 new UnitInfo<LengthUnit>(LengthUnit.Kilometer, new BaseUnits(LengthUnit.Kilometer))
             };
             var expectedBaseUnit = LengthUnit.Centimeter;
             var expectedQuantityType = QuantityType.Length;
-            var expectedBaseDimensions = Length.BaseDimensions;
+            var expectedBaseDimensions = Length<double>.BaseDimensions;
 
             var info = new QuantityInfo<LengthUnit>(expectedQuantityType, expectedUnitInfos,
                 expectedBaseUnit, expectedZero, expectedBaseDimensions);
@@ -67,7 +67,7 @@ public void GenericsConstructor_AssignsProperties()
         public void Constructor_GivenNullAsUnitInfos_ThrowsArgumentNullException()
         {
             Assert.Throws<ArgumentNullException>(() => new QuantityInfo(QuantityType.Length,
-                null, Length.BaseUnit, Length.Zero, Length.BaseDimensions));
+                null, Length<double>.BaseUnit, Length<double>.Zero, Length<double>.BaseDimensions));
         }
 
         [Fact]
@@ -75,7 +75,7 @@ public void Constructor_GivenNullAsUnitInfos_ThrowsArgumentNullException()
         public void GenericsConstructor_GivenNullAsUnitInfos_ThrowsArgumentNullException()
         {
             Assert.Throws<ArgumentNullException>(() => new QuantityInfo<LengthUnit>(QuantityType.Length,
-                null, Length.BaseUnit, Length.Zero, Length.BaseDimensions));
+                null, Length<double>.BaseUnit, Length<double>.Zero, Length<double>.BaseDimensions));
         }
 
         [Fact]
@@ -83,7 +83,7 @@ public void GenericsConstructor_GivenNullAsUnitInfos_ThrowsArgumentNullException
         public void Constructor_GivenNullAsBaseUnit_ThrowsArgumentNullException()
         {
             Assert.Throws<ArgumentNullException>(() => new QuantityInfo(QuantityType.Length,
-                Length.Info.UnitInfos, null, Length.Zero, Length.BaseDimensions));
+                Length<double>.Info.UnitInfos, null, Length<double>.Zero, Length<double>.BaseDimensions));
         }
 
         [Fact]
@@ -91,7 +91,7 @@ public void Constructor_GivenNullAsBaseUnit_ThrowsArgumentNullException()
         public void Constructor_GivenNullAsZero_ThrowsArgumentNullException()
         {
             Assert.Throws<ArgumentNullException>(() => new QuantityInfo(QuantityType.Length,
-                Length.Info.UnitInfos, Length.BaseUnit, null, Length.BaseDimensions));
+                Length<double>.Info.UnitInfos, Length<double>.BaseUnit, null, Length<double>.BaseDimensions));
         }
 
         [Fact]
@@ -99,7 +99,7 @@ public void Constructor_GivenNullAsZero_ThrowsArgumentNullException()
         public void GenericsConstructor_GivenNullAsZero_ThrowsArgumentNullException()
         {
             Assert.Throws<ArgumentNullException>(() => new QuantityInfo<LengthUnit>(QuantityType.Length,
-                Length.Info.UnitInfos, Length.BaseUnit, null, Length.BaseDimensions));
+                Length<double>.Info.UnitInfos, Length<double>.BaseUnit, null, Length<double>.BaseDimensions));
         }
 
         [Fact]
@@ -107,30 +107,30 @@ public void GenericsConstructor_GivenNullAsZero_ThrowsArgumentNullException()
         public void Constructor_GivenNullAsBaseDimensions_ThrowsArgumentNullException()
         {
             Assert.Throws<ArgumentNullException>(() => new QuantityInfo(QuantityType.Length,
-                Length.Info.UnitInfos, Length.BaseUnit, Length.Zero, null));
+                Length<double>.Info.UnitInfos, Length<double>.BaseUnit, Length<double>.Zero, null));
         }
-
         [Fact]
         [SuppressMessage("ReSharper", "AssignNullToNotNullAttribute")]
-        public void GenericsConstructor_GivenNullAsBaseDimensions_ThrowsArgumentNullException()
+        public void Constructor2_GivenNullAsUnitInfos_ThrowsArgumentNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => new QuantityInfo<LengthUnit>(QuantityType.Length,
-                Length.Info.UnitInfos, Length.BaseUnit, Length.Zero, null));
+            Assert.Throws<ArgumentNullException>(() => new QuantityInfo(Length<double>.Info.Name,
+                null, Length<double>.BaseUnit, Length<double>.Zero, Length<double>.BaseDimensions));
         }
+
         [Fact]
         [SuppressMessage("ReSharper", "AssignNullToNotNullAttribute")]
-        public void Constructor2_GivenNullAsUnitInfos_ThrowsArgumentNullException()
+        public void GenericsConstructor_GivenNullAsBaseDimensions_ThrowsArgumentNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => new QuantityInfo(Length.Info.Name,
-                null, Length.BaseUnit, Length.Zero, Length.BaseDimensions));
+            Assert.Throws<ArgumentNullException>(() => new QuantityInfo<LengthUnit>(QuantityType.Length,
+                Length<double>.Info.UnitInfos, Length<double>.BaseUnit, Length<double>.Zero, null));
         }
 
         [Fact]
         [SuppressMessage("ReSharper", "AssignNullToNotNullAttribute")]
         public void GenericsConstructor2_GivenNullAsUnitInfos_ThrowsArgumentNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => new QuantityInfo<LengthUnit>(Length.Info.Name,
-                null, Length.BaseUnit, Length.Zero, Length.BaseDimensions));
+            Assert.Throws<ArgumentNullException>(() => new QuantityInfo<LengthUnit>(Length<double>.Info.Name,
+                null, Length<double>.BaseUnit, Length<double>.Zero, Length<double>.BaseDimensions));
         }
 
         [Fact]
@@ -176,14 +176,14 @@ public void GenericsConstructor2_GivenNullAsBaseDimensions_ThrowsArgumentNullExc
         [Fact]
         public void GetUnitInfoFor_GivenNullAsBaseUnits_ThrowsArgumentNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => Length.Info.GetUnitInfoFor(null));
+            Assert.Throws<ArgumentNullException>(() => Length<double>.Info.GetUnitInfoFor(null));
         }
 
         [Fact]
         public void GetUnitInfoFor_GivenBaseUnitsWithNoMatch_ThrowsInvalidOperationException()
         {
             var baseUnitsWithNoMatch = new BaseUnits(mass: MassUnit.Kilogram);
-            Assert.Throws<InvalidOperationException>(() => Length.Info.GetUnitInfoFor(baseUnitsWithNoMatch));
+            Assert.Throws<InvalidOperationException>(() => Length<double>.Info.GetUnitInfoFor(baseUnitsWithNoMatch));
         }
 
         [Fact]
@@ -195,7 +195,7 @@ public void GetUnitInfoFor_GivenBaseUnitsWithMultipleMatches_ThrowsInvalidOperat
                 new UnitInfo<LengthUnit>[]{
                     new UnitInfo<LengthUnit>(LengthUnit.Meter, baseUnits),
                     new UnitInfo<LengthUnit>(LengthUnit.Foot, baseUnits) },
-                LengthUnit.Meter, Length.Zero, Length.BaseDimensions);
+                LengthUnit.Meter, Length<double>.Zero, Length<double>.BaseDimensions);
 
             Assert.Throws<InvalidOperationException>(() => quantityInfo.GetUnitInfoFor(baseUnits));
         }
@@ -203,14 +203,14 @@ public void GetUnitInfoFor_GivenBaseUnitsWithMultipleMatches_ThrowsInvalidOperat
         [Fact]
         public void GetUnitInfosFor_GivenNullAsBaseUnits_ThrowsArgumentNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => Length.Info.GetUnitInfosFor(null));
+            Assert.Throws<ArgumentNullException>(() => Length<double>.Info.GetUnitInfosFor(null));
         }
 
         [Fact]
         public void GetUnitInfosFor_GivenBaseUnitsWithNoMatch_ReturnsEmpty()
         {
             var baseUnitsWithNoMatch = new BaseUnits(mass: MassUnit.Kilogram);
-            var result = Length.Info.GetUnitInfosFor(baseUnitsWithNoMatch);
+            var result = Length<double>.Info.GetUnitInfosFor(baseUnitsWithNoMatch);
             Assert.Empty(result);
         }
 
@@ -218,7 +218,7 @@ public void GetUnitInfosFor_GivenBaseUnitsWithNoMatch_ReturnsEmpty()
         public void GetUnitInfosFor_GivenBaseUnitsWithOneMatch_ReturnsOneMatch()
         {
             var baseUnitsWithOneMatch = new BaseUnits(LengthUnit.Foot);
-            var result = Length.Info.GetUnitInfosFor(baseUnitsWithOneMatch);
+            var result = Length<double>.Info.GetUnitInfosFor(baseUnitsWithOneMatch);
             Assert.Collection(result, element1 => Assert.Equal(LengthUnit.Foot, element1.Value));
         }
 
@@ -231,7 +231,7 @@ public void GetUnitInfosFor_GivenBaseUnitsWithMultipleMatches_ReturnsMultipleMat
                 new UnitInfo<LengthUnit>[]{
                     new UnitInfo<LengthUnit>(LengthUnit.Meter, baseUnits),
                     new UnitInfo<LengthUnit>(LengthUnit.Foot, baseUnits) },
-                LengthUnit.Meter, Length.Zero, Length.BaseDimensions);
+                LengthUnit.Meter, Length<double>.Zero, Length<double>.BaseDimensions);
 
             var result = quantityInfo.GetUnitInfosFor(baseUnits);
 
diff --git a/UnitsNet.Tests/QuantityTest.cs b/UnitsNet.Tests/QuantityTest.cs
index 3667e56fe2..04d07807a5 100644
--- a/UnitsNet.Tests/QuantityTest.cs
+++ b/UnitsNet.Tests/QuantityTest.cs
@@ -22,7 +22,7 @@ public class QuantityTest
         [InlineData(double.NegativeInfinity)]
         public void From_GivenNaNOrInfinity_ThrowsArgumentException(double value)
         {
-            Assert.Throws<ArgumentException>(() => Quantity.From(value, LengthUnit.Centimeter));
+            Assert.Throws<ArgumentException>(() => Quantity.From<double>(value, LengthUnit.Centimeter));
         }
 
         [Theory]
@@ -31,16 +31,16 @@ public void From_GivenNaNOrInfinity_ThrowsArgumentException(double value)
         [InlineData(double.NegativeInfinity)]
         public void TryFrom_GivenNaNOrInfinity_ReturnsFalseAndNullQuantity(double value)
         {
-            Assert.False(Quantity.TryFrom(value, LengthUnit.Centimeter, out IQuantity parsedLength));
+            Assert.False(Quantity.TryFrom<double>( value, LengthUnit.Centimeter, out IQuantity parsedLength));
             Assert.Null(parsedLength);
         }
 
         [Fact]
         public void From_GivenValueAndUnit_ReturnsQuantity()
         {
-            Assert.Equal(Length.FromCentimeters(3), Quantity.From(3, LengthUnit.Centimeter));
-            Assert.Equal(Mass.FromTonnes(3), Quantity.From(3, MassUnit.Tonne));
-            Assert.Equal(Pressure.FromMegabars(3), Quantity.From(3, PressureUnit.Megabar));
+            Assert.Equal(Length<double>.FromCentimeters(3), Quantity.From<double>( 3, LengthUnit.Centimeter));
+            Assert.Equal(Mass<double>.FromTonnes(3), Quantity.From<double>( 3, MassUnit.Tonne));
+            Assert.Equal(Pressure<double>.FromMegabars(3), Quantity.From<double>( 3, PressureUnit.Megabar));
         }
 
         [Fact]
@@ -59,8 +59,8 @@ public void GetInfo_GivenLength_ReturnsQuantityInfoForLength()
             Assert.Equal(lengthUnitCount, quantityInfo.UnitNames.Length);
             Assert.Equal(lengthUnitCount, quantityInfo.Units.Length);
             Assert.Equal(typeof(LengthUnit), quantityInfo.UnitType);
-            Assert.Equal(typeof(Length), quantityInfo.ValueType);
-            Assert.Equal(Length.Zero, quantityInfo.Zero);
+            Assert.Equal(typeof(Length<double>), quantityInfo.ValueType);
+            Assert.Equal(Length<double>.Zero, quantityInfo.Zero);
         }
 
         [Fact]
@@ -79,8 +79,8 @@ public void GetInfo_GivenMass_ReturnsQuantityInfoForMass()
             Assert.Equal(massUnitCount, quantityInfo.UnitNames.Length);
             Assert.Equal(massUnitCount, quantityInfo.Units.Length);
             Assert.Equal(typeof(MassUnit), quantityInfo.UnitType);
-            Assert.Equal(typeof(Mass), quantityInfo.ValueType);
-            Assert.Equal(Mass.Zero, quantityInfo.Zero);
+            Assert.Equal(typeof(Mass<double>), quantityInfo.ValueType);
+            Assert.Equal(Mass<double>.Zero, quantityInfo.Zero);
         }
 
         [Fact]
@@ -101,9 +101,9 @@ public void Infos_ReturnsKnownQuantityInfoObjects()
         [Fact]
         public void Parse_GivenValueAndUnit_ReturnsQuantity()
         {
-            Assert.Equal(Length.FromCentimeters(3), Quantity.Parse(CultureInfo.InvariantCulture, typeof(Length), "3 cm"));
-            Assert.Equal(Mass.FromTonnes(3), Quantity.Parse(CultureInfo.InvariantCulture, typeof(Mass), "03t"));
-            Assert.Equal(Pressure.FromMegabars(3), Quantity.Parse(CultureInfo.InvariantCulture, typeof(Pressure), "3.0 Mbar"));
+            Assert.Equal(Length<double>.FromCentimeters(3), Quantity.Parse<double>( CultureInfo.InvariantCulture, typeof(Length<double>), "3 cm"));
+            Assert.Equal(Mass<double>.FromTonnes(3), Quantity.Parse<double>( CultureInfo.InvariantCulture, typeof(Mass<double>), "03t"));
+            Assert.Equal(Pressure<double>.FromMegabars(3), Quantity.Parse<double>( CultureInfo.InvariantCulture, typeof(Pressure<double>), "3.0 Mbar"));
         }
 
         [Fact]
@@ -120,47 +120,47 @@ public void QuantityNames_ReturnsKnownNames()
         [Fact]
         public void TryFrom_GivenValueAndUnit_ReturnsQuantity()
         {
-            Assert.True(Quantity.TryFrom(3, LengthUnit.Centimeter, out IQuantity parsedLength));
-            Assert.Equal(Length.FromCentimeters(3), parsedLength);
+            Assert.True(Quantity.TryFrom<double>( 3, LengthUnit.Centimeter, out IQuantity parsedLength));
+            Assert.Equal(Length<double>.FromCentimeters(3), parsedLength);
 
-            Assert.True(Quantity.TryFrom(3, MassUnit.Tonne, out IQuantity parsedMass));
-            Assert.Equal(Mass.FromTonnes(3), parsedMass);
+            Assert.True(Quantity.TryFrom<double>( 3, MassUnit.Tonne, out IQuantity parsedMass));
+            Assert.Equal(Mass<double>.FromTonnes(3), parsedMass);
 
-            Assert.True(Quantity.TryFrom(3, PressureUnit.Megabar, out IQuantity parsedPressure));
-            Assert.Equal(Pressure.FromMegabars(3), parsedPressure);
+            Assert.True(Quantity.TryFrom<double>( 3, PressureUnit.Megabar, out IQuantity parsedPressure));
+            Assert.Equal(Pressure<double>.FromMegabars(3), parsedPressure);
         }
 
         [Fact]
         public void TryParse_GivenInvalidQuantityType_ReturnsFalseAndNullQuantity()
         {
-            Assert.False(Quantity.TryParse(typeof(DummyIQuantity), "3.0 cm", out IQuantity parsedLength));
+            Assert.False(Quantity.TryParse<double>( typeof(DummyIQuantity), "3.0 cm", out IQuantity parsedLength));
             Assert.Null(parsedLength);
         }
 
         [Fact]
         public void TryParse_GivenInvalidString_ReturnsFalseAndNullQuantity()
         {
-            Assert.False(Quantity.TryParse(typeof(Length), "x cm", out IQuantity parsedLength));
+            Assert.False(Quantity.TryParse<double>( typeof(Length<double>), "x cm", out IQuantity parsedLength));
             Assert.Null(parsedLength);
 
-            Assert.False(Quantity.TryParse(typeof(Mass), "xt", out IQuantity parsedMass));
+            Assert.False(Quantity.TryParse<double>( typeof(Mass<double>), "xt", out IQuantity parsedMass));
             Assert.Null(parsedMass);
 
-            Assert.False(Quantity.TryParse(typeof(Pressure), "foo", out IQuantity parsedPressure));
+            Assert.False(Quantity.TryParse<double>( typeof(Pressure<double> ), "foo", out IQuantity parsedPressure));
             Assert.Null(parsedPressure);
         }
 
         [Fact]
         public void TryParse_GivenValueAndUnit_ReturnsQuantity()
         {
-            Assert.True(Quantity.TryParse(typeof(Length), "3 cm", out IQuantity parsedLength));
-            Assert.Equal(Length.FromCentimeters(3), parsedLength);
+            Assert.True(Quantity.TryParse<double>( typeof(Length<double>), "3 cm", out IQuantity parsedLength));
+            Assert.Equal(Length<double>.FromCentimeters(3), parsedLength);
 
-            Assert.True(Quantity.TryParse(typeof(Mass), "03t", out IQuantity parsedMass));
-            Assert.Equal(Mass.FromTonnes(3), parsedMass);
+            Assert.True(Quantity.TryParse<double>( typeof(Mass<double>), "03t", out IQuantity parsedMass));
+            Assert.Equal(Mass<double>.FromTonnes(3), parsedMass);
 
-            Assert.True(Quantity.TryParse(NumberFormatInfo.InvariantInfo, typeof(Pressure), "3.0 Mbar", out IQuantity parsedPressure));
-            Assert.Equal(Pressure.FromMegabars(3), parsedPressure);
+            Assert.True(Quantity.TryParse<double>( NumberFormatInfo.InvariantInfo, typeof(Pressure<double> ), "3.0 Mbar", out IQuantity parsedPressure));
+            Assert.Equal(Pressure<double>.FromMegabars(3), parsedPressure);
         }
 
         [Fact]
@@ -176,23 +176,23 @@ public void Types_ReturnsKnownQuantityTypes()
         [Fact]
         public void FromQuantityType_GivenUndefinedQuantityType_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Quantity.FromQuantityType(QuantityType.Undefined, 0.0));
+            Assert.Throws<ArgumentException>(() => Quantity.FromQuantityType<double>( QuantityType.Undefined, 0.0));
         }
 
         [Fact]
         public void FromQuantityType_GivenInvalidQuantityType_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(() => Quantity.FromQuantityType((QuantityType)(-1), 0.0));
+            Assert.Throws<ArgumentException>(() => Quantity.FromQuantityType<double>( (QuantityType)(-1), 0.0));
         }
 
         [Fact]
         public void FromQuantityType_GivenLengthQuantityType_ReturnsLengthQuantity()
         {
-            var fromQuantity = Quantity.FromQuantityType(QuantityType.Length, 0.0);
+            var fromQuantity = Quantity.FromQuantityType<double>( QuantityType.Length, 0.0);
 
             Assert.Equal(0.0, fromQuantity.Value);
             Assert.Equal(QuantityType.Length, fromQuantity.Type);
-            Assert.Equal(Length.BaseUnit, fromQuantity.Unit);
+            Assert.Equal(Length<double>.BaseUnit, fromQuantity.Unit);
         }
     }
 }
diff --git a/UnitsNet.Tests/QuantityTests.ToString.cs b/UnitsNet.Tests/QuantityTests.ToString.cs
index 06794a8273..c383670c22 100644
--- a/UnitsNet.Tests/QuantityTests.ToString.cs
+++ b/UnitsNet.Tests/QuantityTests.ToString.cs
@@ -17,15 +17,15 @@ public class ToStringTests
             public void ReturnsTheOriginalValueAndUnit()
             {
                 var culture = CultureInfo.InvariantCulture;
-                Assert.Equal("5 kg", Mass.FromKilograms(5).ToString(culture));
-                Assert.Equal("5,000 g", Mass.FromGrams(5000).ToString(culture));
-                Assert.Equal("1e-04 long tn", Mass.FromLongTons(1e-4).ToString(culture));
-                Assert.Equal("3.46e-04 dN/m", ForcePerLength.FromDecinewtonsPerMeter(0.00034567).ToString(culture));
-                Assert.Equal("0.0069 dB", Level.FromDecibels(0.0069).ToString(culture));
-                Assert.Equal("0.011 kWh/kg", SpecificEnergy.FromKilowattHoursPerKilogram(0.011).ToString(culture));
+                Assert.Equal("5 kg", Mass<double>.FromKilograms(5).ToString(culture));
+                Assert.Equal("5,000 g", Mass<double>.FromGrams(5000).ToString(culture));
+                Assert.Equal("1e-04 long tn", Mass<double>.FromLongTons(1e-4).ToString(culture));
+                Assert.Equal("3.46e-04 dN/m", ForcePerLength<double>.FromDecinewtonsPerMeter(0.00034567).ToString(culture));
+                Assert.Equal("0.0069 dB", Level<double>.FromDecibels(0.0069).ToString(culture));
+                Assert.Equal("0.011 kWh/kg", SpecificEnergy<double>.FromKilowattHoursPerKilogram(0.011).ToString(culture));
                 //                Assert.Equal("0.1 MJ/kg·C", SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(0.1).ToString(culture));
-                Assert.Equal("0.1 MJ/kg.C", SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(0.1).ToString(culture));
-                Assert.Equal("5 cm", Length.FromCentimeters(5).ToString(culture));
+                Assert.Equal("0.1 MJ/kg.C", SpecificEntropy<double>.FromMegajoulesPerKilogramDegreeCelsius(0.1).ToString(culture));
+                Assert.Equal("5 cm", Length<double>.FromCentimeters(5).ToString(culture));
             }
 
             [Fact]
@@ -35,9 +35,9 @@ public void FormatsNumberUsingGivenCulture()
                 try
                 {
                     CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
-                    Assert.Equal("0.05 m", Length.FromCentimeters(5).ToUnit(LengthUnit.Meter).ToString((IFormatProvider)null));
-                    Assert.Equal("0.05 m", Length.FromCentimeters(5).ToUnit(LengthUnit.Meter).ToString(CultureInfo.InvariantCulture));
-                    Assert.Equal("0,05 m", Length.FromCentimeters(5).ToUnit(LengthUnit.Meter).ToString(new CultureInfo("nb-NO")));
+                    Assert.Equal("0.05 m", Length<double>.FromCentimeters(5).ToUnit(LengthUnit.Meter).ToString((IFormatProvider)null));
+                    Assert.Equal("0.05 m", Length<double>.FromCentimeters(5).ToUnit(LengthUnit.Meter).ToString(CultureInfo.InvariantCulture));
+                    Assert.Equal("0,05 m", Length<double>.FromCentimeters(5).ToUnit(LengthUnit.Meter).ToString(new CultureInfo("nb-NO")));
                 }
                 finally
                 {
diff --git a/UnitsNet.Tests/QuantityTests.cs b/UnitsNet.Tests/QuantityTests.cs
index e650a60f17..e3c5e0f291 100644
--- a/UnitsNet.Tests/QuantityTests.cs
+++ b/UnitsNet.Tests/QuantityTests.cs
@@ -12,8 +12,8 @@ public partial class QuantityTests
         [Fact]
         public void GetHashCodeForDifferentQuantitiesWithSameValuesAreNotEqual()
         {
-            var length = new Length(1.0, (LengthUnit)2);
-            var area = new Area(1.0, (AreaUnit)2);
+            var length = new Length<double>(1.0, (LengthUnit)2);
+            var area = new Area<double>(1.0, (AreaUnit)2);
 
             Assert.NotEqual(length.GetHashCode(), area.GetHashCode());
         }
diff --git a/UnitsNet.Tests/QuantityTypeConverterTest.cs b/UnitsNet.Tests/QuantityTypeConverterTest.cs
index 6d1b587aed..4ba88db784 100644
--- a/UnitsNet.Tests/QuantityTypeConverterTest.cs
+++ b/UnitsNet.Tests/QuantityTypeConverterTest.cs
@@ -42,10 +42,10 @@ static QuantityTypeConverterTest()
         [InlineData(typeof(double), false)]
         [InlineData(typeof(object), false)]
         [InlineData(typeof(float), false)]
-        [InlineData(typeof(Length), false)]
+        [InlineData(typeof(Length<double>), false)]
         public void CanConvertFrom_GivenSomeTypes(Type value, bool expectedResult)
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
 
             bool canConvertFrom = converter.CanConvertFrom(value);
 
@@ -57,10 +57,10 @@ public void CanConvertFrom_GivenSomeTypes(Type value, bool expectedResult)
         [InlineData(typeof(double), false)]
         [InlineData(typeof(object), false)]
         [InlineData(typeof(float), false)]
-        [InlineData(typeof(Length), false)]
+        [InlineData(typeof(Length<double>), false)]
         public void CanConvertTo_GivenSomeTypes(Type value, bool expectedResult)
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
 
             bool canConvertTo = converter.CanConvertTo(value);
 
@@ -74,10 +74,10 @@ public void CanConvertTo_GivenSomeTypes(Type value, bool expectedResult)
         [InlineData("1km", 1, Units.LengthUnit.Kilometer)]
         public void ConvertFrom_GivenQuantityStringAndContextWithNoAttributes_ReturnsQuantityWithBaseUnitIfNotSpecified(string str, double expectedValue, Enum expectedUnit)
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
-            var convertedValue = (Length)converter.ConvertFrom(context, culture, str);
+            var convertedValue = (Length<double>)converter.ConvertFrom(context, culture, str);
 
             Assert.Equal(expectedValue, convertedValue.Value);
             Assert.Equal(expectedUnit, convertedValue.Unit);
@@ -90,13 +90,13 @@ public void ConvertFrom_GivenQuantityStringAndContextWithNoAttributes_ReturnsQua
         [InlineData("1km", 1, Units.LengthUnit.Kilometer)]
         public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAttribute_ReturnsQuantityWithGivenDefaultUnitIfNotSpecified(string str, double expectedValue, Enum expectedUnit)
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
                 new DefaultUnitAttribute(Units.LengthUnit.Centimeter)
             });
 
-            var convertedValue = (Length)converter.ConvertFrom(context, culture, str);
+            var convertedValue = (Length<double>)converter.ConvertFrom(context, culture, str);
 
             Assert.Equal(expectedValue, convertedValue.Value);
             Assert.Equal(expectedUnit, convertedValue.Unit);
@@ -109,14 +109,14 @@ public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAttribute_Re
         [InlineData("1km", 1000, Units.LengthUnit.Meter)]
         public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAndConvertToUnitAttributes_ReturnsQuantityConvertedToUnit(string str, double expectedValue, Enum expectedUnit)
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
                 new DefaultUnitAttribute(Units.LengthUnit.Centimeter),
                 new ConvertToUnitAttribute(Units.LengthUnit.Meter)
             });
 
-            var convertedValue = (Length)converter.ConvertFrom(context, culture, str);
+            var convertedValue = (Length<double>)converter.ConvertFrom(context, culture, str);
 
             Assert.Equal(expectedValue, convertedValue.Value);
             Assert.Equal(expectedUnit, convertedValue.Unit);
@@ -125,7 +125,7 @@ public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAndConvertTo
         [Fact]
         public void ConvertFrom_GivenEmptyString_ThrowsNotSupportedException()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
             Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(context, culture, ""));
@@ -134,21 +134,21 @@ public void ConvertFrom_GivenEmptyString_ThrowsNotSupportedException()
         [Fact]
         public void ConvertFrom_GivenWrongQuantity_ThrowsArgumentException()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
             Assert.Throws<ArgumentException>(() => converter.ConvertFrom(context, culture, "1m^2"));
         }
 
         [Theory]
-        [InlineData(typeof(Length))]
+        [InlineData(typeof(Length<double>))]
         [InlineData(typeof(IQuantity))]
         [InlineData(typeof(object))]
         public void ConvertTo_GivenWrongType_ThrowsNotSupportedException(Type value)
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
-            Length length = Length.FromMeters(1);
+            Length<double> length = Length<double>.FromMeters(1);
 
             Assert.Throws<NotSupportedException>(() => converter.ConvertTo(length, value));
         }
@@ -156,9 +156,9 @@ public void ConvertTo_GivenWrongType_ThrowsNotSupportedException(Type value)
         [Fact]
         public void ConvertTo_GivenStringType_ReturnsQuantityString()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
-            Length length = Length.FromMeters(1);
+            Length<double> length = Length<double>.FromMeters(1);
 
             string convertedQuantity = (string)converter.ConvertTo(length, typeof(string));
 
@@ -168,9 +168,9 @@ public void ConvertTo_GivenStringType_ReturnsQuantityString()
         [Fact]
         public void ConvertTo_GivenSomeQuantityAndContextWithNoAttributes_ReturnsQuantityStringInUnitOfQuantity()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
-            Length length = Length.FromMeters(1);
+            Length<double> length = Length<double>.FromMeters(1);
 
             string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
 
@@ -192,12 +192,12 @@ public void ConvertTo_GivenSomeQuantityAndContextWithoutProperty_ReturnsQuantity
         [Fact]
         public void ConvertTo_TestDisplayAsFormatting_ReturnsQuantityStringWithDisplayUnitDefaultFormatting()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
                 new DisplayAsUnitAttribute(Units.LengthUnit.Decimeter)
             });
-            Length length = Length.FromMeters(1);
+            var length = Length<double>.FromMeters(1);
 
             string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
 
@@ -207,12 +207,12 @@ public void ConvertTo_TestDisplayAsFormatting_ReturnsQuantityStringWithDisplayUn
         [Fact]
         public void ConvertTo_TestDisplayAsFormatting_ReturnsQuantityStringWithDisplayUnitFormatAsValueOnly()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
                 new DisplayAsUnitAttribute(Units.LengthUnit.Decimeter, "v")
             });
-            Length length = Length.FromMeters(1);
+            var length = Length<double>.FromMeters(1);
 
             string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
 
@@ -222,12 +222,12 @@ public void ConvertTo_TestDisplayAsFormatting_ReturnsQuantityStringWithDisplayUn
         [Fact]
         public void ConvertTo_TestDisplayAsFormattingWithoutDefinedUnit_ReturnsQuantityStringWithQuantityUnitAndFormattedAsValueOnly()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
                 new DisplayAsUnitAttribute(null, "v")
             });
-            Length length = Length.FromMeters(1);
+            var length = Length<double>.FromMeters(1);
 
             string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
 
@@ -237,12 +237,12 @@ public void ConvertTo_TestDisplayAsFormattingWithoutDefinedUnit_ReturnsQuantityS
         [Fact]
         public void ConvertTo_GivenSomeQuantityAndContextWithDisplayAsUnitAttributes_ReturnsQuantityStringInSpecifiedDisplayUnit()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
                 new DisplayAsUnitAttribute(Units.LengthUnit.Decimeter)
             });
-            Length length = Length.FromMeters(1);
+            var length = Length<double>.FromMeters(1);
 
             string convertedQuantityDefaultCulture = (string)converter.ConvertTo(length, typeof(string));
             string convertedQuantitySpecificCulture = (string)converter.ConvertTo(context, culture, length, typeof(string));
@@ -254,7 +254,7 @@ public void ConvertTo_GivenSomeQuantityAndContextWithDisplayAsUnitAttributes_Ret
         [Fact]
         public void ConvertFrom_GivenDefaultUnitAttributeWithWrongUnitType_ThrowsArgumentException()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
                 new DefaultUnitAttribute(Units.VolumeUnit.CubicMeter)
@@ -266,62 +266,62 @@ public void ConvertFrom_GivenDefaultUnitAttributeWithWrongUnitType_ThrowsArgumen
         [Fact]
         public void ConvertFrom_GivenStringWithPower_1()
         {
-            var converter = new QuantityTypeConverter<Length>();
+            var converter = new QuantityTypeConverter<Length<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
-            Assert.Equal(Length.FromMeters(1), converter.ConvertFrom(context, culture, "1m"));
-            Assert.Equal(Length.FromMeters(1), converter.ConvertFrom(context, culture, "1m^1"));
+            Assert.Equal(Length<double>.FromMeters(1), converter.ConvertFrom(context, culture, "1m"));
+            Assert.Equal(Length<double>.FromMeters(1), converter.ConvertFrom(context, culture, "1m^1"));
         }
 
         [Fact]
         public void ConvertFrom_GivenStringWithPower_2()
         {
-            var converter = new QuantityTypeConverter<Area>();
+            var converter = new QuantityTypeConverter<Area<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
-            Assert.Equal(Area.FromSquareMeters(1), converter.ConvertFrom(context, culture, "1m²"));
-            Assert.Equal(Area.FromSquareMeters(1), converter.ConvertFrom(context, culture, "1m^2"));
+            Assert.Equal(Area<double>.FromSquareMeters(1), converter.ConvertFrom(context, culture, "1m²"));
+            Assert.Equal(Area<double>.FromSquareMeters(1), converter.ConvertFrom(context, culture, "1m^2"));
         }
 
         [Fact]
         public void ConvertFrom_GivenStringWithPower_3()
         {
-            var converter = new QuantityTypeConverter<Volume>();
+            var converter = new QuantityTypeConverter<Volume<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
-            Assert.Equal(Volume.FromCubicMeters(1), converter.ConvertFrom(context, culture, "1m³"));
-            Assert.Equal(Volume.FromCubicMeters(1), converter.ConvertFrom(context, culture, "1m^3"));
+            Assert.Equal(Volume<double>.FromCubicMeters(1), converter.ConvertFrom(context, culture, "1m³"));
+            Assert.Equal(Volume<double>.FromCubicMeters(1), converter.ConvertFrom(context, culture, "1m^3"));
         }
 
         [Fact]
         public void ConvertFrom_GivenStringWithPower_4()
         {
-            var converter = new QuantityTypeConverter<AreaMomentOfInertia>();
+            var converter = new QuantityTypeConverter<AreaMomentOfInertia<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
-            Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(1), converter.ConvertFrom(context, culture, "1m⁴"));
-            Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(1), converter.ConvertFrom(context, culture, "1m^4"));
+            Assert.Equal(AreaMomentOfInertia<double>.FromMetersToTheFourth(1), converter.ConvertFrom(context, culture, "1m⁴"));
+            Assert.Equal(AreaMomentOfInertia<double>.FromMetersToTheFourth(1), converter.ConvertFrom(context, culture, "1m^4"));
         }
 
         [Fact]
         public void ConvertFrom_GivenStringWithPower_minus1()
         {
-            var converter = new QuantityTypeConverter<CoefficientOfThermalExpansion>();
+            var converter = new QuantityTypeConverter<CoefficientOfThermalExpansion<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
-            Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K⁻¹"));
-            Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K^-1"));
+            Assert.Equal(CoefficientOfThermalExpansion<double>.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K⁻¹"));
+            Assert.Equal(CoefficientOfThermalExpansion<double>.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K^-1"));
         }
 
         [Fact]
         public void ConvertFrom_GivenStringWithPower_minus2()
         {
-            var converter = new QuantityTypeConverter<MassFlux>();
+            var converter = new QuantityTypeConverter<MassFlux<double>>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
-            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg·s⁻¹·m⁻²"));
-            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg·s^-1·m^-2"));
-            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg*s^-1*m^-2"));
+            Assert.Equal(MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg·s⁻¹·m⁻²"));
+            Assert.Equal(MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg·s^-1·m^-2"));
+            Assert.Equal(MassFlux<double>.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg*s^-1*m^-2"));
         }
     }
 }
diff --git a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
index 5103231a36..6d554ba7d3 100644
--- a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
+++ b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
@@ -37,7 +37,7 @@ public UnitAbbreviationsCacheTests(ITestOutputHelper output)
         [InlineData(0.115, "0.12 m")]
         public void DefaultToStringFormatting(double value, string expected)
         {
-            string actual = Length.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
+            string actual = Length<double>.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
             Assert.Equal(expected, actual);
         }
 
@@ -59,7 +59,7 @@ private enum CustomUnit
         [InlineData("it-IT")]
         public void CommaRadixPointCultureFormatting(string culture)
         {
-            Assert.Equal("0,12 m", Length.FromMeters(0.12).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
+            Assert.Equal("0,12 m", Length<double>.FromMeters(0.12).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
         }
 
         // These cultures all use a decimal point for the radix point
@@ -71,7 +71,7 @@ public void CommaRadixPointCultureFormatting(string culture)
         [InlineData("es-MX")]
         public void DecimalRadixPointCultureFormatting(string culture)
         {
-            Assert.Equal("0.12 m", Length.FromMeters(0.12).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
+            Assert.Equal("0.12 m", Length<double>.FromMeters(0.12).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
         }
 
         // These cultures all use a comma in digit grouping
@@ -84,14 +84,14 @@ public void DecimalRadixPointCultureFormatting(string culture)
         public void CommaDigitGroupingCultureFormatting(string cultureName)
         {
             CultureInfo culture = GetCulture(cultureName);
-            Assert.Equal("1,111 m", Length.FromMeters(1111).ToUnit(LengthUnit.Meter).ToString(culture));
+            Assert.Equal("1,111 m", Length<double>.FromMeters(1111).ToUnit(LengthUnit.Meter).ToString(culture));
 
             // Feet/Inch and Stone/Pound combinations are only used (customarily) in the US, UK and maybe Ireland - all English speaking countries.
             // FeetInches returns a whole number of feet, with the remainder expressed (rounded) in inches. Same for SonePounds.
             Assert.Equal("2,222 ft 3 in",
-                Length.FromFeetInches(2222, 3).FeetInches.ToString(culture));
+                Length<double>.FromFeetInches(2222, 3).FeetInches.ToString(culture));
             Assert.Equal("3,333 st 7 lb",
-                Mass.FromStonePounds(3333, 7).StonePounds.ToString(culture));
+                Mass<double>.FromStonePounds(3333, 7).StonePounds.ToString(culture));
         }
 
         // These cultures use a thin space in digit grouping
@@ -101,7 +101,7 @@ public void CommaDigitGroupingCultureFormatting(string cultureName)
         public void SpaceDigitGroupingCultureFormatting(string culture)
         {
             // Note: the space used in digit groupings is actually a "thin space" Unicode character U+2009
-            Assert.Equal("1 111 m", Length.FromMeters(1111).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
+            Assert.Equal("1 111 m", Length<double>.FromMeters(1111).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
         }
 
         // These cultures all use a decimal point in digit grouping
@@ -113,7 +113,7 @@ public void SpaceDigitGroupingCultureFormatting(string culture)
         [InlineData("it-IT")]
         public void DecimalPointDigitGroupingCultureFormatting(string culture)
         {
-            Assert.Equal("1.111 m", Length.FromMeters(1111).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
+            Assert.Equal("1.111 m", Length<double>.FromMeters(1111).ToUnit(LengthUnit.Meter).ToString(GetCulture(culture)));
         }
 
         // Due to rounding, the values will result in the same string representation regardless of the number of significant digits (up to a certain point)
@@ -127,7 +127,7 @@ public void DecimalPointDigitGroupingCultureFormatting(string culture)
         public void RoundingErrorsWithSignificantDigitsAfterRadixFormatting(double value,
             string significantDigitsAfterRadixFormatString, string expected)
         {
-            string actual = Length.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(significantDigitsAfterRadixFormatString, AmericanCulture);
+            string actual = Length<double>.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(significantDigitsAfterRadixFormatString, AmericanCulture);
             Assert.Equal(expected, actual);
         }
 
@@ -139,7 +139,7 @@ public void RoundingErrorsWithSignificantDigitsAfterRadixFormatting(double value
         [InlineData(1.99e-4, "1.99e-04 m")]
         public void ScientificNotationLowerInterval(double value, string expected)
         {
-            string actual = Length.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
+            string actual = Length<double>.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
             Assert.Equal(expected, actual);
         }
 
@@ -150,7 +150,7 @@ public void ScientificNotationLowerInterval(double value, string expected)
         [InlineData(999.99, "999.99 m")]
         public void FixedPointNotationIntervalFormatting(double value, string expected)
         {
-            string actual = Length.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
+            string actual = Length<double>.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
             Assert.Equal(expected, actual);
         }
 
@@ -162,7 +162,7 @@ public void FixedPointNotationIntervalFormatting(double value, string expected)
         [InlineData(999999.99, "999,999.99 m")]
         public void FixedPointNotationWithDigitGroupingIntervalFormatting(double value, string expected)
         {
-            string actual = Length.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
+            string actual = Length<double>.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
             Assert.Equal(expected, actual);
         }
 
@@ -173,62 +173,62 @@ public void FixedPointNotationWithDigitGroupingIntervalFormatting(double value,
         [InlineData(double.MaxValue, "1.8e+308 m")]
         public void ScientificNotationUpperIntervalFormatting(double value, string expected)
         {
-            string actual = Length.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
+            string actual = Length<double>.FromMeters(value).ToUnit(LengthUnit.Meter).ToString(AmericanCulture);
             Assert.Equal(expected, actual);
         }
 
         [Fact]
         public void AllUnitsImplementToStringForInvariantCulture()
         {
-            Assert.Equal("1 °", Angle.FromDegrees(1).ToString());
-            Assert.Equal("1 m²", Area.FromSquareMeters(1).ToString());
-            Assert.Equal("1 V", ElectricPotential.FromVolts(1).ToString());
-            Assert.Equal("1 N", Force.FromNewtons(1).ToString());
-            Assert.Equal("1 m", Length.FromMeters(1).ToString());
-            Assert.Equal("1 kg", Mass.FromKilograms(1).ToString());
-            Assert.Equal("1 Pa", Pressure.FromPascals(1).ToString());
-            Assert.Equal("1 rad/s", RotationalSpeed.FromRadiansPerSecond(1).ToString());
-            Assert.Equal("1 K", Temperature.FromKelvins(1).ToString());
-            Assert.Equal("1 N·m", Torque.FromNewtonMeters(1).ToString());
-            Assert.Equal("1 m³", Volume.FromCubicMeters(1).ToString());
-            Assert.Equal("1 m³/s", VolumeFlow.FromCubicMetersPerSecond(1).ToString());
-
-            Assert.Equal("2 ft 3 in", Length.FromFeetInches(2, 3).FeetInches.ToString());
-            Assert.Equal("3 st 7 lb", Mass.FromStonePounds(3, 7).StonePounds.ToString());
+            Assert.Equal("1 °", Angle<double>.FromDegrees(1).ToString());
+            Assert.Equal("1 m²", Area<double>.FromSquareMeters(1).ToString());
+            Assert.Equal("1 V", ElectricPotential<double>.FromVolts(1).ToString());
+            Assert.Equal("1 N", Force<double>.FromNewtons(1).ToString());
+            Assert.Equal("1 m", Length<double>.FromMeters(1).ToString());
+            Assert.Equal("1 kg", Mass<double>.FromKilograms(1).ToString());
+            Assert.Equal("1 Pa", Pressure<double>.FromPascals(1).ToString());
+            Assert.Equal("1 rad/s", RotationalSpeed<double>.FromRadiansPerSecond(1).ToString());
+            Assert.Equal("1 K", Temperature<double>.FromKelvins(1).ToString());
+            Assert.Equal("1 N·m", Torque<double>.FromNewtonMeters(1).ToString());
+            Assert.Equal("1 m³", Volume<double>.FromCubicMeters(1).ToString());
+            Assert.Equal("1 m³/s", VolumeFlow<double>.FromCubicMetersPerSecond(1).ToString());
+
+            Assert.Equal("2 ft 3 in", Length<double>.FromFeetInches(2, 3).FeetInches.ToString());
+            Assert.Equal("3 st 7 lb", Mass<double>.FromStonePounds(3, 7).StonePounds.ToString());
         }
 
         [Fact]
         public void ToString_WithNorwegianCulture()
         {
-            Assert.Equal("1 °", Angle.FromDegrees(1).ToUnit(AngleUnit.Degree).ToString(NorwegianCulture));
-            Assert.Equal("1 m²", Area.FromSquareMeters(1).ToUnit(AreaUnit.SquareMeter).ToString(NorwegianCulture));
-            Assert.Equal("1 V", ElectricPotential.FromVolts(1).ToUnit(ElectricPotentialUnit.Volt).ToString(NorwegianCulture));
-            Assert.Equal("1 m³/s", VolumeFlow.FromCubicMetersPerSecond(1).ToUnit(VolumeFlowUnit.CubicMeterPerSecond).ToString(NorwegianCulture));
-            Assert.Equal("1 N", Force.FromNewtons(1).ToUnit(ForceUnit.Newton).ToString(NorwegianCulture));
-            Assert.Equal("1 m", Length.FromMeters(1).ToUnit(LengthUnit.Meter).ToString(NorwegianCulture));
-            Assert.Equal("1 kg", Mass.FromKilograms(1).ToUnit(MassUnit.Kilogram).ToString(NorwegianCulture));
-            Assert.Equal("1 Pa", Pressure.FromPascals(1).ToUnit(PressureUnit.Pascal).ToString(NorwegianCulture));
-            Assert.Equal("1 rad/s", RotationalSpeed.FromRadiansPerSecond(1).ToUnit(RotationalSpeedUnit.RadianPerSecond).ToString(NorwegianCulture));
-            Assert.Equal("1 K", Temperature.FromKelvins(1).ToUnit(TemperatureUnit.Kelvin).ToString(NorwegianCulture));
-            Assert.Equal("1 N·m", Torque.FromNewtonMeters(1).ToUnit(TorqueUnit.NewtonMeter).ToString(NorwegianCulture));
-            Assert.Equal("1 m³", Volume.FromCubicMeters(1).ToUnit(VolumeUnit.CubicMeter).ToString(NorwegianCulture));
+            Assert.Equal("1 °", Angle<double>.FromDegrees(1).ToUnit(AngleUnit.Degree).ToString(NorwegianCulture));
+            Assert.Equal("1 m²", Area<double>.FromSquareMeters(1).ToUnit(AreaUnit.SquareMeter).ToString(NorwegianCulture));
+            Assert.Equal("1 V", ElectricPotential<double>.FromVolts(1).ToUnit(ElectricPotentialUnit.Volt).ToString(NorwegianCulture));
+            Assert.Equal("1 m³/s", VolumeFlow<double>.FromCubicMetersPerSecond(1).ToUnit(VolumeFlowUnit.CubicMeterPerSecond).ToString(NorwegianCulture));
+            Assert.Equal("1 N", Force<double>.FromNewtons(1).ToUnit(ForceUnit.Newton).ToString(NorwegianCulture));
+            Assert.Equal("1 m", Length<double>.FromMeters(1).ToUnit(LengthUnit.Meter).ToString(NorwegianCulture));
+            Assert.Equal("1 kg", Mass<double>.FromKilograms(1).ToUnit(MassUnit.Kilogram).ToString(NorwegianCulture));
+            Assert.Equal("1 Pa", Pressure<double>.FromPascals(1).ToUnit(PressureUnit.Pascal).ToString(NorwegianCulture));
+            Assert.Equal("1 rad/s", RotationalSpeed<double>.FromRadiansPerSecond(1).ToUnit(RotationalSpeedUnit.RadianPerSecond).ToString(NorwegianCulture));
+            Assert.Equal("1 K", Temperature<double>.FromKelvins(1).ToUnit(TemperatureUnit.Kelvin).ToString(NorwegianCulture));
+            Assert.Equal("1 N·m", Torque<double>.FromNewtonMeters(1).ToUnit(TorqueUnit.NewtonMeter).ToString(NorwegianCulture));
+            Assert.Equal("1 m³", Volume<double>.FromCubicMeters(1).ToUnit(VolumeUnit.CubicMeter).ToString(NorwegianCulture));
         }
 
         [Fact]
         public void ToString_WithRussianCulture()
         {
-            Assert.Equal("1 °", Angle.FromDegrees(1).ToUnit(AngleUnit.Degree).ToString(RussianCulture));
-            Assert.Equal("1 м²", Area.FromSquareMeters(1).ToUnit(AreaUnit.SquareMeter).ToString(RussianCulture));
-            Assert.Equal("1 В", ElectricPotential.FromVolts(1).ToUnit(ElectricPotentialUnit.Volt).ToString(RussianCulture));
-            Assert.Equal("1 м³/с", VolumeFlow.FromCubicMetersPerSecond(1).ToUnit(VolumeFlowUnit.CubicMeterPerSecond).ToString(RussianCulture));
-            Assert.Equal("1 Н", Force.FromNewtons(1).ToUnit(ForceUnit.Newton).ToString(RussianCulture));
-            Assert.Equal("1 м", Length.FromMeters(1).ToUnit(LengthUnit.Meter).ToString(RussianCulture));
-            Assert.Equal("1 кг", Mass.FromKilograms(1).ToUnit(MassUnit.Kilogram).ToString(RussianCulture));
-            Assert.Equal("1 Па", Pressure.FromPascals(1).ToUnit(PressureUnit.Pascal).ToString(RussianCulture));
-            Assert.Equal("1 рад/с", RotationalSpeed.FromRadiansPerSecond(1).ToUnit(RotationalSpeedUnit.RadianPerSecond).ToString(RussianCulture));
-            Assert.Equal("1 K", Temperature.FromKelvins(1).ToUnit(TemperatureUnit.Kelvin).ToString(RussianCulture));
-            Assert.Equal("1 Н·м", Torque.FromNewtonMeters(1).ToUnit(TorqueUnit.NewtonMeter).ToString(RussianCulture));
-            Assert.Equal("1 м³", Volume.FromCubicMeters(1).ToUnit(VolumeUnit.CubicMeter).ToString(RussianCulture));
+            Assert.Equal("1 °", Angle<double>.FromDegrees(1).ToUnit(AngleUnit.Degree).ToString(RussianCulture));
+            Assert.Equal("1 м²", Area<double>.FromSquareMeters(1).ToUnit(AreaUnit.SquareMeter).ToString(RussianCulture));
+            Assert.Equal("1 В", ElectricPotential<double>.FromVolts(1).ToUnit(ElectricPotentialUnit.Volt).ToString(RussianCulture));
+            Assert.Equal("1 м³/с", VolumeFlow<double>.FromCubicMetersPerSecond(1).ToUnit(VolumeFlowUnit.CubicMeterPerSecond).ToString(RussianCulture));
+            Assert.Equal("1 Н", Force<double>.FromNewtons(1).ToUnit(ForceUnit.Newton).ToString(RussianCulture));
+            Assert.Equal("1 м", Length<double>.FromMeters(1).ToUnit(LengthUnit.Meter).ToString(RussianCulture));
+            Assert.Equal("1 кг", Mass<double>.FromKilograms(1).ToUnit(MassUnit.Kilogram).ToString(RussianCulture));
+            Assert.Equal("1 Па", Pressure<double>.FromPascals(1).ToUnit(PressureUnit.Pascal).ToString(RussianCulture));
+            Assert.Equal("1 рад/с", RotationalSpeed<double>.FromRadiansPerSecond(1).ToUnit(RotationalSpeedUnit.RadianPerSecond).ToString(RussianCulture));
+            Assert.Equal("1 K", Temperature<double>.FromKelvins(1).ToUnit(TemperatureUnit.Kelvin).ToString(RussianCulture));
+            Assert.Equal("1 Н·м", Torque<double>.FromNewtonMeters(1).ToUnit(TorqueUnit.NewtonMeter).ToString(RussianCulture));
+            Assert.Equal("1 м³", Volume<double>.FromCubicMeters(1).ToUnit(VolumeUnit.CubicMeter).ToString(RussianCulture));
         }
 
         [Fact]
@@ -293,7 +293,7 @@ public void MapUnitToDefaultAbbreviation_GivenCustomAbbreviation_SetsAbbreviatio
             var newZealandCulture = GetCulture("en-NZ");
             UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(AreaUnit.SquareMeter, newZealandCulture, "m^2");
 
-            Assert.Equal("1 m^2", Area.FromSquareMeters(1).ToString(newZealandCulture));
+            Assert.Equal("1 m^2", Area<double>.FromSquareMeters(1).ToString(newZealandCulture));
         }
 
         /// <summary>
diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs
index 9de3a67e94..88c041b004 100644
--- a/UnitsNet.Tests/UnitConverterTest.cs
+++ b/UnitsNet.Tests/UnitConverterTest.cs
@@ -12,77 +12,77 @@ public class UnitConverterTest
         [Fact]
         public void CustomConversionWithSameQuantityType()
         {
-            Length ConversionFunction(Length from) => Length.FromInches(18);
+            Length<double> ConversionFunction(Length<double> from ) => Length<double>.FromInches(18);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
+            var unitConverter = new UnitConverter<double>();
+            unitConverter.SetConversionFunction<Length<double>>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch);
-            var converted = foundConversionFunction(Length.FromMeters(1.0));
+            var foundConversionFunction = unitConverter.GetConversionFunction<Length<double>>(LengthUnit.Meter, LengthUnit.Inch);
+            var converted = foundConversionFunction(Length<double>.FromMeters(1.0));
 
-            Assert.Equal(Length.FromInches(18), converted);
+            Assert.Equal(Length<double>.FromInches(18), converted);
         }
 
         [Fact]
         public void CustomConversionWithSameQuantityTypeByTypeParam()
         {
-            Length ConversionFunction(Length from) => Length.FromInches(18);
+            Length<double> ConversionFunction(Length<double> from ) => Length<double>.FromInches(18);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, (ConversionFunction<Length>) ConversionFunction);
+            var unitConverter = new UnitConverter<double>();
+            unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, (ConversionFunction<Length<double>>) ConversionFunction);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Length), LengthUnit.Meter, typeof(Length), LengthUnit.Inch);
-            var converted = foundConversionFunction(Length.FromMeters(1.0));
+            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Length<double>), LengthUnit.Meter, typeof(Length<double>), LengthUnit.Inch);
+            var converted = foundConversionFunction(Length<double>.FromMeters(1.0));
 
-            Assert.Equal(Length.FromInches(18), converted);
+            Assert.Equal(Length<double>.FromInches(18), converted);
         }
 
         [Fact]
         public void CustomConversionWithDifferentQuantityTypes()
         {
-            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+            IQuantity ConversionFunction(IQuantity from) => Length<double>.FromInches(18);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+            var unitConverter = new UnitConverter<double>();
+            unitConverter.SetConversionFunction<Mass<double>, Length<double>>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch);
-            var converted = foundConversionFunction(Mass.FromGrains(100));
+            var foundConversionFunction = unitConverter.GetConversionFunction<Mass<double>, Length<double>>(MassUnit.Grain, LengthUnit.Inch);
+            var converted = foundConversionFunction(Mass<double>.FromGrains(100));
 
-            Assert.Equal(Length.FromInches(18), converted);
+            Assert.Equal(Length<double>.FromInches(18), converted);
         }
 
         [Fact]
         public void CustomConversionWithDifferentQuantityTypesByTypeParam()
         {
-            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+            IQuantity ConversionFunction(IQuantity from) => Length<double>.FromInches(18);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+            var unitConverter = new UnitConverter<double>();
+            unitConverter.SetConversionFunction<Mass<double>, Length<double>>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Mass), MassUnit.Grain, typeof(Length), LengthUnit.Inch);
-            var converted = foundConversionFunction(Mass.FromGrains(100));
+            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Mass<double>), MassUnit.Grain, typeof(Length<double>), LengthUnit.Inch);
+            var converted = foundConversionFunction(Mass<double>.FromGrains(100));
 
-            Assert.Equal(Length.FromInches(18), converted);
+            Assert.Equal(Length<double>.FromInches(18), converted);
         }
 
         [Fact]
         public void TryCustomConversionForOilBarrelsToUsGallons()
         {
-            Volume ConversionFunction(Volume from) => Volume.FromUsGallons(from.Value * 42);
+            Volume<double> ConversionFunction(Volume<double> from ) => Volume<double>.FromUsGallons(from.Value * 42);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, ConversionFunction);
+            var unitConverter = new UnitConverter<double>();
+            unitConverter.SetConversionFunction<Volume<double>>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, ConversionFunction);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon);
-            var converted = foundConversionFunction(Volume.FromOilBarrels(1));
+            var foundConversionFunction = unitConverter.GetConversionFunction<Volume<double>>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon);
+            var converted = foundConversionFunction(Volume<double>.FromOilBarrels(1));
 
-            Assert.Equal(Volume.FromUsGallons(42), converted);
+            Assert.Equal(Volume<double>.FromUsGallons(42), converted);
         }
 
         [Fact]
         public void ConversionToSameUnit_ReturnsSameQuantity()
         {
-            var unitConverter = new UnitConverter();
+            var unitConverter = new UnitConverter<double>();
 
             var foundConversionFunction = unitConverter.GetConversionFunction<HowMuch>(HowMuchUnit.ATon, HowMuchUnit.ATon);
             var converted = foundConversionFunction(new HowMuch(39, HowMuchUnit.Some)); // Intentionally pass the wrong unit here, to test that the exact same quantity is returned
@@ -98,7 +98,7 @@ public void ConversionToSameUnit_ReturnsSameQuantity()
         public void ConversionForUnitsOfCustomQuantity(double fromValue, HowMuchUnit fromUnit, HowMuchUnit toUnit, double expectedValue)
         {
             // Intentionally don't map conversion Some->Some, it is not necessary
-            var unitConverter = new UnitConverter();
+            var unitConverter = new UnitConverter<double>();
             unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.ATon, x => new HowMuch(x.Value * 2, HowMuchUnit.ATon));
             unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.AShitTon, x => new HowMuch(x.Value * 10, HowMuchUnit.AShitTon));
 
@@ -117,26 +117,26 @@ public void ConversionForUnitsOfCustomQuantity(double fromValue, HowMuchUnit fro
         [InlineData(1000, 1, "ElectricCurrent", "Kiloampere", "Ampere")]
         public void ConvertByName_ConvertsTheValueToGivenUnit(double expectedValue, double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.Equal(expectedValue, UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Equal(expectedValue, UnitConverter<double>.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
         [Fact]
         public void ConvertByName_QuantityCaseInsensitive()
         {
-            Assert.Equal(0, UnitConverter.ConvertByName(0, "length", "Meter", "Centimeter"));
+            Assert.Equal(0, UnitConverter<double>.ConvertByName(0, "length", "Meter", "Centimeter"));
         }
 
         [Fact]
         public void ConvertByName_UnitTypeCaseInsensitive()
         {
-            Assert.Equal(0, UnitConverter.ConvertByName(0, "Length", "meter", "Centimeter"));
+            Assert.Equal(0, UnitConverter<double>.ConvertByName(0, "Length", "meter", "Centimeter"));
         }
 
         [Theory]
         [InlineData(1, "UnknownQuantity", "Meter", "Centimeter")]
         public void ConvertByName_ThrowsUnitNotFoundExceptionOnUnknownQuantity(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter<double>.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
         [Theory]
@@ -144,7 +144,7 @@ public void ConvertByName_ThrowsUnitNotFoundExceptionOnUnknownQuantity(double in
         [InlineData(1, "Length", "Meter", "UnknownToUnit")]
         public void ConvertByName_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnit(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter<double>.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
         [Theory]
@@ -153,7 +153,7 @@ public void ConvertByName_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnit(doubl
         [InlineData(1, "Length", "Meter", "UnknownToUnit")]
         public void TryConvertByName_ReturnsFalseForInvalidInput(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.False(UnitConverter.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out double result));
+            Assert.False(UnitConverter<double>.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out double result));
             Assert.Equal(0, result);
         }
 
@@ -165,7 +165,7 @@ public void TryConvertByName_ReturnsFalseForInvalidInput(double inputValue, stri
         public void TryConvertByName_ReturnsTrueOnSuccessAndOutputsResult(double expectedValue, double inputValue, string quantityTypeName, string fromUnit,
             string toUnit)
         {
-            Assert.True(UnitConverter.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out double result), "TryConvertByName() return value.");
+            Assert.True(UnitConverter<double>.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out double result), "TryConvertByName() return value.");
             Assert.Equal(expectedValue, result);
         }
 
@@ -176,14 +176,14 @@ public void TryConvertByName_ReturnsTrueOnSuccessAndOutputsResult(double expecte
         [InlineData(1000, 1, "ElectricCurrent", "kA", "A")]
         public void ConvertByAbbreviation_ConvertsTheValueToGivenUnit(double expectedValue, double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.Equal(expectedValue, UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Equal(expectedValue, UnitConverter<double>.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
         [Theory]
         [InlineData(1, "UnknownQuantity", "m", "cm")]
         public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownQuantity( double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter<double>.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
         [Theory]
@@ -191,7 +191,7 @@ public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownQuantity(
         [InlineData(1, "Length", "m", "UnknownToUnit")]
         public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnitAbbreviation(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter<double>.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
         [Theory]
@@ -200,7 +200,7 @@ public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUn
         [InlineData(1, "Length", "m", "UnknownToUnit")]
         public void TryConvertByAbbreviation_ReturnsFalseForInvalidInput(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.False(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out double result));
+            Assert.False(UnitConverter<double>.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out double result));
             Assert.Equal(0, result);
         }
 
@@ -212,7 +212,7 @@ public void TryConvertByAbbreviation_ReturnsFalseForInvalidInput(double inputVal
         public void TryConvertByAbbreviation_ReturnsTrueOnSuccessAndOutputsResult(double expectedValue, double inputValue, string quantityTypeName, string fromUnit,
             string toUnit)
         {
-            Assert.True(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out double result), "TryConvertByAbbreviation() return value.");
+            Assert.True(UnitConverter<double>.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out double result), "TryConvertByAbbreviation() return value.");
             Assert.Equal(expectedValue, result);
         }
     }
diff --git a/UnitsNet.Tests/UnitMathTests.cs b/UnitsNet.Tests/UnitMathTests.cs
index 1951549863..80208a3c58 100644
--- a/UnitsNet.Tests/UnitMathTests.cs
+++ b/UnitsNet.Tests/UnitMathTests.cs
@@ -48,17 +48,17 @@ public void AbsoluteValueOfNullReferenceThrowsException()
         [Fact]
         public void AverageOfDifferentUnitsThrowsException()
         {
-            var units = new IQuantity[] {Length.FromMeters(1), Volume.FromLiters(50)};
+            var units = new IQuantity[] {Length<double>.FromMeters(1), Volume<double>.FromLiters(50)};
 
-            Assert.Throws<ArgumentException>(() => units.Average(LengthUnit.Centimeter));
+            Assert.Throws<ArgumentException>(() => units.Average<IQuantity, double>(LengthUnit.Centimeter));
         }
 
         [Fact]
         public void AverageOfEmptySourceThrowsException()
         {
-            var units = new Length[] { };
+            var units = new Length<double>[] { };
 
-            Assert.Throws<InvalidOperationException>(() => units.Average(LengthUnit.Centimeter));
+            Assert.Throws<InvalidOperationException>(() => units.Average<Length<double>, double>(LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -72,9 +72,9 @@ public void AverageOfLengthsWithNullValueThrowsException()
         [Fact]
         public void AverageOfLengthsCalculatesCorrectly()
         {
-            var units = new[] {Length.FromMeters(1), Length.FromCentimeters(50)};
+            var units = new[] {Length<double>.FromMeters(1), Length<double>.FromCentimeters(50)};
 
-            Length average = units.Average(LengthUnit.Centimeter);
+            var average = units.Average<Length<double>, double>( LengthUnit.Centimeter);
 
             Assert.Equal(75, average.Value);
             Assert.Equal(LengthUnit.Centimeter, average.Unit);
@@ -85,11 +85,11 @@ public void AverageOfLengthsWithNullSelectorThrowsException()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Assert.Throws<ArgumentNullException>(() => units.Average((Func<KeyValuePair<string, Length>, Length>) null, LengthUnit.Centimeter));
+            Assert.Throws<ArgumentNullException>(() => units.Average<KeyValuePair<string, Length<double>>, Length<double>, double>((Func<KeyValuePair<string, Length<double>>, Length<double>>) null, LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -97,11 +97,11 @@ public void AverageOfLengthsWithSelectorCalculatesCorrectly()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Length average = units.Average(x => x.Value, LengthUnit.Centimeter);
+            var average = units.Average<KeyValuePair<string, Length<double>>, Length<double>, double>( x => x.Value, LengthUnit.Centimeter);
 
             Assert.Equal(75, average.Value);
             Assert.Equal(LengthUnit.Centimeter, average.Unit);
@@ -122,9 +122,9 @@ public void MaxOfTwoLengthsReturnsTheLargestValue()
         [Fact]
         public void MaxOfDifferentUnitsThrowsException()
         {
-            var units = new IQuantity[] {Length.FromMeters(1), Volume.FromLiters(50)};
+            var units = new IQuantity[] {Length<double>.FromMeters(1), Volume<double>.FromLiters(50)};
 
-            Assert.Throws<ArgumentException>(() => units.Max(LengthUnit.Centimeter));
+            Assert.Throws<ArgumentException>(() => units.Max<IQuantity, double>(LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -138,17 +138,17 @@ public void MaxOfLengthsWithNullValueThrowsException()
         [Fact]
         public void MaxOfEmptySourceThrowsException()
         {
-            var units = new Length[] { };
+            var units = new Length<double>[] { };
 
-            Assert.Throws<InvalidOperationException>(() => units.Max(LengthUnit.Centimeter));
+            Assert.Throws<InvalidOperationException>(() => units.Max<Length<double>, double>(LengthUnit.Centimeter));
         }
 
         [Fact]
         public void MaxOfLengthsCalculatesCorrectly()
         {
-            var units = new[] {Length.FromMeters(1), Length.FromCentimeters(50)};
+            var units = new[] {Length<double>.FromMeters(1), Length<double>.FromCentimeters(50)};
 
-            Length max = units.Max(LengthUnit.Centimeter);
+            var max = units.Max<Length<double>, double>(LengthUnit.Centimeter);
 
             Assert.Equal(100, max.Value);
             Assert.Equal(LengthUnit.Centimeter, max.Unit);
@@ -159,11 +159,11 @@ public void MaxOfLengthsWithNullSelectorThrowsException()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Assert.Throws<ArgumentNullException>(() => units.Max((Func<KeyValuePair<string, Length>, Length>) null, LengthUnit.Centimeter));
+            Assert.Throws<ArgumentNullException>(() => units.Max<KeyValuePair<string, Length<double>>, Length<double>, double>( (Func<KeyValuePair<string, Length<double>>, Length<double>>) null, LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -171,11 +171,11 @@ public void MaxOfLengthsWithSelectorCalculatesCorrectly()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Length max = units.Max(x => x.Value, LengthUnit.Centimeter);
+            var max = units.Max<KeyValuePair<string, Length<double>>, Length<double>, double>( x => x.Value, LengthUnit.Centimeter);
 
             Assert.Equal(100, max.Value);
             Assert.Equal(LengthUnit.Centimeter, max.Unit);
@@ -196,9 +196,9 @@ public void MinOfTwoLengthsReturnsTheSmallestValue()
         [Fact]
         public void MinOfDifferentUnitsThrowsException()
         {
-            var units = new IQuantity[] {Length.FromMeters(1), Volume.FromLiters(50)};
+            var units = new IQuantity[] {Length<double>.FromMeters(1), Volume<double>.FromLiters(50)};
 
-            Assert.Throws<ArgumentException>(() => units.Min(LengthUnit.Centimeter));
+            Assert.Throws<ArgumentException>(() => units.Min<IQuantity, double>(LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -212,17 +212,17 @@ public void MinOfLengthsWithNullValueThrowsException()
         [Fact]
         public void MinOfEmptySourceThrowsException()
         {
-            var units = new Length[] { };
+            var units = new Length<double>[] { };
 
-            Assert.Throws<InvalidOperationException>(() => units.Min(LengthUnit.Centimeter));
+            Assert.Throws<InvalidOperationException>(() => units.Min<Length<double>, double>(LengthUnit.Centimeter));
         }
 
         [Fact]
         public void MinOfLengthsCalculatesCorrectly()
         {
-            var units = new[] {Length.FromMeters(1), Length.FromCentimeters(50)};
+            var units = new[] {Length<double>.FromMeters(1), Length<double>.FromCentimeters(50)};
 
-            Length min = units.Min(LengthUnit.Centimeter);
+            var min = units.Min<Length<double>, double>(LengthUnit.Centimeter);
 
             Assert.Equal(50, min.Value);
             Assert.Equal(LengthUnit.Centimeter, min.Unit);
@@ -233,11 +233,11 @@ public void MinOfLengthsWithNullSelectorThrowsException()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Assert.Throws<ArgumentNullException>(() => units.Min((Func<KeyValuePair<string, Length>, Length>) null, LengthUnit.Centimeter));
+            Assert.Throws<ArgumentNullException>(() => units.Min<KeyValuePair<string, Length<double>>, Length<double>, double>( (Func<KeyValuePair<string, Length<double>>, Length<double>>) null, LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -245,11 +245,11 @@ public void MinOfLengthsWithSelectorCalculatesCorrectly()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Length min = units.Min(x => x.Value, LengthUnit.Centimeter);
+            var min = units.Min<KeyValuePair<string, Length<double>>, Length<double>, double>(x => x.Value, LengthUnit.Centimeter);
 
             Assert.Equal(50, min.Value);
             Assert.Equal(LengthUnit.Centimeter, min.Unit);
@@ -258,9 +258,9 @@ public void MinOfLengthsWithSelectorCalculatesCorrectly()
         [Fact]
         public void SumOfDifferentUnitsThrowsException()
         {
-            var units = new IQuantity[] {Length.FromMeters(1), Volume.FromLiters(50)};
+            var units = new IQuantity[] {Length<double>.FromMeters(1), Volume<double>.FromLiters(50)};
 
-            Assert.Throws<ArgumentException>(() => units.Sum(LengthUnit.Centimeter));
+            Assert.Throws<ArgumentException>(() => units.Sum<IQuantity, double>(LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -274,19 +274,19 @@ public void SumOfLengthsWithNullValueThrowsException()
         [Fact]
         public void SumOfEmptySourceReturnsZero()
         {
-            var units = new Length[] { };
+            var units = new Length<double>[] { };
 
-            Length sum = units.Sum(Length.BaseUnit);
+            var sum = units.Sum<Length<double>, double>(Length<double>.BaseUnit);
 
-            Assert.Equal(Length.Zero, sum);
+            Assert.Equal(Length<double>.Zero, sum);
         }
 
         [Fact]
         public void SumOfLengthsCalculatesCorrectly()
         {
-            var units = new[] {Length.FromMeters(1), Length.FromCentimeters(50)};
+            var units = new[] {Length<double>.FromMeters(1), Length<double>.FromCentimeters(50)};
 
-            Length sum = units.Sum(LengthUnit.Centimeter);
+            var sum = units.Sum<Length<double>, double>(LengthUnit.Centimeter);
 
             Assert.Equal(150, sum.Value);
             Assert.Equal(LengthUnit.Centimeter, sum.Unit);
@@ -297,11 +297,11 @@ public void SumOfLengthsWithNullSelectorThrowsException()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Assert.Throws<ArgumentNullException>(() => units.Sum((Func<KeyValuePair<string, Length>, Length>) null, LengthUnit.Centimeter));
+            Assert.Throws<ArgumentNullException>(() => units.Sum<KeyValuePair<string, Length<double>>, Length<double>, double>( (Func<KeyValuePair<string, Length<double>>, Length<double>>) null, LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -309,11 +309,11 @@ public void SumOfLengthsWithSelectorCalculatesCorrectly()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length<double>>("1", Length<double>.FromMeters(1)),
+                new KeyValuePair<string, Length<double>>("2", Length<double>.FromCentimeters(50))
             };
 
-            Length sum = units.Sum(x => x.Value, LengthUnit.Centimeter);
+            var sum = units.Sum<KeyValuePair<string, Length<double>>, Length<double>, double>( x => x.Value, LengthUnit.Centimeter);
 
             Assert.Equal(150, sum.Value);
             Assert.Equal(LengthUnit.Centimeter, sum.Unit);
diff --git a/UnitsNet.Tests/UnitParserTests.cs b/UnitsNet.Tests/UnitParserTests.cs
index 08411f0a24..7df073d75f 100644
--- a/UnitsNet.Tests/UnitParserTests.cs
+++ b/UnitsNet.Tests/UnitParserTests.cs
@@ -53,8 +53,8 @@ public void Parse_AbbreviationCaseInsensitive_Uppercase_Years()
         [Fact]
         public void Parse_GivenAbbreviationsThatAreAmbiguousWhenLowerCase_ReturnsCorrectUnit()
         {
-            Assert.Equal(PressureUnit.Megabar, Pressure.ParseUnit("Mbar"));
-            Assert.Equal(PressureUnit.Millibar, Pressure.ParseUnit("mbar"));
+            Assert.Equal(PressureUnit.Megabar, Pressure<double>.ParseUnit("Mbar"));
+            Assert.Equal(PressureUnit.Millibar, Pressure<double>.ParseUnit("mbar"));
         }
 
         [Fact]
@@ -107,7 +107,7 @@ public void Parse_AmbiguousUnitsThrowsException()
             var exception1 = Assert.Throws<AmbiguousUnitParseException>(() => UnitParser.Default.Parse<LengthUnit>("pt"));
 
             // Act 2
-            var exception2 = Assert.Throws<AmbiguousUnitParseException>(() => Length.Parse("1 pt"));
+            var exception2 = Assert.Throws<AmbiguousUnitParseException>(() => Length<double>.Parse("1 pt"));
 
             // Assert
             Assert.Equal("Cannot parse \"pt\" since it could be either of these: DtpPoint, PrinterPoint", exception1.Message);
diff --git a/UnitsNet/Comparison.cs b/UnitsNet/Comparison.cs
index 575707e6b5..6056b2f36b 100644
--- a/UnitsNet/Comparison.cs
+++ b/UnitsNet/Comparison.cs
@@ -49,10 +49,11 @@ public static class Comparison
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">Whether the tolerance is absolute or relative.</param>
         /// <returns></returns>
-        public static bool Equals(double referenceValue, double otherValue, double tolerance, ComparisonType comparisonType)
+        public static bool Equals<T>(T referenceValue, T otherValue, T tolerance, ComparisonType comparisonType)
+            where T : struct
         {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0");
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
             switch (comparisonType)
             {
@@ -86,13 +87,15 @@ public static bool Equals(double referenceValue, double otherValue, double toler
         /// <param name="otherValue">The value to compare to.</param>
         /// <param name="tolerance">The relative tolerance. Must be greater than or equal to 0.</param>
         /// <returns>True if the two values are equal within the given relative tolerance, otherwise false.</returns>
-        public static bool EqualsRelative(double referenceValue, double otherValue, double tolerance)
+        public static bool EqualsRelative<T>(T referenceValue, T otherValue, T tolerance)
+            where T : struct
         {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0");
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            var maxVariation = Math.Abs(referenceValue * tolerance);
-            return Math.Abs(referenceValue - otherValue) <= maxVariation;
+            var maxError = CompiledLambdas.AbsoluteValue(CompiledLambdas.Multiply(referenceValue, tolerance));
+            var absoluteError = CompiledLambdas.AbsoluteValue(CompiledLambdas.Subtract(referenceValue, otherValue));
+            return CompiledLambdas.LessThanOrEqual(absoluteError, maxError);
         }
 
         /// <summary>
@@ -114,12 +117,14 @@ public static bool EqualsRelative(double referenceValue, double otherValue, doub
         /// <param name="value2">The second value.</param>
         /// <param name="tolerance">The absolute tolerance. Must be greater than or equal to 0.</param>
         /// <returns>True if the two values are equal within the given absolute tolerance, otherwise false.</returns>
-        public static bool EqualsAbsolute(double value1, double value2, double tolerance)
+        public static bool EqualsAbsolute<T>(T value1, T value2, T tolerance)
+            where T : struct
         {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0");
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return Math.Abs(value1 - value2) <= tolerance;
+            var absoluteError = CompiledLambdas.AbsoluteValue(CompiledLambdas.Subtract(value1, value2));
+            return CompiledLambdas.LessThanOrEqual(absoluteError, tolerance);
         }
     }
 }
diff --git a/UnitsNet/CompiledLambdas.cs b/UnitsNet/CompiledLambdas.cs
index 56790cadaa..bb05128830 100644
--- a/UnitsNet/CompiledLambdas.cs
+++ b/UnitsNet/CompiledLambdas.cs
@@ -9,6 +9,14 @@ namespace UnitsNet
     /// </summary>
     internal static class CompiledLambdas
     {
+        /// <summary>
+        /// Returns the absolute value.
+        /// </summary>
+        /// <typeparam name="T">The type of the value to negate.</typeparam>
+        /// <param name="value">The value to get absolute of.</param>
+        /// <returns>The absolute value.</returns>
+        internal static T AbsoluteValue<T>(T value) where T : struct => AbsoluteValueImplementation<T>.Invoke(value);
+
         /// <summary>
         /// Multiplies the given values.
         /// </summary>
@@ -198,8 +206,38 @@ internal static bool GreaterThan<TLeft, TRight>(TLeft left, TRight right) =>
         internal static bool GreaterThanOrEqual<TLeft, TRight>(TLeft left, TRight right) =>
             GreaterThanOrEqualImplementation<TLeft, TRight>.Invoke(left, right);
 
+        /// <summary>
+        /// Negates the value.
+        /// </summary>
+        /// <typeparam name="T">The type of the value to negate.</typeparam>
+        /// <param name="value">The value to negate.</param>
+        /// <returns>The negated value.</returns>
+        internal static T Negate<T>(T value) => NegateImplementation<T, T>.Invoke(value);
+
         #region Implementation Classes
 
+        private static class AbsoluteValueImplementation<T>
+            where T : struct
+        {
+            private static readonly Func<T, T> Function;
+
+            static AbsoluteValueImplementation()
+            {
+                ParameterExpression A = Expression.Parameter(typeof(T));
+                LabelTarget RETURN = Expression.Label(typeof(T));
+                Expression BODY = Expression.Block(
+                    Expression.IfThenElse(
+                        Expression.LessThan(A, Expression.Constant(default(T))),
+                        Expression.Return(RETURN, Expression.Negate(A)),
+                        Expression.Return(RETURN, A)),
+                    Expression.Label(RETURN, Expression.Constant(default(T), typeof(T))));
+
+                Function = Expression.Lambda<Func<T, T>>(BODY, A).Compile();
+            }
+
+            internal static T Invoke(T value) => Function(value);
+        }
+
         private static class MultiplyImplementation<TLeft, TRight, TResult>
         {
             private readonly static Func<TLeft, TRight, TResult> Function =
@@ -288,8 +326,31 @@ private static class GreaterThanOrEqualImplementation<TLeft, TRight>
             internal static bool Invoke(TLeft left, TRight right) => Function(left, right);
         }
 
+        private static class NegateImplementation<T, TResult>
+        {
+            private readonly static Func<T, TResult> Function =
+                CreateUnaryFunction<T, TResult>(Expression.Negate);
+
+            internal static TResult Invoke(T value) => Function(value);
+        }
+
         #endregion
 
+        /// <summary>
+        /// Creates a compiled lambda for the given <see cref="Func{Expression, UnaryExpression}"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the value to be passed to the <see cref="UnaryExpression"/>.</typeparam>
+        /// <typeparam name="TResult">The return type of the <see cref="UnaryExpression"/>.</typeparam>
+        /// <param name="expressionCreationFunction">The function that creates a unary expression to compile.</param>
+        /// <returns>The compiled unary expression.</returns>
+        private static Func<T, TResult> CreateUnaryFunction<T, TResult>(Func<Expression, UnaryExpression> expressionCreationFunction)
+        {
+            var valueParameter = Expression.Parameter(typeof(T), "value");
+            var negationExpression = expressionCreationFunction(valueParameter);
+            var lambda = Expression.Lambda<Func<T, TResult>>(negationExpression, valueParameter);
+            return lambda.Compile();
+        }
+
         /// <summary>
         /// Creates a compiled lambda for the given <see cref="Func{Expression, Expression, BinaryExpression}"/>.
         /// </summary>
diff --git a/UnitsNet/CustomCode/GlobalConfiguration.cs b/UnitsNet/CustomCode/GlobalConfiguration.cs
index 746e98dc65..f7eff3a926 100644
--- a/UnitsNet/CustomCode/GlobalConfiguration.cs
+++ b/UnitsNet/CustomCode/GlobalConfiguration.cs
@@ -9,8 +9,8 @@
 namespace UnitsNet
 {
     /// <summary>
-    ///     Global configuration for culture, used as default culture in methods like <see cref="Length.ToString()" /> and
-    ///     <see cref="Length.Parse(string)" />.
+    ///     Global configuration for culture, used as default culture in methods like <see cref="Length{T}.ToString()" /> and
+    ///     <see cref="Length{T}.Parse(string)" />.
     /// </summary>
     [Obsolete("The only property DefaultCulture is now deprecated. Manipulate Thread.CurrentThread.CurrentUICulture instead.")]
     public static class GlobalConfiguration
diff --git a/UnitsNet/CustomCode/Quantities/Acceleration.extra.cs b/UnitsNet/CustomCode/Quantities/Acceleration.extra.cs
index 75a2eba9cf..40b736be56 100644
--- a/UnitsNet/CustomCode/Quantities/Acceleration.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Acceleration.extra.cs
@@ -3,14 +3,14 @@
 
 namespace UnitsNet
 {
-    public partial struct Acceleration
+    public partial struct Acceleration<T>
     {
         /// <summary>
-        /// Multiply <see cref="Acceleration"/> and <see cref="Density"/> to get <see cref="SpecificWeight"/>.
+        /// Multiply <see cref="Acceleration{T}"/> and <see cref="Density{T}"/> to get <see cref="SpecificWeight{T}"/>.
         /// </summary>
-        public static SpecificWeight operator *(Acceleration acceleration, Density density)
+        public static SpecificWeight<T> operator *(Acceleration<T> acceleration, Density<T> density)
         {
-            return new SpecificWeight(acceleration.MetersPerSecondSquared * density.KilogramsPerCubicMeter, UnitsNet.Units.SpecificWeightUnit.NewtonPerCubicMeter);
+            return new SpecificWeight<T>(acceleration.MetersPerSecondSquared * density.KilogramsPerCubicMeter, UnitsNet.Units.SpecificWeightUnit.NewtonPerCubicMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs b/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs
index 30693f48eb..2d2a555cae 100644
--- a/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs
@@ -7,7 +7,7 @@
 
 namespace UnitsNet
 {
-    public partial struct AmountOfSubstance
+    public partial struct AmountOfSubstance<T>
     {
         /// <summary>
         ///     The Avogadro constant is the number of constituent particles, usually molecules, 
@@ -35,34 +35,34 @@ public double NumberOfParticles()
         }
 
 
-        /// <summary>Get <see cref="AmountOfSubstance" /> from <see cref="Mass" /> and a given <see cref="MolarMass" />.</summary>
-        public static AmountOfSubstance FromMass(Mass mass, MolarMass molarMass)
+        /// <summary>Get <see cref="AmountOfSubstance{T}" /> from <see cref="Mass{T}" /> and a given <see cref="MolarMass{T}" />.</summary>
+        public static AmountOfSubstance<T> FromMass(Mass<T> mass, MolarMass<T> molarMass )
         {
             return mass / molarMass;
         }
-        
-        /// <summary>Get <see cref="Mass" /> from <see cref="AmountOfSubstance" /> for a given <see cref="MolarMass" />.</summary>
-        public static Mass operator *(AmountOfSubstance amountOfSubstance, MolarMass molarMass)
+
+        /// <summary>Get <see cref="Mass{T}" /> from <see cref="AmountOfSubstance{T}" /> for a given <see cref="MolarMass{T}" />.</summary>
+        public static Mass<T> operator *(AmountOfSubstance<T> amountOfSubstance, MolarMass<T> molarMass )
         {
-            return Mass.FromGrams(amountOfSubstance.Moles * molarMass.GramsPerMole);
+            return Mass<T>.FromGrams(amountOfSubstance.Moles * molarMass.GramsPerMole);
         }
 
-        /// <summary>Get <see cref="Mass" /> from <see cref="AmountOfSubstance" /> for a given <see cref="MolarMass" />.</summary>
-        public static Mass operator *(MolarMass molarMass, AmountOfSubstance amountOfSubstance)
+        /// <summary>Get <see cref="Mass{T}" /> from <see cref="AmountOfSubstance{T}" /> for a given <see cref="MolarMass{T}" />.</summary>
+        public static Mass<T> operator *(MolarMass<T> molarMass, AmountOfSubstance<T> amountOfSubstance )
         {
-            return Mass.FromGrams(amountOfSubstance.Moles * molarMass.GramsPerMole);
+            return Mass<T>.FromGrams(amountOfSubstance.Moles * molarMass.GramsPerMole);
         }
 
-        /// <summary>Get <see cref="Molarity" /> from <see cref="AmountOfSubstance" /> divided by <see cref="Volume" />.</summary>
-        public static Molarity operator /(AmountOfSubstance amountOfComponent, Volume mixtureVolume)
+        /// <summary>Get <see cref="Molarity{T}" /> from <see cref="AmountOfSubstance{T}" /> divided by <see cref="Volume{T}" />.</summary>
+        public static Molarity<T> operator /(AmountOfSubstance<T> amountOfComponent, Volume<T> mixtureVolume )
         {
-            return Molarity.FromMolesPerCubicMeter(amountOfComponent.Moles / mixtureVolume.CubicMeters);
+            return Molarity<T>.FromMolesPerCubicMeter(amountOfComponent.Moles / mixtureVolume.CubicMeters);
         }
 
-        /// <summary>Get <see cref="Volume" /> from <see cref="AmountOfSubstance" /> divided by <see cref="Molarity" />.</summary>
-        public static Volume operator /(AmountOfSubstance amountOfSubstance, Molarity molarity)
+        /// <summary>Get <see cref="Volume{T}" /> from <see cref="AmountOfSubstance{T}" /> divided by <see cref="Molarity{T}" />.</summary>
+        public static Volume<T> operator /(AmountOfSubstance<T> amountOfSubstance, Molarity<T> molarity )
         {
-            return Volume.FromCubicMeters(amountOfSubstance.Moles / molarity.MolesPerCubicMeter);
+            return Volume<T>.FromCubicMeters(amountOfSubstance.Moles / molarity.MolesPerCubicMeter);
         }
 
     }
diff --git a/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs b/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs
index cc0a3cfcdf..8ac9b25682 100644
--- a/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs
@@ -6,16 +6,16 @@
 
 namespace UnitsNet
 {
-    public partial struct AmplitudeRatio
+    public partial struct AmplitudeRatio<T>
     {
         /// <summary>
-        ///     Initializes a new instance of the <see cref="AmplitudeRatio" /> struct from the specified electric potential
+        ///     Initializes a new instance of the <see cref="AmplitudeRatio{T}" /> struct from the specified electric potential
         ///     referenced to one volt RMS. This assumes both the specified electric potential and the one volt reference have the
         ///     same
         ///     resistance.
         /// </summary>
         /// <param name="voltage">The electric potential referenced to one volt.</param>
-        public AmplitudeRatio(ElectricPotential voltage)
+        public AmplitudeRatio(ElectricPotential<T> voltage )
             : this()
         {
             if (voltage.Volts <= 0)
@@ -24,12 +24,12 @@ public AmplitudeRatio(ElectricPotential voltage)
                     "The base-10 logarithm of a number ≤ 0 is undefined. Voltage must be greater than 0 V.");
 
             // E(dBV) = 20*log10(value(V)/reference(V))
-            _value = 20 * Math.Log10(voltage.Volts / 1);
+            Value = 20 * Math.Log10(voltage.Volts / 1);
             _unit = AmplitudeRatioUnit.DecibelVolt;
         }
 
         /// <summary>
-        ///     Gets an <see cref="ElectricPotential" /> from this <see cref="AmplitudeRatio" />.
+        ///     Gets an <see cref="ElectricPotential{T}" /> from this <see cref="AmplitudeRatio{T}" />.
         /// </summary>
         /// <remarks>
         ///     Provides a nicer syntax for converting an amplitude ratio back to a voltage.
@@ -37,33 +37,33 @@ public AmplitudeRatio(ElectricPotential voltage)
         ///         <c>var voltage = voltageRatio.ToElectricPotential();</c>
         ///     </example>
         /// </remarks>
-        public ElectricPotential ToElectricPotential()
+        public ElectricPotential<T> ToElectricPotential()
         {
             // E(V) = 1V * 10^(E(dBV)/20)
-            return ElectricPotential.FromVolts( Math.Pow( 10, DecibelVolts / 20 ) );
+            return ElectricPotential<T>.FromVolts( Math.Pow( 10, DecibelVolts / 20 ) );
         }
 
         /// <summary>
-        ///     Converts this <see cref="AmplitudeRatio" /> to a <see cref="PowerRatio" />.
+        ///     Converts this <see cref="AmplitudeRatio{T}" /> to a <see cref="PowerRatio{T}" />.
         /// </summary>
         /// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
         /// <remarks>http://www.maximintegrated.com/en/app-notes/index.mvp/id/808</remarks>
-        public PowerRatio ToPowerRatio( ElectricResistance impedance )
+        public PowerRatio<T> ToPowerRatio( ElectricResistance<T> impedance )
         {
             // P(dBW) = E(dBV) - 10*log10(Z(Ω)/1)
-            return PowerRatio.FromDecibelWatts( DecibelVolts - 10 * Math.Log10( impedance.Ohms / 1 ) );
+            return PowerRatio<T>.FromDecibelWatts( DecibelVolts - 10 * Math.Log10( impedance.Ohms / 1 ) );
         }
 
         #region Static Methods
 
         /// <summary>
-        ///     Gets an <see cref="AmplitudeRatio" /> in decibels (dB) relative to 1 volt RMS from an
-        ///     <see cref="ElectricPotential" />.
+        ///     Gets an <see cref="AmplitudeRatio{T}" /> in decibels (dB) relative to 1 volt RMS from an
+        ///     <see cref="ElectricPotential{T}" />.
         /// </summary>
         /// <param name="voltage">The voltage (electric potential) relative to one volt RMS.</param>
-        public static AmplitudeRatio FromElectricPotential(ElectricPotential voltage)
+        public static AmplitudeRatio<T> FromElectricPotential(ElectricPotential<T> voltage )
         {
-            return new AmplitudeRatio(voltage);
+            return new AmplitudeRatio<T>( voltage);
         }
 
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/Angle.extra.cs b/UnitsNet/CustomCode/Quantities/Angle.extra.cs
index 59318915c4..4ee5eba580 100644
--- a/UnitsNet/CustomCode/Quantities/Angle.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Angle.extra.cs
@@ -5,18 +5,18 @@
 
 namespace UnitsNet
 {
-    public partial struct Angle
+    public partial struct Angle<T>
     {
-        /// <summary>Get <see cref="RotationalSpeed"/> from <see cref="Angle"/> delta over time delta.</summary>
-        public static RotationalSpeed operator /(Angle angle, TimeSpan timeSpan)
+        /// <summary>Get <see cref="RotationalSpeed{T}"/> from <see cref="Angle{T}"/> delta over time delta.</summary>
+        public static RotationalSpeed<T> operator /(Angle<T> angle, TimeSpan timeSpan )
         {
-            return RotationalSpeed.FromRadiansPerSecond(angle.Radians / timeSpan.TotalSeconds);
+            return RotationalSpeed<T>.FromRadiansPerSecond(angle.Radians / timeSpan.TotalSeconds);
         }
 
-        /// <inheritdoc cref="op_Division(UnitsNet.Angle,System.TimeSpan)" />
-        public static RotationalSpeed operator /(Angle angle, Duration duration)
+        /// <inheritdoc cref="op_Division(UnitsNet.Angle{T}, System.TimeSpan)" />
+        public static RotationalSpeed<T> operator /(Angle<T> angle, Duration<T> duration )
         {
-            return RotationalSpeed.FromRadiansPerSecond(angle.Radians / duration.Seconds);
+            return RotationalSpeed<T>.FromRadiansPerSecond(angle.Radians / duration.Seconds);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/Area.extra.cs b/UnitsNet/CustomCode/Quantities/Area.extra.cs
index 5a89d29521..e9ec9db1db 100644
--- a/UnitsNet/CustomCode/Quantities/Area.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Area.extra.cs
@@ -5,41 +5,41 @@
 
 namespace UnitsNet
 {
-    public partial struct Area
+    public partial struct Area<T>
     {
         #region Static Methods
 
         /// <summary>Get circle area from a diameter.</summary>
-        public static Area FromCircleDiameter(Length diameter)
+        public static Area<T> FromCircleDiameter(Length<T> diameter )
         {
-            var radius = Length.FromMeters(diameter.Meters / 2d);
+            var radius = Length<T>.FromMeters(diameter.Meters / 2d);
             return FromCircleRadius(radius);
         }
 
         /// <summary>Get circle area from a radius.</summary>
-        public static Area FromCircleRadius(Length radius)
+        public static Area<T> FromCircleRadius(Length<T> radius )
         {
             return FromSquareMeters(Math.PI * radius.Meters * radius.Meters);
         }
 
         #endregion
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Area"/> divided by <see cref="Length"/>.</summary>
-        public static Length operator /(Area area, Length length)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Area{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static Length<T> operator /(Area<T> area, Length<T> length )
         {
-            return Length.FromMeters(area.SquareMeters / length.Meters);
+            return Length<T>.FromMeters(area.SquareMeters / length.Meters);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="Area"/> times <see cref="MassFlux"/>.</summary>
-        public static MassFlow operator *(Area area, MassFlux massFlux)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="Area{T}"/> times <see cref="MassFlux{T}"/>.</summary>
+        public static MassFlow<T> operator *(Area<T> area, MassFlux<T> massFlux )
         {
-            return MassFlow.FromGramsPerSecond(area.SquareMeters * massFlux.GramsPerSecondPerSquareMeter);
+            return MassFlow<T>.FromGramsPerSecond(area.SquareMeters * massFlux.GramsPerSecondPerSquareMeter);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="Area"/> times <see cref="Speed"/>.</summary>
-        public static VolumeFlow operator *(Area area, Speed speed)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from <see cref="Area{T}"/> times <see cref="Speed{T}"/>.</summary>
+        public static VolumeFlow<T> operator *(Area<T> area, Speed<T> speed )
         {
-            return VolumeFlow.FromCubicMetersPerSecond(area.SquareMeters * speed.MetersPerSecond);
+            return VolumeFlow<T>.FromCubicMetersPerSecond(area.SquareMeters * speed.MetersPerSecond);
         }
 
         /// <summary>Get <see cref="LinearDensity"/> from <see cref="Area"/> times <see cref="Density"/>.</summary>
diff --git a/UnitsNet/CustomCode/Quantities/AreaMomentOfInertia.extra.cs b/UnitsNet/CustomCode/Quantities/AreaMomentOfInertia.extra.cs
index 6afa77213e..213125a490 100644
--- a/UnitsNet/CustomCode/Quantities/AreaMomentOfInertia.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/AreaMomentOfInertia.extra.cs
@@ -5,12 +5,12 @@
 
 namespace UnitsNet
 {
-    public partial struct AreaMomentOfInertia
+    public partial struct AreaMomentOfInertia<T>
     {
-        /// <summary>Get <see cref="Volume"/> from <see cref="AreaMomentOfInertia"/> divided by <see cref="Length"/>.</summary>
-        public static Volume operator /(AreaMomentOfInertia areaMomentOfInertia, Length length)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="AreaMomentOfInertia{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static Volume<T> operator /(AreaMomentOfInertia<T> areaMomentOfInertia, Length<T> length )
         {
-            return Volume.FromCubicMeters(areaMomentOfInertia.MetersToTheFourth / length.Meters);
+            return Volume<T>.FromCubicMeters(areaMomentOfInertia.MetersToTheFourth / length.Meters);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/BrakeSpecificFuelConsumption.extra.cs b/UnitsNet/CustomCode/Quantities/BrakeSpecificFuelConsumption.extra.cs
index 5bd29a877a..e94543ee3e 100644
--- a/UnitsNet/CustomCode/Quantities/BrakeSpecificFuelConsumption.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/BrakeSpecificFuelConsumption.extra.cs
@@ -3,22 +3,22 @@
 
 namespace UnitsNet
 {
-    public partial struct BrakeSpecificFuelConsumption
+    public partial struct BrakeSpecificFuelConsumption<T>
     {
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="BrakeSpecificFuelConsumption"/> times <see cref="Power"/>.</summary>
-        public static MassFlow operator *(BrakeSpecificFuelConsumption bsfc, Power power)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="BrakeSpecificFuelConsumption{T}"/> times <see cref="Power{T}"/>.</summary>
+        public static MassFlow<T> operator *(BrakeSpecificFuelConsumption<T> bsfc, Power<T> power )
         {
-            return MassFlow.FromKilogramsPerSecond(bsfc.KilogramsPerJoule*power.Watts);
+            return MassFlow<T>.FromKilogramsPerSecond(bsfc.KilogramsPerJoule*power.Watts);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from <paramref name="value"/> divided by <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static SpecificEnergy operator /(double value, BrakeSpecificFuelConsumption bsfc)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from <paramref name="value"/> divided by <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static SpecificEnergy<T> operator /(double value, BrakeSpecificFuelConsumption<T> bsfc )
         {
-            return SpecificEnergy.FromJoulesPerKilogram(value/bsfc.KilogramsPerJoule);
+            return SpecificEnergy<T>.FromJoulesPerKilogram(value/bsfc.KilogramsPerJoule);
         }
 
-        /// <summary>Get constant from <see cref="BrakeSpecificFuelConsumption"/> times <see cref="SpecificEnergy"/>.</summary>
-        public static double operator *(BrakeSpecificFuelConsumption bsfc, SpecificEnergy specificEnergy)
+        /// <summary>Get constant from <see cref="BrakeSpecificFuelConsumption{T}"/> times <see cref="SpecificEnergy{T}"/>.</summary>
+        public static double operator *(BrakeSpecificFuelConsumption<T> bsfc, SpecificEnergy<T> specificEnergy )
         {
             return specificEnergy.JoulesPerKilogram*bsfc.KilogramsPerJoule;
         }
diff --git a/UnitsNet/CustomCode/Quantities/Density.extra.cs b/UnitsNet/CustomCode/Quantities/Density.extra.cs
index d20459ed7b..9b3d72a858 100644
--- a/UnitsNet/CustomCode/Quantities/Density.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Density.extra.cs
@@ -6,69 +6,69 @@
 
 namespace UnitsNet
 {
-    public partial struct Density
+    public partial struct Density<T>
     {
         /// <summary>
-        ///     Gets <see cref="Molarity" /> from this <see cref="Density" />.
+        ///     Gets <see cref="Molarity{T}" /> from this <see cref="Density{T}" />.
         /// </summary>
         /// <param name="molecularWeight"></param>
-        /// <seealso cref="MassConcentration.ToMolarity(MolarMass)"/>
+        /// <seealso cref="MassConcentration{T}.ToMolarity(MolarMass{T})"/>
         [Obsolete("This method is deprecated in favor of MassConcentration.ToMolarity(MolarMass).")]
-        public Molarity ToMolarity(Mass molecularWeight)
+        public Molarity<T> ToMolarity(Mass<T> molecularWeight )
         {
-            return Molarity.FromMolesPerCubicMeter(KilogramsPerCubicMeter / molecularWeight.Kilograms);
+            return Molarity<T>.FromMolesPerCubicMeter(KilogramsPerCubicMeter / molecularWeight.Kilograms);
         }
 
         #region Static Methods
 
         /// <summary>
-        ///     Get <see cref="Density" /> from <see cref="Molarity" />.
+        ///     Get <see cref="Density{T}" /> from <see cref="Molarity{T}" />.
         /// </summary>
-        /// <seealso cref="MassConcentration.FromMolarity(Molarity, MolarMass)"/>
+        /// <seealso cref="MassConcentration{T}.FromMolarity(Molarity{T}, MolarMass{T})"/>
         [Obsolete("This method is deprecated in favor of MassConcentration.FromMolarity(Molarity, MolarMass).")]
-        public static Density FromMolarity(Molarity molarity, Mass molecularWeight)
+        public static Density<T> FromMolarity(Molarity<T> molarity, Mass<T> molecularWeight )
         {
-            return new Density(molarity.MolesPerCubicMeter * molecularWeight.Kilograms, DensityUnit.KilogramPerCubicMeter);
+            return new Density<T>( molarity.MolesPerCubicMeter * molecularWeight.Kilograms, DensityUnit.KilogramPerCubicMeter);
         }
 
         #endregion
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="Density"/> times <see cref="Volume"/>.</summary>
-        public static Mass operator *(Density density, Volume volume)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="Density{T}"/> times <see cref="Volume{T}"/>.</summary>
+        public static Mass<T> operator *(Density<T> density, Volume<T> volume )
         {
-            return Mass.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
+            return Mass<T>.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
         }
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="Volume"/> times <see cref="Density"/>.</summary>
-        public static Mass operator *(Volume volume, Density density)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="Volume{T}"/> times <see cref="Density{T}"/>.</summary>
+        public static Mass<T> operator *(Volume<T> volume, Density<T> density )
         {
-            return Mass.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
+            return Mass<T>.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
         }
 
-        /// <summary>Get <see cref="DynamicViscosity"/> from <see cref="Density"/> times <see cref="KinematicViscosity"/>.</summary>
-        public static DynamicViscosity operator *(Density density, KinematicViscosity kinematicViscosity)
+        /// <summary>Get <see cref="DynamicViscosity{T}"/> from <see cref="Density{T}"/> times <see cref="KinematicViscosity{T}"/>.</summary>
+        public static DynamicViscosity<T> operator *(Density<T> density, KinematicViscosity<T> kinematicViscosity )
         {
-            return DynamicViscosity.FromNewtonSecondsPerMeterSquared(kinematicViscosity.SquareMetersPerSecond * density.KilogramsPerCubicMeter);
+            return DynamicViscosity<T>.FromNewtonSecondsPerMeterSquared(kinematicViscosity.SquareMetersPerSecond * density.KilogramsPerCubicMeter);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> <see cref="Density"/> times <see cref="Speed"/>.</summary>
-        public static MassFlux operator *(Density density, Speed speed)
+        /// <summary>Get <see cref="MassFlux{T}"/> <see cref="Density{T}"/> times <see cref="Speed{T}"/>.</summary>
+        public static MassFlux<T> operator *(Density<T> density, Speed<T> speed )
         {
-            return MassFlux.FromKilogramsPerSecondPerSquareMeter(density.KilogramsPerCubicMeter * speed.MetersPerSecond);
+            return MassFlux<T>.FromKilogramsPerSecondPerSquareMeter(density.KilogramsPerCubicMeter * speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="SpecificWeight"/> from <see cref="Density"/> times <see cref="Acceleration"/>.</summary>
-        public static SpecificWeight operator *(Density density, Acceleration acceleration)
+        /// <summary>Get <see cref="SpecificWeight{T}"/> from <see cref="Density{T}"/> times <see cref="Acceleration{T}"/>.</summary>
+        public static SpecificWeight<T> operator *(Density<T> density, Acceleration<T> acceleration )
         {
-            return new SpecificWeight(density.KilogramsPerCubicMeter * acceleration.MetersPerSecondSquared, SpecificWeightUnit.NewtonPerCubicMeter);
+            return new SpecificWeight<T>( density.KilogramsPerCubicMeter * acceleration.MetersPerSecondSquared, SpecificWeightUnit.NewtonPerCubicMeter);
         }
 
-        /// <summary>Get <see cref="Molarity"/> from <see cref="Density"/> divided by <see cref="Mass"/>.</summary>
-        /// <seealso cref="MassConcentration.op_Division(MassConcentration, MolarMass)"/>
+        /// <summary>Get <see cref="Molarity{T}"/> from <see cref="Density{T}"/> divided by <see cref="Mass{T}"/>.</summary>
+        /// <seealso cref="MassConcentration{T}.op_Division(MassConcentration{T}, MolarMass{T})"/>
         [Obsolete("This operator is deprecated in favor of MassConcentration.op_Division(MassConcentration, MolarMass).")]
-        public static Molarity operator /(Density density, Mass molecularWeight)
+        public static Molarity<T> operator /(Density<T> density, Mass<T> molecularWeight )
         {
-            return new Molarity(density.KilogramsPerCubicMeter / molecularWeight.Kilograms, MolarityUnit.MolesPerCubicMeter);
+            return new Molarity<T>( density.KilogramsPerCubicMeter / molecularWeight.Kilograms, MolarityUnit.MolesPerCubicMeter);
         }
 
         /// <summary>Get <see cref="LinearDensity"/> from <see cref="Density"/> times <see cref="Area"/>.</summary>
diff --git a/UnitsNet/CustomCode/Quantities/Duration.extra.cs b/UnitsNet/CustomCode/Quantities/Duration.extra.cs
index 32e6dbc09d..7dee27e610 100644
--- a/UnitsNet/CustomCode/Quantities/Duration.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Duration.extra.cs
@@ -5,7 +5,7 @@
 
 namespace UnitsNet
 {
-    public partial struct Duration
+    public partial struct Duration<T>
     {
         /// <summary>
         ///     Convert a Duration to a TimeSpan.
@@ -16,86 +16,87 @@ public TimeSpan ToTimeSpan()
         {
             if( Seconds > TimeSpan.MaxValue.TotalSeconds ||
                 Seconds < TimeSpan.MinValue.TotalSeconds )
-                throw new ArgumentOutOfRangeException( nameof( Duration ), "The duration is too large or small to fit in a TimeSpan" );
+                throw new ArgumentOutOfRangeException( nameof( Duration<T> ), "The duration is too large or small to fit in a TimeSpan" );
             return TimeSpan.FromSeconds( Seconds );
         }
 
-        /// <summary>Get <see cref="DateTime"/> from <see cref="DateTime"/> plus <see cref="Duration"/>.</summary>
-        public static DateTime operator +(DateTime time, Duration duration)
+        /// <summary>Get <see cref="DateTime"/> from <see cref="DateTime"/> plus <see cref="Duration{T}"/>.</summary>
+        public static DateTime operator +(DateTime time, Duration<T> duration)
         {
             return time.AddSeconds(duration.Seconds);
         }
 
-        /// <summary>Get <see cref="DateTime"/> from <see cref="DateTime"/> minus <see cref="Duration"/>.</summary>
-        public static DateTime operator -(DateTime time, Duration duration)
+        /// <summary>Get <see cref="DateTime"/> from <see cref="DateTime"/> minus <see cref="Duration{T}"/>.</summary>
+        public static DateTime operator -(DateTime time, Duration<T> duration)
         {
             return time.AddSeconds(-duration.Seconds);
         }
 
-        /// <summary>Explicitly cast <see cref="Duration"/> to <see cref="TimeSpan"/>.</summary>
-        public static explicit operator TimeSpan(Duration duration)
+        /// <summary>Explicitly cast <see cref="Duration{T}"/> to <see cref="TimeSpan"/>.</summary>
+        public static explicit operator TimeSpan(Duration<T> duration)
         {
             return duration.ToTimeSpan();
         }
 
-        /// <summary>Explicitly cast <see cref="TimeSpan"/> to <see cref="Duration"/>.</summary>
-        public static explicit operator Duration(TimeSpan duration)
+        /// <summary>Explicitly cast <see cref="TimeSpan"/> to <see cref="Duration{T}"/>.</summary>
+        public static explicit operator Duration<T>(TimeSpan duration)
         {
             return FromSeconds(duration.TotalSeconds);
         }
 
-        /// <summary>True if <see cref="Duration"/> is less than <see cref="TimeSpan"/>.</summary>
-        public static bool operator <(Duration duration, TimeSpan timeSpan)
+        /// <summary>True if <see cref="Duration{T}"/> is less than <see cref="TimeSpan"/>.</summary>
+        public static bool operator <(Duration<T> duration, TimeSpan timeSpan)
         {
-            return duration.Seconds < timeSpan.TotalSeconds;
+            return CompiledLambdas.LessThan(duration.Seconds, timeSpan.TotalSeconds);
         }
 
-        /// <summary>True if <see cref="Duration"/> is greater than <see cref="TimeSpan"/>.</summary>
-        public static bool operator >(Duration duration, TimeSpan timeSpan)
+        /// <summary>True if <see cref="Duration{T}"/> is greater than <see cref="TimeSpan"/>.</summary>
+        public static bool operator >(Duration<T> duration, TimeSpan timeSpan)
         {
-            return duration.Seconds > timeSpan.TotalSeconds;
+            return CompiledLambdas.GreaterThan(duration.Seconds, timeSpan.TotalSeconds);
         }
 
-        /// <summary>True if <see cref="Duration"/> is less than or equal to <see cref="TimeSpan"/>.</summary>
-        public static bool operator <=(Duration duration, TimeSpan timeSpan)
+        /// <summary>True if <see cref="Duration{T}"/> is less than or equal to <see cref="TimeSpan"/>.</summary>
+        public static bool operator <=(Duration<T> duration, TimeSpan timeSpan)
         {
-            return duration.Seconds <= timeSpan.TotalSeconds;
+            return CompiledLambdas.LessThanOrEqual( duration.Seconds, timeSpan.TotalSeconds);
         }
 
-        /// <summary>True if <see cref="Duration"/> is greater than or equal to <see cref="TimeSpan"/>.</summary>
-        public static bool operator >=(Duration duration, TimeSpan timeSpan)
+        /// <summary>True if <see cref="Duration{T}"/> is greater than or equal to <see cref="TimeSpan"/>.</summary>
+        public static bool operator >=(Duration<T> duration, TimeSpan timeSpan)
         {
-            return duration.Seconds >= timeSpan.TotalSeconds;
+            return CompiledLambdas.GreaterThanOrEqual(duration.Seconds, timeSpan.TotalSeconds);
         }
 
-        /// <summary>True if <see cref="TimeSpan"/> is less than <see cref="Duration"/>.</summary>
-        public static bool operator <(TimeSpan timeSpan, Duration duration)
+        /// <summary>True if <see cref="TimeSpan"/> is less than <see cref="Duration{T}"/>.</summary>
+        public static bool operator <(TimeSpan timeSpan, Duration<T> duration )
         {
-            return timeSpan.TotalSeconds < duration.Seconds;
+            return CompiledLambdas.LessThan(timeSpan.TotalSeconds, duration.Seconds);
         }
 
-        /// <summary>True if <see cref="TimeSpan"/> is greater than <see cref="Duration"/>.</summary>
-        public static bool operator >(TimeSpan timeSpan, Duration duration)
+        /// <summary>True if <see cref="TimeSpan"/> is greater than <see cref="Duration{T}"/>.</summary>
+        public static bool operator >(TimeSpan timeSpan, Duration<T> duration )
         {
-            return timeSpan.TotalSeconds > duration.Seconds;
+            return CompiledLambdas.GreaterThan(timeSpan.TotalSeconds, duration.Seconds);
         }
 
-        /// <summary>True if <see cref="TimeSpan"/> is less than or equal to <see cref="Duration"/>.</summary>
-        public static bool operator <=(TimeSpan timeSpan, Duration duration)
+        /// <summary>True if <see cref="TimeSpan"/> is less than or equal to <see cref="Duration{T}"/>.</summary>
+        public static bool operator <=(TimeSpan timeSpan, Duration<T> duration )
         {
-            return timeSpan.TotalSeconds <= duration.Seconds;
+            return CompiledLambdas.LessThanOrEqual(timeSpan.TotalSeconds, duration.Seconds);
         }
 
-        /// <summary>True if <see cref="TimeSpan"/> is greater than or equal to <see cref="Duration"/>.</summary>
-        public static bool operator >=(TimeSpan timeSpan, Duration duration)
+        /// <summary>True if <see cref="TimeSpan"/> is greater than or equal to <see cref="Duration{T}"/>.</summary>
+        public static bool operator >=(TimeSpan timeSpan, Duration<T> duration )
         {
-            return timeSpan.TotalSeconds >= duration.Seconds;
+            return CompiledLambdas.GreaterThanOrEqual(timeSpan.TotalSeconds, duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Volume"/> from <see cref="Duration"/> times <see cref="VolumeFlow"/>.</summary>
-        public static Volume operator *(Duration duration, VolumeFlow volumeFlow)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="Duration{T}"/> times <see cref="VolumeFlow{T}"/>.</summary>
+        public static Volume<T> operator *(Duration<T> duration, VolumeFlow<T> volumeFlow )
         {
-            return Volume.FromCubicMeters(volumeFlow.CubicMetersPerSecond * duration.Seconds);
+            var value = CompiledLambdas.Multiply(volumeFlow.CubicMetersPerSecond, duration.Seconds);
+            return Volume<T>.FromCubicMeters(value);
         }
 
         /// <summary>Calculate <see cref="ElectricCharge"/> from <see cref="Duration"/> multiplied by <see cref="ElectricCurrent"/>.</summary>
diff --git a/UnitsNet/CustomCode/Quantities/DynamicViscosity.extra.cs b/UnitsNet/CustomCode/Quantities/DynamicViscosity.extra.cs
index e99348a111..ed89a3ac20 100644
--- a/UnitsNet/CustomCode/Quantities/DynamicViscosity.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/DynamicViscosity.extra.cs
@@ -3,12 +3,12 @@
 
 namespace UnitsNet
 {
-    public partial struct DynamicViscosity
+    public partial struct DynamicViscosity<T>
     {
-        /// <summary>Get <see cref="KinematicViscosity"/> from <see cref="DynamicViscosity"/> divided by <see cref="Density"/>.</summary>
-        public static KinematicViscosity operator /(DynamicViscosity dynamicViscosity, Density density)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from <see cref="DynamicViscosity{T}"/> divided by <see cref="Density{T}"/>.</summary>
+        public static KinematicViscosity<T> operator /(DynamicViscosity<T> dynamicViscosity, Density<T> density )
         {
-            return KinematicViscosity.FromSquareMetersPerSecond(dynamicViscosity.NewtonSecondsPerMeterSquared / density.KilogramsPerCubicMeter);
+            return KinematicViscosity<T>.FromSquareMetersPerSecond(dynamicViscosity.NewtonSecondsPerMeterSquared / density.KilogramsPerCubicMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs b/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs
index d006828077..8d753bbd2e 100644
--- a/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs
@@ -3,10 +3,10 @@
 
 namespace UnitsNet
 {
-    public partial struct ElectricPotential
+    public partial struct ElectricPotential<T>
     {
         /// <summary>
-        ///     Gets an <see cref="AmplitudeRatio" /> in decibels (dB) relative to 1 volt RMS from this <see cref="ElectricPotential" />.
+        ///     Gets an <see cref="AmplitudeRatio{T}" /> in decibels (dB) relative to 1 volt RMS from this <see cref="ElectricPotential{T}" />.
         /// </summary>
         /// <remarks>
         ///     Provides a nicer syntax for converting a voltage to an amplitude ratio (relative to 1 volt RMS).
@@ -14,9 +14,9 @@ public partial struct ElectricPotential
         ///         <c>var voltageRatio = voltage.ToAmplitudeRatio();</c>
         ///     </example>
         /// </remarks>
-        public AmplitudeRatio ToAmplitudeRatio()
+        public AmplitudeRatio<T> ToAmplitudeRatio()
         {
-            return AmplitudeRatio.FromElectricPotential(this);
+            return AmplitudeRatio<T>.FromElectricPotential(this);
         }
 
         /// <summary>Get <see cref="ElectricResistance"/> from <see cref="ElectricPotential"/> divided by <see cref="ElectricCurrent"/>.</summary>
diff --git a/UnitsNet/CustomCode/Quantities/Force.extra.cs b/UnitsNet/CustomCode/Quantities/Force.extra.cs
index 1d9881edff..ec98adb856 100644
--- a/UnitsNet/CustomCode/Quantities/Force.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Force.extra.cs
@@ -5,55 +5,55 @@
 
 namespace UnitsNet
 {
-    public partial struct Force
+    public partial struct Force<T>
     {
-        /// <summary>Get <see cref="Force"/> from <see cref="Pressure"/> divided by <see cref="Area"/>.</summary>
-        public static Force FromPressureByArea(Pressure p, Area area)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Pressure{T}"/> divided by <see cref="Area{T}"/>.</summary>
+        public static Force<T> FromPressureByArea(Pressure<T> p, Area<T> area )
         {
             double newtons = p.Pascals * area.SquareMeters;
-            return new Force(newtons, ForceUnit.Newton);
+            return new Force<T>( newtons, ForceUnit.Newton);
         }
 
-        /// <summary>Get <see cref="Force"/> from <see cref="Mass"/> times <see cref="Acceleration"/>.</summary>
-        public static Force FromMassByAcceleration(Mass mass, Acceleration acceleration)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Mass{T}"/> times <see cref="Acceleration{T}"/>.</summary>
+        public static Force<T> FromMassByAcceleration(Mass<T> mass, Acceleration<T> acceleration )
         {
-            return new Force(mass.Kilograms * acceleration.MetersPerSecondSquared, ForceUnit.Newton);
+            return new Force<T>( mass.Kilograms * acceleration.MetersPerSecondSquared, ForceUnit.Newton);
         }
 
-        /// <summary>Get <see cref="Power"/> from <see cref="Force"/> times <see cref="Speed"/>.</summary>
-        public static Power operator *(Force force, Speed speed)
+        /// <summary>Get <see cref="Power{T}"/> from <see cref="Force{T}"/> times <see cref="Speed{T}"/>.</summary>
+        public static Power<T> operator *(Force<T> force, Speed<T> speed )
         {
-            return Power.FromWatts(force.Newtons * speed.MetersPerSecond);
+            return Power<T>.FromWatts(force.Newtons * speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="Power"/> from <see cref="Speed"/> times <see cref="Force"/>.</summary>
-        public static Power operator *(Speed speed, Force force)
+        /// <summary>Get <see cref="Power{T}"/> from <see cref="Speed{T}"/> times <see cref="Force{T}"/>.</summary>
+        public static Power<T> operator *(Speed<T> speed, Force<T> force )
         {
-            return Power.FromWatts(force.Newtons * speed.MetersPerSecond);
+            return Power<T>.FromWatts(force.Newtons * speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from <see cref="Force"/> divided by <see cref="Mass"/>.</summary>
-        public static Acceleration operator /(Force force, Mass mass)
+        /// <summary>Get <see cref="Acceleration{T}"/> from <see cref="Force{T}"/> divided by <see cref="Mass{T}"/>.</summary>
+        public static Acceleration<T> operator /(Force<T> force, Mass<T> mass )
         {
-            return Acceleration.FromMetersPerSecondSquared(force.Newtons / mass.Kilograms);
+            return Acceleration<T>.FromMetersPerSecondSquared(force.Newtons / mass.Kilograms);
         }
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="Force"/> divided by <see cref="Acceleration"/>.</summary>
-        public static Mass operator /(Force force, Acceleration acceleration)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="Force{T}"/> divided by <see cref="Acceleration{T}"/>.</summary>
+        public static Mass<T> operator /(Force<T> force, Acceleration<T> acceleration )
         {
-            return Mass.FromKilograms(force.Newtons / acceleration.MetersPerSecondSquared);
+            return Mass<T>.FromKilograms(force.Newtons / acceleration.MetersPerSecondSquared);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from <see cref="Force"/> divided by <see cref="Area"/>.</summary>
-        public static Pressure operator /(Force force, Area area)
+        /// <summary>Get <see cref="Pressure{T}"/> from <see cref="Force{T}"/> divided by <see cref="Area{T}"/>.</summary>
+        public static Pressure<T> operator /(Force<T> force, Area<T> area )
         {
-            return Pressure.FromPascals(force.Newtons / area.SquareMeters);
+            return Pressure<T>.FromPascals(force.Newtons / area.SquareMeters);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from <see cref="Force"/> divided by <see cref="Length"/>.</summary>
-        public static ForcePerLength operator /(Force force, Length length)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from <see cref="Force{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static ForcePerLength<T> operator /(Force<T> force, Length<T> length )
         {
-            return ForcePerLength.FromNewtonsPerMeter(force.Newtons / length.Meters);
+            return ForcePerLength<T>.FromNewtonsPerMeter(force.Newtons / length.Meters);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/ForcePerLength.extra.cs b/UnitsNet/CustomCode/Quantities/ForcePerLength.extra.cs
index 7cb334b147..9b0d9bfc07 100644
--- a/UnitsNet/CustomCode/Quantities/ForcePerLength.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/ForcePerLength.extra.cs
@@ -3,24 +3,24 @@
 
 namespace UnitsNet
 {
-    public partial struct ForcePerLength
+    public partial struct ForcePerLength<T>
     {
-        /// <summary>Get <see cref="Force"/> from <see cref="ForcePerLength"/> multiplied by <see cref="Length"/>.</summary>
-        public static Force operator *(ForcePerLength forcePerLength, Length length)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="ForcePerLength{T}"/> multiplied by <see cref="Length{T}"/>.</summary>
+        public static Force<T> operator *(ForcePerLength<T> forcePerLength, Length<T> length )
         {
-            return Force.FromNewtons(forcePerLength.NewtonsPerMeter * length.Meters);
+            return Force<T>.FromNewtons(forcePerLength.NewtonsPerMeter * length.Meters);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Force"/> divided by <see cref="ForcePerLength"/>.</summary>
-        public static Length operator /(Force force, ForcePerLength forcePerLength)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Force{T}"/> divided by <see cref="ForcePerLength{T}"/>.</summary>
+        public static Length<T> operator /(Force<T> force, ForcePerLength<T> forcePerLength )
         {
-            return Length.FromMeters(force.Newtons / forcePerLength.NewtonsPerMeter);
+            return Length<T>.FromMeters(force.Newtons / forcePerLength.NewtonsPerMeter);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from <see cref="ForcePerLength"/> divided by <see cref="Length"/>.</summary>
-        public static Pressure operator /(ForcePerLength forcePerLength, Length length)
+        /// <summary>Get <see cref="Pressure{T}"/> from <see cref="ForcePerLength{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static Pressure<T> operator /(ForcePerLength<T> forcePerLength, Length<T> length )
         {
-            return Pressure.FromNewtonsPerSquareMeter(forcePerLength.NewtonsPerMeter / length.Meters);
+            return Pressure<T>.FromNewtonsPerSquareMeter(forcePerLength.NewtonsPerMeter / length.Meters);
         }
 
         /// <summary>Get <see cref="Torque"/> from <see cref="ForcePerLength"/> multiplied by <see cref="Area"/>.</summary>
diff --git a/UnitsNet/CustomCode/Quantities/HeatFlux.extra.cs b/UnitsNet/CustomCode/Quantities/HeatFlux.extra.cs
index 395661fb1f..e5a33b51cf 100644
--- a/UnitsNet/CustomCode/Quantities/HeatFlux.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/HeatFlux.extra.cs
@@ -3,12 +3,12 @@
 
 namespace UnitsNet
 {
-    public partial struct HeatFlux
+    public partial struct HeatFlux<T>
     {
-        /// <summary>Get <see cref="Power"/> from <see cref="HeatFlux"/> times <see cref="Area"/>.</summary>
-        public static Power operator *(HeatFlux heatFlux, Area area)
+        /// <summary>Get <see cref="Power{T}"/> from <see cref="HeatFlux{T}"/> times <see cref="Area{T}"/>.</summary>
+        public static Power<T> operator *(HeatFlux<T> heatFlux, Area<T> area )
         {
-            return Power.FromWatts(heatFlux.WattsPerSquareMeter * area.SquareMeters);
+            return Power<T>.FromWatts(heatFlux.WattsPerSquareMeter * area.SquareMeters);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/KinematicViscosity.extra.cs b/UnitsNet/CustomCode/Quantities/KinematicViscosity.extra.cs
index f43b75534c..a7b8f927c7 100644
--- a/UnitsNet/CustomCode/Quantities/KinematicViscosity.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/KinematicViscosity.extra.cs
@@ -5,42 +5,42 @@
 
 namespace UnitsNet
 {
-    public partial struct KinematicViscosity
+    public partial struct KinematicViscosity<T>
     {
-        /// <summary>Get <see cref="Speed"/> from <see cref="KinematicViscosity"/> divided by <see cref="Length"/>.</summary>
-        public static Speed operator /(KinematicViscosity kinematicViscosity, Length length)
+        /// <summary>Get <see cref="Speed{T}"/> from <see cref="KinematicViscosity{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static Speed<T> operator /(KinematicViscosity<T> kinematicViscosity, Length<T> length )
         {
-            return Speed.FromMetersPerSecond(kinematicViscosity.SquareMetersPerSecond / length.Meters);
+            return Speed<T>.FromMetersPerSecond(kinematicViscosity.SquareMetersPerSecond / length.Meters);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="KinematicViscosity"/> times <see cref="TimeSpan"/>.</summary>
-        public static Area operator *(KinematicViscosity kinematicViscosity, TimeSpan timeSpan)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="KinematicViscosity{T}"/> times <see cref="TimeSpan"/>.</summary>
+        public static Area<T> operator *(KinematicViscosity<T> kinematicViscosity, TimeSpan timeSpan)
         {
-            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * timeSpan.TotalSeconds);
+            return Area<T>.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="TimeSpan"/> times <see cref="KinematicViscosity"/>.</summary>
-        public static Area operator *(TimeSpan timeSpan, KinematicViscosity kinematicViscosity)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="TimeSpan"/> times <see cref="KinematicViscosity{T}"/>.</summary>
+        public static Area<T> operator *(TimeSpan timeSpan, KinematicViscosity<T> kinematicViscosity )
         {
-            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * timeSpan.TotalSeconds);
+            return Area<T>.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="KinematicViscosity"/> times <see cref="Duration"/>.</summary>
-        public static Area operator *(KinematicViscosity kinematicViscosity, Duration duration)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="KinematicViscosity{T}"/> times <see cref="Duration{T}"/>.</summary>
+        public static Area<T> operator *(KinematicViscosity<T> kinematicViscosity, Duration<T> duration )
         {
-            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * duration.Seconds);
+            return Area<T>.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="Duration"/> times <see cref="KinematicViscosity"/>.</summary>
-        public static Area operator *(Duration duration, KinematicViscosity kinematicViscosity)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="Duration{T}"/> times <see cref="KinematicViscosity{T}"/>.</summary>
+        public static Area<T> operator *(Duration<T> duration, KinematicViscosity<T> kinematicViscosity )
         {
-            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * duration.Seconds);
+            return Area<T>.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="DynamicViscosity"/> from <see cref="KinematicViscosity"/> times <see cref="Density"/>.</summary>
-        public static DynamicViscosity operator *(KinematicViscosity kinematicViscosity, Density density)
+        /// <summary>Get <see cref="DynamicViscosity{T}"/> from <see cref="KinematicViscosity{T}"/> times <see cref="Density{T}"/>.</summary>
+        public static DynamicViscosity<T> operator *(KinematicViscosity<T> kinematicViscosity, Density<T> density )
         {
-            return DynamicViscosity.FromNewtonSecondsPerMeterSquared(kinematicViscosity.SquareMetersPerSecond * density.KilogramsPerCubicMeter);
+            return DynamicViscosity<T>.FromNewtonSecondsPerMeterSquared(kinematicViscosity.SquareMetersPerSecond * density.KilogramsPerCubicMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/LapseRate.extra.cs b/UnitsNet/CustomCode/Quantities/LapseRate.extra.cs
index 6f675602e0..34f77c4e9a 100644
--- a/UnitsNet/CustomCode/Quantities/LapseRate.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/LapseRate.extra.cs
@@ -3,21 +3,21 @@
 
 namespace UnitsNet
 {
-    public partial struct LapseRate
+    public partial struct LapseRate<T>
     {
-        /// <summary>Get <see cref="Length"/> from <see cref="TemperatureDelta"/> divided by <see cref="LapseRate"/>.</summary>
-        public static Length operator /(TemperatureDelta left, LapseRate right)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="TemperatureDelta{T}"/> divided by <see cref="LapseRate{T}"/>.</summary>
+        public static Length<T> operator /(TemperatureDelta<T> left, LapseRate<T> right )
         {
-            return Length.FromKilometers(left.Kelvins / right.DegreesCelciusPerKilometer);
+            return Length<T>.FromKilometers(left.Kelvins / right.DegreesCelciusPerKilometer);
         }
 
-        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="Length"/> times <see cref="LapseRate"/>.</summary>
-        public static TemperatureDelta operator *(Length left, LapseRate right) => right * left;
+        /// <summary>Get <see cref="TemperatureDelta{T}"/> from <see cref="Length{T}"/> times <see cref="LapseRate{T}"/>.</summary>
+        public static TemperatureDelta<T> operator *(Length<T> left, LapseRate<T> right ) => right * left;
 
-        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="LapseRate"/> times <see cref="Length"/>.</summary>
-        public static TemperatureDelta operator *(LapseRate left, Length right)
+        /// <summary>Get <see cref="TemperatureDelta{T}"/> from <see cref="LapseRate{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static TemperatureDelta<T> operator *(LapseRate<T> left, Length<T> right )
         {
-            return TemperatureDelta.FromDegreesCelsius(left.DegreesCelciusPerKilometer * right.Kilometers);
+            return TemperatureDelta<T>.FromDegreesCelsius(left.DegreesCelciusPerKilometer * right.Kilometers);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/Length.extra.cs b/UnitsNet/CustomCode/Quantities/Length.extra.cs
index c69d65fabf..62bbb95e44 100644
--- a/UnitsNet/CustomCode/Quantities/Length.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Length.extra.cs
@@ -10,7 +10,7 @@
 
 namespace UnitsNet
 {
-    public partial struct Length
+    public partial struct Length<T>
     {
         private const double InchesInOneFoot = 12;
 
@@ -32,7 +32,7 @@ public FeetInches FeetInches
         /// <summary>
         ///     Get length from combination of feet and inches.
         /// </summary>
-        public static Length FromFeetInches(double feet, double inches)
+        public static Length<T> FromFeetInches(double feet, double inches)
         {
             return FromInches(InchesInOneFoot*feet + inches);
         }
@@ -47,10 +47,10 @@ public static Length FromFeetInches(double feet, double inches)
         /// <param name="str"></param>
         /// <param name="formatProvider">Optionally specify the culture format numbers and localize unit abbreviations. Defaults to thread's culture.</param>
         /// <returns>Parsed length.</returns>
-        public static Length ParseFeetInches([NotNull] string str, IFormatProvider? formatProvider = null)
+        public static Length<T> ParseFeetInches([NotNull] string str, IFormatProvider? formatProvider = null)
         {
             if (str == null) throw new ArgumentNullException(nameof(str));
-            if (!TryParseFeetInches(str, out Length result, formatProvider))
+            if (!TryParseFeetInches(str, out Length<T> result, formatProvider))
             {
                 // A bit lazy, but I didn't want to duplicate this edge case implementation just to get more narrow exception descriptions.
                 throw new FormatException("Unable to parse feet and inches. Expected format \"2' 4\"\" or \"2 ft 4 in\". Whitespace is optional.");
@@ -69,7 +69,7 @@ public static Length ParseFeetInches([NotNull] string str, IFormatProvider? form
         /// <param name="str"></param>
         /// <param name="result">Parsed length.</param>
         /// <param name="formatProvider">Optionally specify the culture format numbers and localize unit abbreviations. Defaults to thread's culture.</param>
-        public static bool TryParseFeetInches(string? str, out Length result, IFormatProvider? formatProvider = null)
+        public static bool TryParseFeetInches(string? str, out Length<T> result, IFormatProvider? formatProvider = null)
         {
             if (str == null)
             {
@@ -98,8 +98,8 @@ public static bool TryParseFeetInches(string? str, out Length result, IFormatPro
             var feetGroup = match.Groups["feet"];
             var inchesGroup = match.Groups["inches"];
 
-            if (TryParse(feetGroup.Value, formatProvider, out Length feet) &&
-                TryParse(inchesGroup.Value, formatProvider, out Length inches))
+            if (TryParse(feetGroup.Value, formatProvider, out Length<T> feet ) &&
+                TryParse(inchesGroup.Value, formatProvider, out Length<T> inches ))
             {
                 result = feet + inches;
 
@@ -113,70 +113,70 @@ public static bool TryParseFeetInches(string? str, out Length result, IFormatPro
             return false;
         }
 
-        /// <summary>Get <see cref="Speed"/> from <see cref="Length"/> divided by <see cref="TimeSpan"/>.</summary>
-        public static Speed operator /(Length length, TimeSpan timeSpan)
+        /// <summary>Get <see cref="Speed{T}"/> from <see cref="Length{T}"/> divided by <see cref="TimeSpan"/>.</summary>
+        public static Speed<T> operator /(Length<T> length, TimeSpan timeSpan)
         {
-            return Speed.FromMetersPerSecond(length.Meters/timeSpan.TotalSeconds);
+            return Speed<T>.FromMetersPerSecond(length.Meters/timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Speed"/> from <see cref="Length"/> divided by <see cref="Duration"/>.</summary>
-        public static Speed operator /(Length length, Duration duration)
+        /// <summary>Get <see cref="Speed{T}"/> from <see cref="Length{T}"/> divided by <see cref="Duration{T}"/>.</summary>
+        public static Speed<T> operator /(Length<T> length, Duration<T> duration )
         {
-            return Speed.FromMetersPerSecond(length.Meters/duration.Seconds);
+            return Speed<T>.FromMetersPerSecond(length.Meters/duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Duration"/> from <see cref="Length"/> divided by <see cref="Speed"/>.</summary>
-        public static Duration operator /(Length length, Speed speed)
+        /// <summary>Get <see cref="Duration{T}"/> from <see cref="Length{T}"/> divided by <see cref="Speed{T}"/>.</summary>
+        public static Duration<T> operator /(Length<T> length, Speed<T> speed )
         {
-            return Duration.FromSeconds(length.Meters/speed.MetersPerSecond);
+            return Duration<T>.FromSeconds(length.Meters/speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="Length"/> times <see cref="Length"/>.</summary>
-        public static Area operator *(Length length1, Length length2)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="Length{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static Area<T> operator *(Length<T> length1, Length<T> length2 )
         {
-            return Area.FromSquareMeters(length1.Meters*length2.Meters);
+            return Area<T>.FromSquareMeters(length1.Meters*length2.Meters);
         }
 
-        /// <summary>Get <see cref="Volume"/> from <see cref="Area"/> times <see cref="Length"/>.</summary>
-        public static Volume operator *(Area area, Length length)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="Area{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static Volume<T> operator *(Area<T> area, Length<T> length )
         {
-            return Volume.FromCubicMeters(area.SquareMeters*length.Meters);
+            return Volume<T>.FromCubicMeters(area.SquareMeters*length.Meters);
         }
 
-        /// <summary>Get <see cref="Volume"/> from <see cref="Length"/> times <see cref="Area"/>.</summary>
-        public static Volume operator *(Length length, Area area)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="Length{T}"/> times <see cref="Area{T}"/>.</summary>
+        public static Volume<T> operator *(Length<T> length, Area<T> area )
         {
-            return Volume.FromCubicMeters(area.SquareMeters*length.Meters);
+            return Volume<T>.FromCubicMeters(area.SquareMeters*length.Meters);
         }
 
-        /// <summary>Get <see cref="Torque"/> from <see cref="Force"/> times <see cref="Length"/>.</summary>
-        public static Torque operator *(Force force, Length length)
+        /// <summary>Get <see cref="Torque{T}"/> from <see cref="Force{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static Torque<T> operator *(Force<T> force, Length<T> length )
         {
-            return Torque.FromNewtonMeters(force.Newtons*length.Meters);
+            return Torque<T>.FromNewtonMeters(force.Newtons*length.Meters);
         }
 
-        /// <summary>Get <see cref="Torque"/> from <see cref="Length"/> times <see cref="Force"/>.</summary>
-        public static Torque operator *(Length length, Force force)
+        /// <summary>Get <see cref="Torque{T}"/> from <see cref="Length{T}"/> times <see cref="Force{T}"/>.</summary>
+        public static Torque<T> operator *(Length<T> length, Force<T> force )
         {
-            return Torque.FromNewtonMeters(force.Newtons*length.Meters);
+            return Torque<T>.FromNewtonMeters(force.Newtons*length.Meters);
         }
 
-        /// <summary>Get <see cref="KinematicViscosity"/> from <see cref="Length"/> times <see cref="Speed"/>.</summary>
-        public static KinematicViscosity operator *(Length length, Speed speed)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from <see cref="Length{T}"/> times <see cref="Speed{T}"/>.</summary>
+        public static KinematicViscosity<T> operator *(Length<T> length, Speed<T> speed )
         {
-            return KinematicViscosity.FromSquareMetersPerSecond(length.Meters*speed.MetersPerSecond);
+            return KinematicViscosity<T>.FromSquareMetersPerSecond(length.Meters*speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from <see cref="Length"/> times <see cref="SpecificWeight"/>.</summary>
-        public static Pressure operator *(Length length, SpecificWeight specificWeight)
+        /// <summary>Get <see cref="Pressure{T}"/> from <see cref="Length{T}"/> times <see cref="SpecificWeight{T}"/>.</summary>
+        public static Pressure<T> operator *(Length<T> length, SpecificWeight<T> specificWeight )
         {
-            return new Pressure(length.Meters * specificWeight.NewtonsPerCubicMeter, PressureUnit.Pascal);
+            return new Pressure<T>( length.Meters * specificWeight.NewtonsPerCubicMeter, PressureUnit.Pascal);
         }
     }
 
     /// <summary>
-    ///     Representation of feet and inches, used to preserve the original values when constructing <see cref="Length"/> by
-    ///     <see cref="Length.FromFeetInches"/> and later output them unaltered with <see cref="ToString()"/>.
+    ///     Representation of feet and inches, used to preserve the original values when constructing <see cref="Length{T}"/> by
+    ///     <see cref="Length{T}.FromFeetInches"/> and later output them unaltered with <see cref="ToString()"/>.
     /// </summary>
     public sealed class FeetInches
     {
diff --git a/UnitsNet/CustomCode/Quantities/Level.extra.cs b/UnitsNet/CustomCode/Quantities/Level.extra.cs
index a7b1a82825..493f3f09ce 100644
--- a/UnitsNet/CustomCode/Quantities/Level.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Level.extra.cs
@@ -6,10 +6,10 @@
 
 namespace UnitsNet
 {
-    public partial struct Level
+    public partial struct Level<T>
     {
         /// <summary>
-        ///     Initializes a new instance of the logarithmic <see cref="Level" /> struct which is the ratio of a quantity Q to a
+        ///     Initializes a new instance of the logarithmic <see cref="Level{T}" /> struct which is the ratio of a quantity Q to a
         ///     reference value of that quantity Q0.
         /// </summary>
         /// <param name="quantity">The quantity.</param>
@@ -27,7 +27,7 @@ public Level(double quantity, double reference)
                 throw new ArgumentOutOfRangeException(nameof(reference), errorMessage);
             // ReSharper restore CompareOfFloatsByEqualityOperator
 
-            _value = 10*Math.Log10(quantity/reference);
+            Value = 10*Math.Log10(quantity/reference);
             _unit = LevelUnit.Decibel;
         }
     }
diff --git a/UnitsNet/CustomCode/Quantities/Mass.extra.cs b/UnitsNet/CustomCode/Quantities/Mass.extra.cs
index b28c958182..9ecf19bb33 100644
--- a/UnitsNet/CustomCode/Quantities/Mass.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Mass.extra.cs
@@ -9,12 +9,12 @@
 
 namespace UnitsNet
 {
-    public partial struct Mass
+    public partial struct Mass<T>
     {
-        /// <summary>Get <see cref="Mass"/> from <see cref="Force"/> of gravity.</summary>
-        public static Mass FromGravitationalForce(Force f)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="Force{T}"/> of gravity.</summary>
+        public static Mass<T> FromGravitationalForce(Force<T> f )
         {
-            return new Mass(f.KilogramsForce, MassUnit.Kilogram);
+            return new Mass<T>( f.KilogramsForce, MassUnit.Kilogram);
         }
 
         /// <summary>
@@ -42,57 +42,57 @@ public StonePounds StonePounds
         /// <summary>
         ///     Get Mass from combination of stone and pounds.
         /// </summary>
-        public static Mass FromStonePounds(double stone, double pounds)
+        public static Mass<T> FromStonePounds(double stone, double pounds)
         {
             return FromPounds(StonesInOnePound*stone + pounds);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="Mass"/> divided by <see cref="TimeSpan"/>.</summary>
-        public static MassFlow operator /(Mass mass, TimeSpan timeSpan)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="Mass{T}"/> divided by <see cref="TimeSpan"/>.</summary>
+        public static MassFlow<T> operator /(Mass<T> mass, TimeSpan timeSpan)
         {
-            return MassFlow.FromKilogramsPerSecond(mass.Kilograms/timeSpan.TotalSeconds);
+            return MassFlow<T>.FromKilogramsPerSecond(mass.Kilograms/timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="Mass"/> divided by <see cref="Duration"/>.</summary>
-        public static MassFlow operator /(Mass mass, Duration duration)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="Mass{T}"/> divided by <see cref="Duration{T}"/>.</summary>
+        public static MassFlow<T> operator /(Mass<T> mass, Duration<T> duration )
         {
-            return MassFlow.FromKilogramsPerSecond(mass.Kilograms/duration.Seconds);
+            return MassFlow<T>.FromKilogramsPerSecond(mass.Kilograms/duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Density"/> from <see cref="MassFlow"/> divided by <see cref="Volume"/>.</summary>
-        public static Density operator /(Mass mass, Volume volume)
+        /// <summary>Get <see cref="Density{T}"/> from <see cref="MassFlow{T}"/> divided by <see cref="Volume{T}"/>.</summary>
+        public static Density<T> operator /(Mass<T> mass, Volume<T> volume )
         {
-            return Density.FromKilogramsPerCubicMeter(mass.Kilograms/volume.CubicMeters);
+            return Density<T>.FromKilogramsPerCubicMeter(mass.Kilograms/volume.CubicMeters);
         }
 
-        /// <summary>Get <see cref="Volume"/> from <see cref="Mass"/> divided by <see cref="Density"/>.</summary>
-        public static Volume operator /(Mass mass, Density density)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="Mass{T}"/> divided by <see cref="Density{T}"/>.</summary>
+        public static Volume<T> operator /(Mass<T> mass, Density<T> density )
         {
-            return Volume.FromCubicMeters(mass.Kilograms / density.KilogramsPerCubicMeter);
+            return Volume<T>.FromCubicMeters(mass.Kilograms / density.KilogramsPerCubicMeter);
         }
 
-        /// <summary>Get <see cref="AmountOfSubstance" /> from <see cref="MolarMass" /> divided by <see cref="Mass" />.</summary>
-        public static AmountOfSubstance operator /(Mass mass, MolarMass molarMass)
+        /// <summary>Get <see cref="AmountOfSubstance{T}" /> from <see cref="MolarMass{T}" /> divided by <see cref="Mass{T}" />.</summary>
+        public static AmountOfSubstance<T> operator /(Mass<T> mass, MolarMass<T> molarMass )
         {
-            return AmountOfSubstance.FromMoles(mass.Kilograms / molarMass.KilogramsPerMole);
+            return AmountOfSubstance<T>.FromMoles(mass.Kilograms / molarMass.KilogramsPerMole);
         }
 
-        /// <summary>Get <see cref="Force"/> from <see cref="Mass"/> times <see cref="Acceleration"/>.</summary>
-        public static Force operator *(Mass mass, Acceleration acceleration)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Mass{T}"/> times <see cref="Acceleration{T}"/>.</summary>
+        public static Force<T> operator *(Mass<T> mass, Acceleration<T> acceleration )
         {
-            return Force.FromNewtons(mass.Kilograms*acceleration.MetersPerSecondSquared);
+            return Force<T>.FromNewtons(mass.Kilograms*acceleration.MetersPerSecondSquared);
         }
 
-        /// <summary>Get <see cref="Force"/> from <see cref="Acceleration"/> times <see cref="Mass"/>.</summary>
-        public static Force operator *(Acceleration acceleration, Mass mass)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Acceleration{T}"/> times <see cref="Mass{T}"/>.</summary>
+        public static Force<T> operator *(Acceleration<T> acceleration, Mass<T> mass )
         {
-            return Force.FromNewtons(mass.Kilograms*acceleration.MetersPerSecondSquared);
+            return Force<T>.FromNewtons(mass.Kilograms*acceleration.MetersPerSecondSquared);
         }
     }
 
     /// <summary>
-    ///     Representation of stone and pounds, used to preserve the original values when constructing <see cref="Mass"/> by
-    ///     <see cref="Mass.FromStonePounds"/> and later output them unaltered with <see cref="ToString()"/>.
+    ///     Representation of stone and pounds, used to preserve the original values when constructing <see cref="Mass{T}"/> by
+    ///     <see cref="Mass{T}.FromStonePounds"/> and later output them unaltered with <see cref="ToString()"/>.
     /// </summary>
     public sealed class StonePounds
     {
diff --git a/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs b/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs
index edce6c4ee2..84ded33d69 100644
--- a/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs
@@ -5,23 +5,23 @@
 
 namespace UnitsNet
 {
-    public partial struct MassConcentration
+    public partial struct MassConcentration<T>
     {
         /// <summary>
-        ///     Get <see cref="Molarity" /> from this <see cref="MassConcentration" /> using the known component <see cref="MolarMass" />.
+        ///     Get <see cref="Molarity{T}" /> from this <see cref="MassConcentration{T}" /> using the known component <see cref="MolarMass{T}" />.
         /// </summary>
         /// <param name="molecularWeight"></param>
-        public Molarity ToMolarity(MolarMass molecularWeight)
+        public Molarity<T> ToMolarity(MolarMass<T> molecularWeight )
         {
             return this / molecularWeight;
         }
 
         /// <summary>
-        ///  Get <see cref="VolumeConcentration" /> from this <see cref="MassConcentration" /> using the known component <see cref="Density" />.
+        ///  Get <see cref="VolumeConcentration{T}" /> from this <see cref="MassConcentration{T}" /> using the known component <see cref="Density{T}" />.
         /// </summary>
         /// <param name="componentDensity"></param>
         /// <returns></returns>
-        public VolumeConcentration ToVolumeConcentration(Density componentDensity)
+        public VolumeConcentration<T> ToVolumeConcentration(Density<T> componentDensity )
         {
             return this / componentDensity;
         }
@@ -30,17 +30,17 @@ public VolumeConcentration ToVolumeConcentration(Density componentDensity)
         #region Static Methods
 
         /// <summary>
-        ///     Get <see cref="MassConcentration" /> from <see cref="Molarity" />.
+        ///     Get <see cref="MassConcentration{T}" /> from <see cref="Molarity{T}" />.
         /// </summary>
-        public static MassConcentration FromMolarity(Molarity molarity, MolarMass mass)
+        public static MassConcentration<T> FromMolarity(Molarity<T> molarity, MolarMass<T> mass )
         {
             return molarity * mass;
         }
 
         /// <summary>
-        ///     Get <see cref="MassConcentration" /> from <see cref="VolumeConcentration" /> and component <see cref="Density" />.
+        ///     Get <see cref="MassConcentration{T}" /> from <see cref="VolumeConcentration{T}" /> and component <see cref="Density{T}" />.
         /// </summary>
-        public static MassConcentration FromVolumeConcentration(VolumeConcentration volumeConcentration, Density componentDensity)
+        public static MassConcentration<T> FromVolumeConcentration(VolumeConcentration<T> volumeConcentration, Density<T> componentDensity )
         {
             return volumeConcentration * componentDensity;
         }
@@ -48,29 +48,29 @@ public static MassConcentration FromVolumeConcentration(VolumeConcentration volu
         #endregion
 
         #region Operators
-        
-        /// <summary>Get <see cref="Mass" /> from <see cref="MassConcentration" /> times <see cref="Volume" />.</summary>
-        public static Mass operator *(MassConcentration density, Volume volume)
+
+        /// <summary>Get <see cref="Mass{T}" /> from <see cref="MassConcentration{T}" /> times <see cref="Volume{T}" />.</summary>
+        public static Mass<T> operator *(MassConcentration<T> density, Volume<T> volume )
         {
-            return Mass.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
+            return Mass<T>.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
         }
 
-        /// <summary>Get <see cref="Mass" /> from <see cref="Volume" /> times <see cref="MassConcentration" />.</summary>
-        public static Mass operator *(Volume volume, MassConcentration density)
+        /// <summary>Get <see cref="Mass{T}" /> from <see cref="Volume{T}" /> times <see cref="MassConcentration{T}" />.</summary>
+        public static Mass<T> operator *(Volume<T> volume, MassConcentration<T> density )
         {
-            return Mass.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
+            return Mass<T>.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
         }
-        
-        /// <summary>Get <see cref="Molarity" /> from <see cref="MassConcentration" /> divided by the component's <see cref="MolarMass" />.</summary>
-        public static Molarity operator /(MassConcentration massConcentration, MolarMass componentMass)
+
+        /// <summary>Get <see cref="Molarity{T}" /> from <see cref="MassConcentration{T}" /> divided by the component's <see cref="MolarMass{T}" />.</summary>
+        public static Molarity<T> operator /(MassConcentration<T> massConcentration, MolarMass<T> componentMass )
         {
-            return Molarity.FromMolesPerCubicMeter(massConcentration.GramsPerCubicMeter / componentMass.GramsPerMole);
+            return Molarity<T>.FromMolesPerCubicMeter(massConcentration.GramsPerCubicMeter / componentMass.GramsPerMole);
         }
 
-        /// <summary>Get <see cref="VolumeConcentration" /> from <see cref="MassConcentration" /> divided by the component's <see cref="Density" />.</summary>
-        public static VolumeConcentration operator /(MassConcentration massConcentration, Density componentDensity)
+        /// <summary>Get <see cref="VolumeConcentration{T}" /> from <see cref="MassConcentration{T}" /> divided by the component's <see cref="Density{T}" />.</summary>
+        public static VolumeConcentration<T> operator /(MassConcentration<T> massConcentration, Density<T> componentDensity )
         {
-            return VolumeConcentration.FromDecimalFractions(massConcentration.KilogramsPerCubicMeter / componentDensity.KilogramsPerCubicMeter);
+            return VolumeConcentration<T>.FromDecimalFractions(massConcentration.KilogramsPerCubicMeter / componentDensity.KilogramsPerCubicMeter);
         }
 
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/MassFlow.extra.cs b/UnitsNet/CustomCode/Quantities/MassFlow.extra.cs
index e60c5c75d8..dcbabc97bf 100644
--- a/UnitsNet/CustomCode/Quantities/MassFlow.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/MassFlow.extra.cs
@@ -5,72 +5,72 @@
 
 namespace UnitsNet
 {
-    public partial struct MassFlow
+    public partial struct MassFlow<T>
     {
-        /// <summary>Get <see cref="Mass"/> from <see cref="MassFlow"/> times <see cref="TimeSpan"/>.</summary>
-        public static Mass operator *(MassFlow massFlow, TimeSpan time)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="MassFlow{T}"/> times <see cref="TimeSpan"/>.</summary>
+        public static Mass<T> operator *(MassFlow<T> massFlow, TimeSpan time)
         {
-            return Mass.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
+            return Mass<T>.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="TimeSpan"/> times <see cref="MassFlow"/>.</summary>
-        public static Mass operator *(TimeSpan time, MassFlow massFlow)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="TimeSpan"/> times <see cref="MassFlow{T}"/>.</summary>
+        public static Mass<T> operator *(TimeSpan time, MassFlow<T> massFlow )
         {
-            return Mass.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
+            return Mass<T>.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="MassFlow"/> times <see cref="Duration"/>.</summary>
-        public static Mass operator *(MassFlow massFlow, Duration duration)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="MassFlow{T}"/> times <see cref="Duration{T}"/>.</summary>
+        public static Mass<T> operator *(MassFlow<T> massFlow, Duration<T> duration )
         {
-            return Mass.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
+            return Mass<T>.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="Duration"/> times <see cref="MassFlow"/>.</summary>
-        public static Mass operator *(Duration duration, MassFlow massFlow)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="Duration{T}"/> times <see cref="MassFlow{T}"/>.</summary>
+        public static Mass<T> operator *(Duration<T> duration, MassFlow<T> massFlow )
         {
-            return Mass.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
+            return Mass<T>.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Power"/> from <see cref="MassFlow"/> divided by <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static Power operator /(MassFlow massFlow, BrakeSpecificFuelConsumption bsfc)
+        /// <summary>Get <see cref="Power{T}"/> from <see cref="MassFlow{T}"/> divided by <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static Power<T> operator /(MassFlow<T> massFlow, BrakeSpecificFuelConsumption<T> bsfc )
         {
-            return Power.FromWatts(massFlow.KilogramsPerSecond / bsfc.KilogramsPerJoule);
+            return Power<T>.FromWatts(massFlow.KilogramsPerSecond / bsfc.KilogramsPerJoule);
         }
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from <see cref="MassFlow"/> divided by <see cref="Power"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator /(MassFlow massFlow, Power power)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption{T}"/> from <see cref="MassFlow{T}"/> divided by <see cref="Power{T}"/>.</summary>
+        public static BrakeSpecificFuelConsumption<T> operator /(MassFlow<T> massFlow, Power<T> power )
         {
-            return BrakeSpecificFuelConsumption.FromKilogramsPerJoule(massFlow.KilogramsPerSecond / power.Watts);
+            return BrakeSpecificFuelConsumption<T>.FromKilogramsPerJoule(massFlow.KilogramsPerSecond / power.Watts);
         }
 
-        /// <summary>Get <see cref="Power"/> from <see cref="MassFlow"/> times <see cref="SpecificEnergy"/>.</summary>
-        public static Power operator *(MassFlow massFlow, SpecificEnergy specificEnergy)
+        /// <summary>Get <see cref="Power{T}"/> from <see cref="MassFlow{T}"/> times <see cref="SpecificEnergy{T}"/>.</summary>
+        public static Power<T> operator *(MassFlow<T> massFlow, SpecificEnergy<T> specificEnergy )
         {
-            return Power.FromWatts(massFlow.KilogramsPerSecond * specificEnergy.JoulesPerKilogram);
+            return Power<T>.FromWatts(massFlow.KilogramsPerSecond * specificEnergy.JoulesPerKilogram);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> from <see cref="MassFlow"/> divided by <see cref="Area"/>.</summary>
-        public static MassFlux operator /(MassFlow massFlow, Area area)
+        /// <summary>Get <see cref="MassFlux{T}"/> from <see cref="MassFlow{T}"/> divided by <see cref="Area{T}"/>.</summary>
+        public static MassFlux<T> operator /(MassFlow<T> massFlow, Area<T> area )
         {
-            return MassFlux.FromKilogramsPerSecondPerSquareMeter(massFlow.KilogramsPerSecond / area.SquareMeters);
+            return MassFlux<T>.FromKilogramsPerSecondPerSquareMeter(massFlow.KilogramsPerSecond / area.SquareMeters);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="MassFlow"/> divided by <see cref="MassFlux"/>.</summary>
-        public static Area operator /(MassFlow massFlow, MassFlux massFlux)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="MassFlow{T}"/> divided by <see cref="MassFlux{T}"/>.</summary>
+        public static Area<T> operator /(MassFlow<T> massFlow, MassFlux<T> massFlux )
         {
-            return Area.FromSquareMeters(massFlow.KilogramsPerSecond / massFlux.KilogramsPerSecondPerSquareMeter);
+            return Area<T>.FromSquareMeters(massFlow.KilogramsPerSecond / massFlux.KilogramsPerSecondPerSquareMeter);
         }
 
-        /// <summary>Get <see cref="Density"/> from <see cref="MassFlow"/> divided by <see cref="VolumeFlow"/>.</summary>
-        public static Density operator /(MassFlow massFlow, VolumeFlow volumeFlow)
+        /// <summary>Get <see cref="Density{T}"/> from <see cref="MassFlow{T}"/> divided by <see cref="VolumeFlow{T}"/>.</summary>
+        public static Density<T> operator /(MassFlow<T> massFlow, VolumeFlow<T> volumeFlow )
         {
-            return Density.FromKilogramsPerCubicMeter(massFlow.KilogramsPerSecond / volumeFlow.CubicMetersPerSecond);
+            return Density<T>.FromKilogramsPerCubicMeter(massFlow.KilogramsPerSecond / volumeFlow.CubicMetersPerSecond);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="MassFlow"/> divided by <see cref="Density"/>.</summary>
-        public static VolumeFlow operator /(MassFlow massFlow, Density density)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from <see cref="MassFlow{T}"/> divided by <see cref="Density{T}"/>.</summary>
+        public static VolumeFlow<T> operator /(MassFlow<T> massFlow, Density<T> density )
         {
-            return VolumeFlow.FromCubicMetersPerSecond(massFlow.KilogramsPerSecond / density.KilogramsPerCubicMeter);
+            return VolumeFlow<T>.FromCubicMetersPerSecond(massFlow.KilogramsPerSecond / density.KilogramsPerCubicMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/MassFlux.extra.cs b/UnitsNet/CustomCode/Quantities/MassFlux.extra.cs
index 654ce48a20..c005f050b3 100644
--- a/UnitsNet/CustomCode/Quantities/MassFlux.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/MassFlux.extra.cs
@@ -3,24 +3,24 @@
 
 namespace UnitsNet
 {
-    public partial struct MassFlux
+    public partial struct MassFlux<T>
     {
-        /// <summary>Get <see cref="Density"/> from <see cref="MassFlux"/> divided by <see cref="Speed"/>.</summary>
-        public static Density operator /(MassFlux massFlux, Speed speed)
+        /// <summary>Get <see cref="Density{T}"/> from <see cref="MassFlux{T}"/> divided by <see cref="Speed{T}"/>.</summary>
+        public static Density<T> operator /(MassFlux<T> massFlux, Speed<T> speed )
         {
-            return Density.FromKilogramsPerCubicMeter(massFlux.KilogramsPerSecondPerSquareMeter / speed.MetersPerSecond);
+            return Density<T>.FromKilogramsPerCubicMeter(massFlux.KilogramsPerSecondPerSquareMeter / speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="Speed"/> from <see cref="MassFlux"/> divided by <see cref="Density"/>.</summary>
-        public static Speed operator /(MassFlux massFlux, Density density)
+        /// <summary>Get <see cref="Speed{T}"/> from <see cref="MassFlux{T}"/> divided by <see cref="Density{T}"/>.</summary>
+        public static Speed<T> operator /(MassFlux<T> massFlux, Density<T> density )
         {
-            return Speed.FromMetersPerSecond(massFlux.KilogramsPerSecondPerSquareMeter / density.KilogramsPerCubicMeter);
+            return Speed<T>.FromMetersPerSecond(massFlux.KilogramsPerSecondPerSquareMeter / density.KilogramsPerCubicMeter);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="MassFlux"/> times <see cref="Area"/>.</summary>
-        public static MassFlow operator *(MassFlux massFlux, Area area)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="MassFlux{T}"/> times <see cref="Area{T}"/>.</summary>
+        public static MassFlow<T> operator *(MassFlux<T> massFlux, Area<T> area )
         {
-            return MassFlow.FromGramsPerSecond(massFlux.GramsPerSecondPerSquareMeter * area.SquareMeters);
+            return MassFlow<T>.FromGramsPerSecond(massFlux.GramsPerSecondPerSquareMeter * area.SquareMeters);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs b/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs
index c685887214..9676ab5beb 100644
--- a/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs
@@ -2,24 +2,24 @@
 
 namespace UnitsNet
 {
-    public partial struct MassFraction
+    public partial struct MassFraction<T>
     {
         /// <summary>
-        /// Get the <see cref="Mass"/> of the component by multiplying the <see cref="Mass"/> of the mixture and this <see cref="MassFraction"/>.
+        /// Get the <see cref="Mass{T}"/> of the component by multiplying the <see cref="Mass{T}"/> of the mixture and this <see cref="MassFraction{T}"/>.
         /// </summary>
         /// <param name="totalMass">The total mass of the mixture</param>
         /// <returns>The actual mass of the component involved in this mixture</returns>
-        public Mass GetComponentMass(Mass totalMass)
+        public Mass<T> GetComponentMass(Mass<T> totalMass )
         {
             return totalMass * this;
         }
 
         /// <summary>
-        /// Get the total <see cref="Mass"/> of the mixture by dividing the <see cref="Mass"/> of the component by this <see cref="MassFraction"/>
+        /// Get the total <see cref="Mass{T}"/> of the mixture by dividing the <see cref="Mass{T}"/> of the component by this <see cref="MassFraction{T}"/>
         /// </summary>
         /// <param name="componentMass">The actual mass of the component involved in this mixture</param>
         /// <returns>The total mass of the mixture</returns>
-        public Mass GetTotalMass(Mass componentMass)
+        public Mass<T> GetTotalMass(Mass<T> componentMass )
         {
             return componentMass / this;
         }
@@ -27,30 +27,30 @@ public Mass GetTotalMass(Mass componentMass)
         #region Static Methods
 
         /// <summary>
-        ///     Get <see cref="MassFraction" /> from a component <see cref="Mass" /> and total mixture <see cref="Mass" /> .
+        ///     Get <see cref="MassFraction{T}" /> from a component <see cref="Mass{T}" /> and total mixture <see cref="Mass{T}" /> .
         /// </summary>
-        public static MassFraction FromMasses(Mass componentMass, Mass mixtureMass)
+        public static MassFraction<T> FromMasses(Mass<T> componentMass, Mass<T> mixtureMass )
         {
-            return new MassFraction(componentMass / mixtureMass, MassFractionUnit.DecimalFraction);
+            return new MassFraction<T>( componentMass / mixtureMass, MassFractionUnit.DecimalFraction);
         }
 
         #endregion
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="Mass"/> multiplied by a <see cref="MassFraction"/>.</summary>
-        public static Mass operator *(MassFraction massFraction, Mass mass)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="Mass{T}"/> multiplied by a <see cref="MassFraction{T}"/>.</summary>
+        public static Mass<T> operator *(MassFraction<T> massFraction, Mass<T> mass )
         {
-            return Mass.FromKilograms(massFraction.DecimalFractions * mass.Kilograms);
+            return Mass<T>.FromKilograms(massFraction.DecimalFractions * mass.Kilograms);
         }
 
-        /// <summary>Get <see cref="Mass"/> from <see cref="Mass"/> multiplied by a <see cref="MassFraction"/>.</summary>
-        public static Mass operator *(Mass mass, MassFraction massFraction)
+        /// <summary>Get <see cref="Mass{T}"/> from <see cref="Mass{T}"/> multiplied by a <see cref="MassFraction{T}"/>.</summary>
+        public static Mass<T> operator *(Mass<T> mass, MassFraction<T> massFraction )
         {
-            return Mass.FromKilograms(massFraction.DecimalFractions * mass.Kilograms);
+            return Mass<T>.FromKilograms(massFraction.DecimalFractions * mass.Kilograms);
         }
-        /// <summary>Get the total <see cref="Mass"/> by dividing the component  <see cref="Mass"/> by a <see cref="MassFraction"/>.</summary>
-        public static Mass operator /(Mass mass, MassFraction massFraction)
+        /// <summary>Get the total <see cref="Mass{T}"/> by dividing the component  <see cref="Mass{T}"/> by a <see cref="MassFraction{T}"/>.</summary>
+        public static Mass<T> operator /(Mass<T> mass, MassFraction<T> massFraction )
         {
-            return Mass.FromKilograms(mass.Kilograms / massFraction.DecimalFractions);
+            return Mass<T>.FromKilograms(mass.Kilograms / massFraction.DecimalFractions);
         }
 
     }
diff --git a/UnitsNet/CustomCode/Quantities/Molarity.extra.cs b/UnitsNet/CustomCode/Quantities/Molarity.extra.cs
index 53af6eeb15..b174705e68 100644
--- a/UnitsNet/CustomCode/Quantities/Molarity.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Molarity.extra.cs
@@ -3,46 +3,46 @@
 
 namespace UnitsNet
 {
-    public partial struct Molarity
+    public partial struct Molarity<T>
     {
         /// <summary>
-        ///     Construct from <see cref="Density"/> divided by <see cref="Mass"/>.
+        ///     Construct from <see cref="Density{T}"/> divided by <see cref="Mass{T}"/>.
         /// </summary>
-        /// <seealso cref="MassConcentration.op_Division(MassConcentration,MolarMass)"/>
+        /// <seealso cref="MassConcentration{T}.op_Division(MassConcentration{T}, MolarMass{T})"/>
         [Obsolete("This constructor will be removed in favor of operator overload MassConcentration.op_Division(MassConcentration,MolarMass).")]
-        public Molarity(Density density, Mass molecularWeight)
+        public Molarity(Density<T> density, Mass<T> molecularWeight )
             : this()
         {
-            _value = density.KilogramsPerCubicMeter / molecularWeight.Kilograms;
+            Value = density.KilogramsPerCubicMeter / molecularWeight.Kilograms;
             _unit = MolarityUnit.MolesPerCubicMeter;
         }
 
         /// <summary>
-        ///     Get a <see cref="Density"/> from this <see cref="Molarity"/>.
+        ///     Get a <see cref="Density{T}"/> from this <see cref="Molarity{T}"/>.
         /// </summary>
         /// <param name="molecularWeight"></param>
-        /// <seealso cref="ToMassConcentration(MolarMass)"/>
+        /// <seealso cref="ToMassConcentration(MolarMass{T})"/>
         [Obsolete("This method will be removed in favor of ToMassConcentration(MolarMass)")]
-        public Density ToDensity(Mass molecularWeight)
+        public Density<T> ToDensity(Mass<T> molecularWeight )
         {
-            return Density.FromKilogramsPerCubicMeter(MolesPerCubicMeter * molecularWeight.Kilograms);
+            return Density<T>.FromKilogramsPerCubicMeter(MolesPerCubicMeter * molecularWeight.Kilograms);
         }
 
         /// <summary>
-        ///     Get a <see cref="MassConcentration"/> from this <see cref="Molarity"/>.
+        ///     Get a <see cref="MassConcentration{T}"/> from this <see cref="Molarity{T}"/>.
         /// </summary>
         /// <param name="molecularWeight"></param>
-        public MassConcentration ToMassConcentration(MolarMass molecularWeight) 
+        public MassConcentration<T> ToMassConcentration(MolarMass<T> molecularWeight ) 
         {
             return this * molecularWeight; 
         }
 
         /// <summary>
-        ///     Get a <see cref="MassConcentration"/> from this <see cref="Molarity"/>.
+        ///     Get a <see cref="MassConcentration{T}"/> from this <see cref="Molarity{T}"/>.
         /// </summary>
         /// <param name="componentDensity"></param>
         /// <param name="componentMass"></param>
-        public VolumeConcentration ToVolumeConcentration(Density componentDensity, MolarMass componentMass)
+        public VolumeConcentration<T> ToVolumeConcentration(Density<T> componentDensity, MolarMass<T> componentMass )
         {
             return this * componentMass / componentDensity;
         }
@@ -50,24 +50,24 @@ public VolumeConcentration ToVolumeConcentration(Density componentDensity, Molar
         #region Static Methods
 
         /// <summary>
-        ///     Get <see cref="Molarity"/> from <see cref="Density"/>.
+        ///     Get <see cref="Molarity{T}"/> from <see cref="Density{T}"/>.
         /// </summary>
         /// <param name="density"></param>
         /// <param name="molecularWeight"></param>
         [Obsolete("Use MassConcentration / MolarMass operator overload instead.")]
-        public static Molarity FromDensity(Density density, Mass molecularWeight)
+        public static Molarity<T> FromDensity(Density<T> density, Mass<T> molecularWeight )
         {
             return density / molecularWeight;
         }
 
         /// <summary>
-        ///  Get <see cref="Molarity"/> from <see cref="VolumeConcentration"/> and known component <see cref="Density"/> and <see cref="MolarMass"/>.
+        ///  Get <see cref="Molarity{T}"/> from <see cref="VolumeConcentration{T}"/> and known component <see cref="Density{T}"/> and <see cref="MolarMass{T}"/>.
         /// </summary>
         /// <param name="volumeConcentration"></param>
         /// <param name="componentDensity"></param>
         /// <param name="componentMass"></param>
         /// <returns></returns>
-        public static Molarity FromVolumeConcentration(VolumeConcentration volumeConcentration, Density componentDensity, MolarMass componentMass)
+        public static Molarity<T> FromVolumeConcentration(VolumeConcentration<T> volumeConcentration, Density<T> componentDensity, MolarMass<T> componentMass )
         {
             return volumeConcentration * componentDensity / componentMass;
         }
@@ -76,28 +76,28 @@ public static Molarity FromVolumeConcentration(VolumeConcentration volumeConcent
 
         #region Operators
 
-        /// <summary>Get <see cref="MassConcentration" /> from <see cref="Molarity" /> times the <see cref="MolarMass" />.</summary>
-        public static MassConcentration operator *(Molarity molarity, MolarMass componentMass)
+        /// <summary>Get <see cref="MassConcentration{T}" /> from <see cref="Molarity{T}" /> times the <see cref="MolarMass{T}" />.</summary>
+        public static MassConcentration<T> operator *(Molarity<T> molarity, MolarMass<T> componentMass )
         {
-            return MassConcentration.FromGramsPerCubicMeter(molarity.MolesPerCubicMeter * componentMass.GramsPerMole);
+            return MassConcentration<T>.FromGramsPerCubicMeter(molarity.MolesPerCubicMeter * componentMass.GramsPerMole);
         }
 
-        /// <summary>Get <see cref="MassConcentration" /> from <see cref="MolarMass" /> times the <see cref="Molarity" />.</summary>
-        public static MassConcentration operator *(MolarMass componentMass, Molarity molarity)
+        /// <summary>Get <see cref="MassConcentration{T}" /> from <see cref="MolarMass{T}" /> times the <see cref="Molarity{T}" />.</summary>
+        public static MassConcentration<T> operator *(MolarMass<T> componentMass, Molarity<T> molarity )
         {
-            return MassConcentration.FromGramsPerCubicMeter(molarity.MolesPerCubicMeter * componentMass.GramsPerMole);
+            return MassConcentration<T>.FromGramsPerCubicMeter(molarity.MolesPerCubicMeter * componentMass.GramsPerMole);
         }
 
-        /// <summary>Get <see cref="Molarity" /> from diluting the current <see cref="Molarity" /> by the given <see cref="VolumeConcentration" />.</summary>
-        public static Molarity operator *(Molarity molarity, VolumeConcentration volumeConcentration)
+        /// <summary>Get <see cref="Molarity{T}" /> from diluting the current <see cref="Molarity{T}" /> by the given <see cref="VolumeConcentration{T}" />.</summary>
+        public static Molarity<T> operator *(Molarity<T> molarity, VolumeConcentration<T> volumeConcentration )
         {
-            return new Molarity(molarity.MolesPerCubicMeter * volumeConcentration.DecimalFractions, MolarityUnit.MolesPerCubicMeter);
+            return new Molarity<T>( molarity.MolesPerCubicMeter * volumeConcentration.DecimalFractions, MolarityUnit.MolesPerCubicMeter);
         }
 
-        /// <summary>Get <see cref="Molarity" /> from diluting the current <see cref="Molarity" /> by the given <see cref="VolumeConcentration" />.</summary>
-        public static Molarity operator *(VolumeConcentration volumeConcentration, Molarity molarity)
+        /// <summary>Get <see cref="Molarity{T}" /> from diluting the current <see cref="Molarity{T}" /> by the given <see cref="VolumeConcentration{T}" />.</summary>
+        public static Molarity<T> operator *(VolumeConcentration<T> volumeConcentration, Molarity<T> molarity )
         {
-            return new Molarity(molarity.MolesPerCubicMeter * volumeConcentration.DecimalFractions, MolarityUnit.MolesPerCubicMeter);
+            return new Molarity<T>( molarity.MolesPerCubicMeter * volumeConcentration.DecimalFractions, MolarityUnit.MolesPerCubicMeter);
         }
 
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/Power.extra.cs b/UnitsNet/CustomCode/Quantities/Power.extra.cs
index 187c2740fc..97ec0f9157 100644
--- a/UnitsNet/CustomCode/Quantities/Power.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Power.extra.cs
@@ -5,10 +5,10 @@
 
 namespace UnitsNet
 {
-    public partial struct Power
+    public partial struct Power<T>
     {
         /// <summary>
-        ///     Gets a <see cref="PowerRatio" /> from this <see cref="Power" /> relative to one watt.
+        ///     Gets a <see cref="PowerRatio{T}" /> from this <see cref="Power{T}" /> relative to one watt.
         /// </summary>
         /// <remarks>
         ///     Provides a nicer syntax for converting a power to a power ratio (relative to 1 watt).
@@ -16,81 +16,81 @@ public partial struct Power
         ///         <c>var powerRatio = power.ToPowerRatio();</c>
         ///     </example>
         /// </remarks>
-        public PowerRatio ToPowerRatio()
+        public PowerRatio<T> ToPowerRatio()
         {
-            return PowerRatio.FromPower(this);
+            return PowerRatio<T>.FromPower(this);
         }
 
-        /// <summary>Get <see cref="Energy"/> from <see cref="Power"/> times <see cref="TimeSpan"/>.</summary>
-        public static Energy operator *(Power power, TimeSpan time)
+        /// <summary>Get <see cref="Energy{T}"/> from <see cref="Power{T}"/> times <see cref="TimeSpan"/>.</summary>
+        public static Energy<T> operator *(Power<T> power, TimeSpan time)
         {
-            return Energy.FromJoules(power.Watts * time.TotalSeconds);
+            return Energy<T>.FromJoules(power.Watts * time.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Energy"/> from <see cref="TimeSpan"/> times <see cref="Power"/>.</summary>
-        public static Energy operator *(TimeSpan time, Power power)
+        /// <summary>Get <see cref="Energy{T}"/> from <see cref="TimeSpan"/> times <see cref="Power{T}"/>.</summary>
+        public static Energy<T> operator *(TimeSpan time, Power<T> power )
         {
-            return Energy.FromJoules(power.Watts * time.TotalSeconds);
+            return Energy<T>.FromJoules(power.Watts * time.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Energy"/> from <see cref="Power"/> times <see cref="Duration"/>.</summary>
-        public static Energy operator *(Power power, Duration duration)
+        /// <summary>Get <see cref="Energy{T}"/> from <see cref="Power{T}"/> times <see cref="Duration{T}"/>.</summary>
+        public static Energy<T> operator *(Power<T> power, Duration<T> duration )
         {
-            return Energy.FromJoules(power.Watts * duration.Seconds);
+            return Energy<T>.FromJoules(power.Watts * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Energy"/> from <see cref="Duration"/> times <see cref="Power"/>.</summary>
-        public static Energy operator *(Duration duration, Power power)
+        /// <summary>Get <see cref="Energy{T}"/> from <see cref="Duration{T}"/> times <see cref="Power{T}"/>.</summary>
+        public static Energy<T> operator *(Duration<T> duration, Power<T> power )
         {
-            return Energy.FromJoules(power.Watts * duration.Seconds);
+            return Energy<T>.FromJoules(power.Watts * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Force"/> from <see cref="Power"/> divided by <see cref="Speed"/>.</summary>
-        public static Force operator /(Power power, Speed speed)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Power{T}"/> divided by <see cref="Speed{T}"/>.</summary>
+        public static Force<T> operator /(Power<T> power, Speed<T> speed )
         {
-            return Force.FromNewtons(power.Watts / speed.MetersPerSecond);
+            return Force<T>.FromNewtons(power.Watts / speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="Torque"/> from <see cref="Power"/> divided by <see cref="RotationalSpeed"/>.</summary>
-        public static Torque operator /(Power power, RotationalSpeed rotationalSpeed)
+        /// <summary>Get <see cref="Torque{T}"/> from <see cref="Power{T}"/> divided by <see cref="RotationalSpeed{T}"/>.</summary>
+        public static Torque<T> operator /(Power<T> power, RotationalSpeed<T> rotationalSpeed )
         {
-            return Torque.FromNewtonMeters(power.Watts / rotationalSpeed.RadiansPerSecond);
+            return Torque<T>.FromNewtonMeters(power.Watts / rotationalSpeed.RadiansPerSecond);
         }
 
-        /// <summary>Get <see cref="RotationalSpeed"/> from <see cref="Power"/> divided by <see cref="Torque"/>.</summary>
-        public static RotationalSpeed operator /(Power power, Torque torque)
+        /// <summary>Get <see cref="RotationalSpeed{T}"/> from <see cref="Power{T}"/> divided by <see cref="Torque{T}"/>.</summary>
+        public static RotationalSpeed<T> operator /(Power<T> power, Torque<T> torque )
         {
-            return RotationalSpeed.FromRadiansPerSecond(power.Watts / torque.NewtonMeters);
+            return RotationalSpeed<T>.FromRadiansPerSecond(power.Watts / torque.NewtonMeters);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="Power"/> times <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static MassFlow operator *(Power power, BrakeSpecificFuelConsumption bsfc)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="Power{T}"/> times <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static MassFlow<T> operator *(Power<T> power, BrakeSpecificFuelConsumption<T> bsfc )
         {
-            return MassFlow.FromKilogramsPerSecond(bsfc.KilogramsPerJoule * power.Watts);
+            return MassFlow<T>.FromKilogramsPerSecond(bsfc.KilogramsPerJoule * power.Watts);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from <see cref="Power"/> divided by <see cref="MassFlow"/>.</summary>
-        public static SpecificEnergy operator /(Power power, MassFlow massFlow)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from <see cref="Power{T}"/> divided by <see cref="MassFlow{T}"/>.</summary>
+        public static SpecificEnergy<T> operator /(Power<T> power, MassFlow<T> massFlow )
         {
-            return SpecificEnergy.FromJoulesPerKilogram(power.Watts / massFlow.KilogramsPerSecond);
+            return SpecificEnergy<T>.FromJoulesPerKilogram(power.Watts / massFlow.KilogramsPerSecond);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="Power"/> divided by <see cref="SpecificEnergy"/>.</summary>
-        public static MassFlow operator /(Power power, SpecificEnergy specificEnergy)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="Power{T}"/> divided by <see cref="SpecificEnergy{T}"/>.</summary>
+        public static MassFlow<T> operator /(Power<T> power, SpecificEnergy<T> specificEnergy )
         {
-            return MassFlow.FromKilogramsPerSecond(power.Watts / specificEnergy.JoulesPerKilogram);
+            return MassFlow<T>.FromKilogramsPerSecond(power.Watts / specificEnergy.JoulesPerKilogram);
         }
 
-        /// <summary>Get <see cref="HeatFlux"/> from <see cref="Power"/> divided by <see cref="Area"/>.</summary>
-        public static HeatFlux operator /(Power power, Area area)
+        /// <summary>Get <see cref="HeatFlux{T}"/> from <see cref="Power{T}"/> divided by <see cref="Area{T}"/>.</summary>
+        public static HeatFlux<T> operator /(Power<T> power, Area<T> area )
         {
-            return HeatFlux.FromWattsPerSquareMeter(power.Watts / area.SquareMeters);
+            return HeatFlux<T>.FromWattsPerSquareMeter(power.Watts / area.SquareMeters);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="Power"/> divided by <see cref="HeatFlux"/>.</summary>
-        public static Area operator /(Power power, HeatFlux heatFlux)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="Power{T}"/> divided by <see cref="HeatFlux{T}"/>.</summary>
+        public static Area<T> operator /(Power<T> power, HeatFlux<T> heatFlux )
         {
-            return Area.FromSquareMeters( power.Watts / heatFlux.WattsPerSquareMeter );
+            return Area<T>.FromSquareMeters( power.Watts / heatFlux.WattsPerSquareMeter );
         }
 
         /// <summary>Calculate <see cref="ElectricCurrent"/> from <see cref="Power"/> divided by <see cref="ElectricPotential"/>.</summary>
diff --git a/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs b/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs
index f563f720ae..68af34cb7b 100644
--- a/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs
@@ -6,14 +6,14 @@
 
 namespace UnitsNet
 {
-    public partial struct PowerRatio
+    public partial struct PowerRatio<T>
     {
         /// <summary>
-        ///     Initializes a new instance of the <see cref="PowerRatio" /> struct from the specified power referenced to one watt.
+        ///     Initializes a new instance of the <see cref="PowerRatio{T}" /> struct from the specified power referenced to one watt.
         /// </summary>
         /// <param name="power">The power relative to one watt.</param>
 
-        public PowerRatio(Power power)
+        public PowerRatio(Power<T> power )
             : this()
         {
             if (power.Watts <= 0)
@@ -21,12 +21,12 @@ public PowerRatio(Power power)
                     nameof(power), "The base-10 logarithm of a number ≤ 0 is undefined. Power must be greater than 0 W.");
 
             // P(dBW) = 10*log10(value(W)/reference(W))
-            _value = 10 * Math.Log10(power.Watts / 1);
+            Value = 10 * Math.Log10(power.Watts / 1);
             _unit = PowerRatioUnit.DecibelWatt;
         }
 
         /// <summary>
-        ///     Gets a <see cref="Power" /> from this <see cref="PowerRatio" /> (which is a power level relative to one watt).
+        ///     Gets a <see cref="Power{T}" /> from this <see cref="PowerRatio{T}" /> (which is a power level relative to one watt).
         /// </summary>
         /// <remarks>
         ///     Provides a nicer syntax for converting a power ratio back to a power.
@@ -34,31 +34,31 @@ public PowerRatio(Power power)
         ///         <c>var power = powerRatio.ToPower();</c>
         ///     </example>
         /// </remarks>
-        public Power ToPower()
+        public Power<T> ToPower()
         {
             // P(W) = 1W * 10^(P(dBW)/10)
-            return Power.FromWatts(Math.Pow(10, DecibelWatts / 10));
+            return Power<T>.FromWatts(Math.Pow(10, DecibelWatts / 10));
         }
 
         /// <summary>
-        ///     Gets a <see cref="AmplitudeRatio" /> from this <see cref="PowerRatio" />.
+        ///     Gets a <see cref="AmplitudeRatio{T}" /> from this <see cref="PowerRatio{T}" />.
         /// </summary>
         /// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
-        public AmplitudeRatio ToAmplitudeRatio(ElectricResistance impedance)
+        public AmplitudeRatio<T> ToAmplitudeRatio(ElectricResistance<T> impedance )
         {
             // E(dBV) = 10*log10(Z(Ω)/1) + P(dBW)
-            return AmplitudeRatio.FromDecibelVolts(10 * Math.Log10(impedance.Ohms / 1) + DecibelWatts);
+            return AmplitudeRatio<T>.FromDecibelVolts(10 * Math.Log10(impedance.Ohms / 1) + DecibelWatts);
         }
 
         #region Static Methods
 
         /// <summary>
-        ///     Gets a <see cref="PowerRatio" /> from a <see cref="Power" /> relative to one watt.
+        ///     Gets a <see cref="PowerRatio{T}" /> from a <see cref="Power{T}" /> relative to one watt.
         /// </summary>
         /// <param name="power">The power relative to one watt.</param>
-        public static PowerRatio FromPower(Power power)
+        public static PowerRatio<T> FromPower(Power<T> power )
         {
-            return new PowerRatio(power);
+            return new PowerRatio<T>( power);
         }
 
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs
index ecaf977ed6..652ff729b4 100644
--- a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs
@@ -3,30 +3,30 @@
 
 namespace UnitsNet
 {
-    public partial struct Pressure
+    public partial struct Pressure<T>
     {
-        /// <summary>Get <see cref="Force"/> from <see cref="Pressure"/> times <see cref="Area"/>.</summary>
-        public static Force operator *(Pressure pressure, Area area)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Pressure{T}"/> times <see cref="Area{T}"/>.</summary>
+        public static Force<T> operator *(Pressure<T> pressure, Area<T> area )
         {
-            return Force.FromNewtons(pressure.Pascals * area.SquareMeters);
+            return Force<T>.FromNewtons(pressure.Pascals * area.SquareMeters);
         }
 
-        /// <summary>Get <see cref="Force"/> from <see cref="Area"/> times <see cref="Pressure"/>.</summary>
-        public static Force operator *(Area area, Pressure pressure)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Area{T}"/> times <see cref="Pressure{T}"/>.</summary>
+        public static Force<T> operator *(Area<T> area, Pressure<T> pressure )
         {
-            return Force.FromNewtons(pressure.Pascals * area.SquareMeters);
+            return Force<T>.FromNewtons(pressure.Pascals * area.SquareMeters);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Pressure"/> divided by <see cref="SpecificWeight"/>.</summary>
-        public static Length operator /(Pressure pressure, SpecificWeight specificWeight)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Pressure{T}"/> divided by <see cref="SpecificWeight{T}"/>.</summary>
+        public static Length<T> operator /(Pressure<T> pressure, SpecificWeight<T> specificWeight )
         {
-            return new Length(pressure.Pascals / specificWeight.NewtonsPerCubicMeter, UnitsNet.Units.LengthUnit.Meter);
+            return new Length<T>( pressure.Pascals / specificWeight.NewtonsPerCubicMeter, UnitsNet.Units.LengthUnit.Meter);
         }
 
-        /// <summary>Get <see cref="SpecificWeight"/> from <see cref="Pressure"/> divided by <see cref="Length"/>.</summary>
-        public static SpecificWeight operator /(Pressure pressure, Length length)
+        /// <summary>Get <see cref="SpecificWeight{T}"/> from <see cref="Pressure{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static SpecificWeight<T> operator /(Pressure<T> pressure, Length<T> length )
         {
-            return new SpecificWeight(pressure.Pascals / length.Meters, UnitsNet.Units.SpecificWeightUnit.NewtonPerCubicMeter);
+            return new SpecificWeight<T>( pressure.Pascals / length.Meters, UnitsNet.Units.SpecificWeightUnit.NewtonPerCubicMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/RotationalSpeed.extra.cs b/UnitsNet/CustomCode/Quantities/RotationalSpeed.extra.cs
index a1f18c79cd..b6f6d326a4 100644
--- a/UnitsNet/CustomCode/Quantities/RotationalSpeed.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/RotationalSpeed.extra.cs
@@ -5,30 +5,30 @@
 
 namespace UnitsNet
 {
-    public partial struct RotationalSpeed
+    public partial struct RotationalSpeed<T>
     {
-        /// <summary>Get <see cref="Angle"/> from <see cref="RotationalSpeed"/> times <see cref="TimeSpan"/>.</summary>
-        public static Angle operator *(RotationalSpeed rotationalSpeed, TimeSpan timeSpan)
+        /// <summary>Get <see cref="Angle{T}"/> from <see cref="RotationalSpeed{T}"/> times <see cref="TimeSpan"/>.</summary>
+        public static Angle<T> operator *(RotationalSpeed<T> rotationalSpeed, TimeSpan timeSpan )
         {
-            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
+            return Angle<T>.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Angle"/> from <see cref="TimeSpan"/> times <see cref="RotationalSpeed"/>.</summary>
-        public static Angle operator *(TimeSpan timeSpan, RotationalSpeed rotationalSpeed)
+        /// <summary>Get <see cref="Angle{T}"/> from <see cref="TimeSpan"/> times <see cref="RotationalSpeed{T}"/>.</summary>
+        public static Angle<T> operator *(TimeSpan timeSpan, RotationalSpeed<T> rotationalSpeed )
         {
-            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
+            return Angle<T>.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Angle"/> from <see cref="RotationalSpeed"/> times <see cref="Duration"/>.</summary>
-        public static Angle operator *(RotationalSpeed rotationalSpeed, Duration duration)
+        /// <summary>Get <see cref="Angle{T}"/> from <see cref="RotationalSpeed{T}"/> times <see cref="Duration{T}"/>.</summary>
+        public static Angle<T> operator *(RotationalSpeed<T> rotationalSpeed, Duration<T> duration )
         {
-            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
+            return Angle<T>.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Angle"/> from <see cref="Duration"/> times <see cref="RotationalSpeed"/>.</summary>
-        public static Angle operator *(Duration duration, RotationalSpeed rotationalSpeed)
+        /// <summary>Get <see cref="Angle{T}"/> from <see cref="Duration{T}"/> times <see cref="RotationalSpeed{T}"/>.</summary>
+        public static Angle<T> operator *(Duration<T> duration, RotationalSpeed<T> rotationalSpeed )
         {
-            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
+            return Angle<T>.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/RotationalStiffness.extra.cs b/UnitsNet/CustomCode/Quantities/RotationalStiffness.extra.cs
index 48b9342455..700d01030f 100644
--- a/UnitsNet/CustomCode/Quantities/RotationalStiffness.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/RotationalStiffness.extra.cs
@@ -3,24 +3,24 @@
 
 namespace UnitsNet
 {
-    public partial struct RotationalStiffness
+    public partial struct RotationalStiffness<T>
     {
-        /// <summary>Get <see cref="Torque"/> from <see cref="RotationalStiffness"/> times <see cref="Angle"/>.</summary>
-        public static Torque operator *(RotationalStiffness rotationalStiffness, Angle angle)
+        /// <summary>Get <see cref="Torque{T}"/> from <see cref="RotationalStiffness{T}"/> times <see cref="Angle{T}"/>.</summary>
+        public static Torque<T> operator *(RotationalStiffness<T> rotationalStiffness, Angle<T> angle )
         {
-            return Torque.FromNewtonMeters(rotationalStiffness.NewtonMetersPerRadian * angle.Radians);
+            return Torque<T>.FromNewtonMeters(rotationalStiffness.NewtonMetersPerRadian * angle.Radians);
         }
 
-        /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffness"/> divided by <see cref="Length"/>.</summary>
-        public static RotationalStiffnessPerLength operator /(RotationalStiffness rotationalStiffness, Length length)
+        /// <summary>Get <see cref="RotationalStiffnessPerLength{T}"/> from <see cref="RotationalStiffness{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static RotationalStiffnessPerLength<T> operator /(RotationalStiffness<T> rotationalStiffness, Length<T> length )
         {
-            return RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(rotationalStiffness.NewtonMetersPerRadian / length.Meters);
+            return RotationalStiffnessPerLength<T>.FromNewtonMetersPerRadianPerMeter(rotationalStiffness.NewtonMetersPerRadian / length.Meters);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="RotationalStiffness"/> divided by <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static Length operator /(RotationalStiffness rotationalStiffness, RotationalStiffnessPerLength rotationalStiffnessPerLength)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="RotationalStiffness{T}"/> divided by <see cref="RotationalStiffnessPerLength{T}"/>.</summary>
+        public static Length<T> operator /(RotationalStiffness<T> rotationalStiffness, RotationalStiffnessPerLength<T> rotationalStiffnessPerLength )
         {
-            return Length.FromMeters(rotationalStiffness.NewtonMetersPerRadian / rotationalStiffnessPerLength.NewtonMetersPerRadianPerMeter);
+            return Length<T>.FromMeters(rotationalStiffness.NewtonMetersPerRadian / rotationalStiffnessPerLength.NewtonMetersPerRadianPerMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/RotationalStiffnessPerLength.extra.cs b/UnitsNet/CustomCode/Quantities/RotationalStiffnessPerLength.extra.cs
index 1aef772c05..693146a611 100644
--- a/UnitsNet/CustomCode/Quantities/RotationalStiffnessPerLength.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/RotationalStiffnessPerLength.extra.cs
@@ -4,12 +4,12 @@
 // ReSharper disable once CheckNamespace
 namespace UnitsNet
 {
-    public partial struct RotationalStiffnessPerLength
+    public partial struct RotationalStiffnessPerLength<T>
     {
-        /// <summary>Get <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessPerLength"/> times <see cref="Length"/>.</summary>
-        public static RotationalStiffness operator *(RotationalStiffnessPerLength rotationalStiffness, Length length)
+        /// <summary>Get <see cref="RotationalStiffness{T}"/> from <see cref="RotationalStiffnessPerLength{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static RotationalStiffness<T> operator *(RotationalStiffnessPerLength<T> rotationalStiffness, Length<T> length )
         {
-            return RotationalStiffness.FromNewtonMetersPerRadian(rotationalStiffness.NewtonMetersPerRadianPerMeter * length.Meters);
+            return RotationalStiffness<T>.FromNewtonMetersPerRadian(rotationalStiffness.NewtonMetersPerRadianPerMeter * length.Meters);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/SpecificEnergy.extra.cs b/UnitsNet/CustomCode/Quantities/SpecificEnergy.extra.cs
index 45f4473f80..be370c6f37 100644
--- a/UnitsNet/CustomCode/Quantities/SpecificEnergy.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/SpecificEnergy.extra.cs
@@ -3,36 +3,36 @@
 
 namespace UnitsNet
 {
-    public partial struct SpecificEnergy
+    public partial struct SpecificEnergy<T>
     {
-        /// <summary>Get <see cref="Energy"/> from <see cref="SpecificEnergy"/> times <see cref="Mass"/>.</summary>
-        public static Energy operator *(SpecificEnergy specificEnergy, Mass mass)
+        /// <summary>Get <see cref="Energy{T}"/> from <see cref="SpecificEnergy{T}"/> times <see cref="Mass{T}"/>.</summary>
+        public static Energy<T> operator *(SpecificEnergy<T> specificEnergy, Mass<T> mass )
         {
-            return Energy.FromJoules(specificEnergy.JoulesPerKilogram * mass.Kilograms);
+            return Energy<T>.FromJoules(specificEnergy.JoulesPerKilogram * mass.Kilograms);
         }
 
-        /// <summary>Get <see cref="Energy"/> from <see cref="Mass"/> times <see cref="SpecificEnergy"/>.</summary>
-        public static Energy operator *(Mass mass, SpecificEnergy specificEnergy)
+        /// <summary>Get <see cref="Energy{T}"/> from <see cref="Mass{T}"/> times <see cref="SpecificEnergy{T}"/>.</summary>
+        public static Energy<T> operator *(Mass<T> mass, SpecificEnergy<T> specificEnergy )
         {
-            return Energy.FromJoules(specificEnergy.JoulesPerKilogram * mass.Kilograms);
+            return Energy<T>.FromJoules(specificEnergy.JoulesPerKilogram * mass.Kilograms);
         }
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from <see cref="double"/> divided by <see cref="SpecificEnergy"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator /(double value, SpecificEnergy specificEnergy)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption{T}"/> from <see cref="double"/> divided by <see cref="SpecificEnergy{T}"/>.</summary>
+        public static BrakeSpecificFuelConsumption<T> operator /(double value, SpecificEnergy<T> specificEnergy )
         {
-            return BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value / specificEnergy.JoulesPerKilogram);
+            return BrakeSpecificFuelConsumption<T>.FromKilogramsPerJoule(value / specificEnergy.JoulesPerKilogram);
         }
 
-        /// <summary>Get <see cref="double"/> from <see cref="SpecificEnergy"/> times <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static double operator *(SpecificEnergy specificEnergy, BrakeSpecificFuelConsumption bsfc)
+        /// <summary>Get <see cref="double"/> from <see cref="SpecificEnergy{T}"/> times <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static double operator *(SpecificEnergy<T> specificEnergy, BrakeSpecificFuelConsumption<T> bsfc )
         {
             return specificEnergy.JoulesPerKilogram * bsfc.KilogramsPerJoule;
         }
 
-        /// <summary>Get <see cref="Power"/> from <see cref="SpecificEnergy"/> times <see cref="MassFlow"/>.</summary>
-        public static Power operator *(SpecificEnergy specificEnergy, MassFlow massFlow)
+        /// <summary>Get <see cref="Power{T}"/> from <see cref="SpecificEnergy{T}"/> times <see cref="MassFlow{T}"/>.</summary>
+        public static Power<T> operator *(SpecificEnergy<T> specificEnergy, MassFlow<T> massFlow )
         {
-            return Power.FromWatts(massFlow.KilogramsPerSecond * specificEnergy.JoulesPerKilogram);
+            return Power<T>.FromWatts(massFlow.KilogramsPerSecond * specificEnergy.JoulesPerKilogram);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/SpecificVolume.extra.cs b/UnitsNet/CustomCode/Quantities/SpecificVolume.extra.cs
index f284f8bb28..3bd2be1ddb 100644
--- a/UnitsNet/CustomCode/Quantities/SpecificVolume.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/SpecificVolume.extra.cs
@@ -3,18 +3,18 @@
 
 namespace UnitsNet
 {
-    public partial struct SpecificVolume
+    public partial struct SpecificVolume<T>
     {
-        /// <summary>Get <see cref="Density"/> from <see cref="double"/> divided by <see cref="SpecificVolume"/>.</summary>
-        public static Density operator /(double constant, SpecificVolume volume)
+        /// <summary>Get <see cref="Density{T}"/> from <see cref="double"/> divided by <see cref="SpecificVolume{T}"/>.</summary>
+        public static Density<T> operator /(double constant, SpecificVolume<T> volume )
         {
-            return Density.FromKilogramsPerCubicMeter(constant / volume.CubicMetersPerKilogram);
+            return Density<T>.FromKilogramsPerCubicMeter(constant / volume.CubicMetersPerKilogram);
         }
 
-        /// <summary>Get <see cref="Volume"/> from <see cref="SpecificVolume"/> times <see cref="Mass"/>.</summary>
-        public static Volume operator *(SpecificVolume volume, Mass mass)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="SpecificVolume{T}"/> times <see cref="Mass{T}"/>.</summary>
+        public static Volume<T> operator *(SpecificVolume<T> volume, Mass<T> mass )
         {
-            return Volume.FromCubicMeters(volume.CubicMetersPerKilogram * mass.Kilograms);
+            return Volume<T>.FromCubicMeters(volume.CubicMetersPerKilogram * mass.Kilograms);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/SpecificWeight.extra.cs b/UnitsNet/CustomCode/Quantities/SpecificWeight.extra.cs
index 85f4f8bae1..4f9a999533 100644
--- a/UnitsNet/CustomCode/Quantities/SpecificWeight.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/SpecificWeight.extra.cs
@@ -5,36 +5,36 @@
 
 namespace UnitsNet
 {
-    public partial struct SpecificWeight
+    public partial struct SpecificWeight<T>
     {
-        /// <summary>Get <see cref="Pressure"/> from <see cref="SpecificWeight"/> times <see cref="Length"/>.</summary>
-        public static Pressure operator *(SpecificWeight specificWeight, Length length)
+        /// <summary>Get <see cref="Pressure{T}"/> from <see cref="SpecificWeight{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static Pressure<T> operator *(SpecificWeight<T> specificWeight, Length<T> length )
         {
-            return new Pressure(specificWeight.NewtonsPerCubicMeter * length.Meters, UnitsNet.Units.PressureUnit.Pascal);
+            return new Pressure<T>( specificWeight.NewtonsPerCubicMeter * length.Meters, UnitsNet.Units.PressureUnit.Pascal);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from <see cref="SpecificWeight"/> times <see cref="Area"/>.</summary>
-        public static ForcePerLength operator *(SpecificWeight specificWeight, Area area)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from <see cref="SpecificWeight{T}"/> times <see cref="Area{T}"/>.</summary>
+        public static ForcePerLength<T> operator *(SpecificWeight<T> specificWeight, Area<T> area )
         {
-            return new ForcePerLength(specificWeight.NewtonsPerCubicMeter * area.SquareMeters, ForcePerLengthUnit.NewtonPerMeter);
+            return new ForcePerLength<T>( specificWeight.NewtonsPerCubicMeter * area.SquareMeters, ForcePerLengthUnit.NewtonPerMeter);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from <see cref="Area"/> times <see cref="SpecificWeight"/>.</summary>
-        public static ForcePerLength operator *(Area area, SpecificWeight specificWeight)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from <see cref="Area{T}"/> times <see cref="SpecificWeight{T}"/>.</summary>
+        public static ForcePerLength<T> operator *(Area<T> area, SpecificWeight<T> specificWeight )
         {
-            return new ForcePerLength(area.SquareMeters * specificWeight.NewtonsPerCubicMeter, ForcePerLengthUnit.NewtonPerMeter);
+            return new ForcePerLength<T>( area.SquareMeters * specificWeight.NewtonsPerCubicMeter, ForcePerLengthUnit.NewtonPerMeter);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from <see cref="SpecificWeight"/> divided by <see cref="Density"/>.</summary>
-        public static Acceleration operator /(SpecificWeight specificWeight, Density density)
+        /// <summary>Get <see cref="Acceleration{T}"/> from <see cref="SpecificWeight{T}"/> divided by <see cref="Density{T}"/>.</summary>
+        public static Acceleration<T> operator /(SpecificWeight<T> specificWeight, Density<T> density )
         {
-            return new Acceleration(specificWeight.NewtonsPerCubicMeter / density.KilogramsPerCubicMeter, UnitsNet.Units.AccelerationUnit.MeterPerSecondSquared);
+            return new Acceleration<T>( specificWeight.NewtonsPerCubicMeter / density.KilogramsPerCubicMeter, UnitsNet.Units.AccelerationUnit.MeterPerSecondSquared);
         }
 
-        /// <summary>Get <see cref="Density"/> from <see cref="SpecificWeight"/> divided by <see cref="Acceleration"/>.</summary>
-        public static Density operator /(SpecificWeight specific, Acceleration acceleration)
+        /// <summary>Get <see cref="Density{T}"/> from <see cref="SpecificWeight{T}"/> divided by <see cref="Acceleration{T}"/>.</summary>
+        public static Density<T> operator /(SpecificWeight<T> specific, Acceleration<T> acceleration )
         {
-            return new Density(specific.NewtonsPerCubicMeter / acceleration.MetersPerSecondSquared, UnitsNet.Units.DensityUnit.KilogramPerCubicMeter);
+            return new Density<T>( specific.NewtonsPerCubicMeter / acceleration.MetersPerSecondSquared, UnitsNet.Units.DensityUnit.KilogramPerCubicMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/Speed.extra.cs b/UnitsNet/CustomCode/Quantities/Speed.extra.cs
index 549fff0bea..6c147eab35 100644
--- a/UnitsNet/CustomCode/Quantities/Speed.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Speed.extra.cs
@@ -5,66 +5,66 @@
 
 namespace UnitsNet
 {
-    public partial struct Speed
+    public partial struct Speed<T>
     {
-        /// <summary>Get <see cref="Acceleration"/> from <see cref="Speed"/> divided by <see cref="TimeSpan"/>.</summary>
-        public static Acceleration operator /(Speed speed, TimeSpan timeSpan)
+        /// <summary>Get <see cref="Acceleration{T}"/> from <see cref="Speed{T}"/> divided by <see cref="TimeSpan"/>.</summary>
+        public static Acceleration<T> operator /(Speed<T> speed, TimeSpan timeSpan )
         {
-            return Acceleration.FromMetersPerSecondSquared(speed.MetersPerSecond / timeSpan.TotalSeconds);
+            return Acceleration<T>.FromMetersPerSecondSquared(speed.MetersPerSecond / timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Speed"/> times <see cref="TimeSpan"/>.</summary>
-        public static Length operator *(Speed speed, TimeSpan timeSpan)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Speed{T}"/> times <see cref="TimeSpan"/>.</summary>
+        public static Length<T> operator *(Speed<T> speed, TimeSpan timeSpan)
         {
-            return Length.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
+            return Length<T>.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="TimeSpan"/> times <see cref="Speed"/>.</summary>
-        public static Length operator *(TimeSpan timeSpan, Speed speed)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="TimeSpan"/> times <see cref="Speed{T}"/>.</summary>
+        public static Length<T> operator *(TimeSpan timeSpan, Speed<T> speed )
         {
-            return Length.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
+            return Length<T>.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from <see cref="Speed"/> divided by <see cref="Duration"/>.</summary>
-        public static Acceleration operator /(Speed speed, Duration duration)
+        /// <summary>Get <see cref="Acceleration{T}"/> from <see cref="Speed{T}"/> divided by <see cref="Duration{T}"/>.</summary>
+        public static Acceleration<T> operator /(Speed<T> speed, Duration<T> duration )
         {
-            return Acceleration.FromMetersPerSecondSquared(speed.MetersPerSecond / duration.Seconds);
+            return Acceleration<T>.FromMetersPerSecondSquared(speed.MetersPerSecond / duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Speed"/> times <see cref="Duration"/>.</summary>
-        public static Length operator *(Speed speed, Duration duration)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Speed{T}"/> times <see cref="Duration{T}"/>.</summary>
+        public static Length<T> operator *(Speed<T> speed, Duration<T> duration )
         {
-            return Length.FromMeters(speed.MetersPerSecond * duration.Seconds);
+            return Length<T>.FromMeters(speed.MetersPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Duration"/> times <see cref="Speed"/>.</summary>
-        public static Length operator *(Duration duration, Speed speed)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Duration{T}"/> times <see cref="Speed{T}"/>.</summary>
+        public static Length<T> operator *(Duration<T> duration, Speed<T> speed )
         {
-            return Length.FromMeters(speed.MetersPerSecond * duration.Seconds);
+            return Length<T>.FromMeters(speed.MetersPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="KinematicViscosity"/> from <see cref="Speed"/> times <see cref="Length"/>.</summary>
-        public static KinematicViscosity operator *(Speed speed, Length length)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from <see cref="Speed{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static KinematicViscosity<T> operator *(Speed<T> speed, Length<T> length )
         {
-            return KinematicViscosity.FromSquareMetersPerSecond(length.Meters * speed.MetersPerSecond);
+            return KinematicViscosity<T>.FromSquareMetersPerSecond(length.Meters * speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from <see cref="Speed"/> times <see cref="Speed"/>.</summary>
-        public static SpecificEnergy operator *(Speed left, Speed right)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from <see cref="Speed{T}"/> times <see cref="Speed{T}"/>.</summary>
+        public static SpecificEnergy<T> operator *(Speed<T> left, Speed<T> right )
         {
-            return SpecificEnergy.FromJoulesPerKilogram(left.MetersPerSecond * right.MetersPerSecond);
+            return SpecificEnergy<T>.FromJoulesPerKilogram(left.MetersPerSecond * right.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> from <see cref="Speed"/> times <see cref="Density"/>.</summary>
-        public static MassFlux operator *(Speed speed, Density density)
+        /// <summary>Get <see cref="MassFlux{T}"/> from <see cref="Speed{T}"/> times <see cref="Density{T}"/>.</summary>
+        public static MassFlux<T> operator *(Speed<T> speed, Density<T> density )
         {
-            return MassFlux.FromKilogramsPerSecondPerSquareMeter(speed.MetersPerSecond * density.KilogramsPerCubicMeter);
+            return MassFlux<T>.FromKilogramsPerSecondPerSquareMeter(speed.MetersPerSecond * density.KilogramsPerCubicMeter);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="Speed"/> times <see cref="Area"/>.</summary>
-        public static VolumeFlow operator *(Speed speed, Area area)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from <see cref="Speed{T}"/> times <see cref="Area{T}"/>.</summary>
+        public static VolumeFlow<T> operator *(Speed<T> speed, Area<T> area )
         {
-            return VolumeFlow.FromCubicMetersPerSecond(speed.MetersPerSecond * area.SquareMeters);
+            return VolumeFlow<T>.FromCubicMetersPerSecond(speed.MetersPerSecond * area.SquareMeters);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/Temperature.extra.cs b/UnitsNet/CustomCode/Quantities/Temperature.extra.cs
index cfce09a948..cdbe809944 100644
--- a/UnitsNet/CustomCode/Quantities/Temperature.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Temperature.extra.cs
@@ -5,46 +5,46 @@
 
 namespace UnitsNet
 {
-    public partial struct Temperature
+    public partial struct Temperature<T>
     {
         /// <summary>
-        ///     Add a <see cref="Temperature" /> and a <see cref="TemperatureDelta" />.
+        ///     Add a <see cref="Temperature{T}" /> and a <see cref="TemperatureDelta{T}" />.
         /// </summary>
         /// <remarks>Due to temperature units having different scales, the arithmetic must be performed on the same scale.</remarks>
         /// <returns>The new temperature.</returns>
-        public static Temperature operator +(Temperature left, TemperatureDelta right)
+        public static Temperature<T> operator +(Temperature<T> left, TemperatureDelta<T> right )
         {
-            return new Temperature(left.Kelvins + right.Kelvins, TemperatureUnit.Kelvin);
+            return new Temperature<T>( left.Kelvins + right.Kelvins, TemperatureUnit.Kelvin);
         }
 
         /// <summary>
-        ///     Add a <see cref="TemperatureDelta" /> and a <see cref="Temperature" />.
+        ///     Add a <see cref="TemperatureDelta{T}" /> and a <see cref="Temperature{T}" />.
         /// </summary>
         /// <remarks>Due to temperature units having different scales, the arithmetic must be performed on the same scale.</remarks>
         /// <returns>The new temperature.</returns>
-        public static Temperature operator +(TemperatureDelta left, Temperature right)
+        public static Temperature<T> operator +(TemperatureDelta<T> left, Temperature<T> right )
         {
-            return new Temperature(left.Kelvins + right.Kelvins, TemperatureUnit.Kelvin);
+            return new Temperature<T>( left.Kelvins + right.Kelvins, TemperatureUnit.Kelvin);
         }
 
         /// <summary>
-        ///     Subtract a <see cref="Temperature" /> by a <see cref="TemperatureDelta" />.
+        ///     Subtract a <see cref="Temperature{T}" /> by a <see cref="TemperatureDelta{T}" />.
         /// </summary>
         /// <remarks>Due to temperature units having different scales, the arithmetic must be performed on the same scale.</remarks>
         /// <returns>The new temperature.</returns>
-        public static Temperature operator -(Temperature left, TemperatureDelta right)
+        public static Temperature<T> operator -(Temperature<T> left, TemperatureDelta<T> right )
         {
-            return new Temperature(left.Kelvins - right.Kelvins, TemperatureUnit.Kelvin);
+            return new Temperature<T>( left.Kelvins - right.Kelvins, TemperatureUnit.Kelvin);
         }
 
         /// <summary>
-        ///     Subtract a <see cref="Temperature" /> by a <see cref="TemperatureDelta" />.
+        ///     Subtract a <see cref="Temperature{T}" /> by a <see cref="TemperatureDelta{T}" />.
         /// </summary>
         /// <remarks>Due to temperature units having different scales, the arithmetic must be performed on the same scale.</remarks>
         /// <returns>The delta temperature (difference).</returns>
-        public static TemperatureDelta operator -(Temperature left, Temperature right)
+        public static TemperatureDelta<T> operator -(Temperature<T> left, Temperature<T> right )
         {
-            return new TemperatureDelta(left.Kelvins - right.Kelvins, TemperatureDeltaUnit.Kelvin);
+            return new TemperatureDelta<T>( left.Kelvins - right.Kelvins, TemperatureDeltaUnit.Kelvin);
         }
 
         /// <summary>
@@ -57,8 +57,8 @@ public partial struct Temperature
         /// </remarks>
         /// <param name="factor">Factor to multiply by.</param>
         /// <param name="unit">Unit to perform multiplication in.</param>
-        /// <returns>The resulting <see cref="Temperature" />.</returns>
-        public Temperature Multiply(double factor, TemperatureUnit unit)
+        /// <returns>The resulting <see cref="Temperature{T}" />.</returns>
+        public Temperature<T> Multiply(double factor, TemperatureUnit unit)
         {
             double resultInUnit = As(unit) * factor;
             return From(resultInUnit, unit);
@@ -75,8 +75,8 @@ public Temperature Multiply(double factor, TemperatureUnit unit)
         /// </remarks>
         /// <param name="divisor">Factor to multiply by.</param>
         /// <param name="unit">Unit to perform multiplication in.</param>
-        /// <returns>The resulting <see cref="Temperature" />.</returns>
-        public Temperature Divide(double divisor, TemperatureUnit unit)
+        /// <returns>The resulting <see cref="Temperature{T}" />.</returns>
+        public Temperature<T> Divide(double divisor, TemperatureUnit unit)
         {
             double resultInUnit = As(unit) / divisor;
             return From(resultInUnit, unit);
diff --git a/UnitsNet/CustomCode/Quantities/TemperatureDelta.extra.cs b/UnitsNet/CustomCode/Quantities/TemperatureDelta.extra.cs
index b3b3878cbb..d0bc1ecf97 100644
--- a/UnitsNet/CustomCode/Quantities/TemperatureDelta.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/TemperatureDelta.extra.cs
@@ -3,22 +3,22 @@
 
 namespace UnitsNet
 {
-    public partial struct TemperatureDelta
+    public partial struct TemperatureDelta<T>
     {
-        /// <summary>Get <see cref="LapseRate"/> from <see cref="TemperatureDelta"/> divided by <see cref="Length"/>.</summary>
-        public static LapseRate operator /(TemperatureDelta left, Length right)
+        /// <summary>Get <see cref="LapseRate{T}"/> from <see cref="TemperatureDelta{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static LapseRate<T> operator /(TemperatureDelta<T> left, Length<T> right )
         {
-            return LapseRate.FromDegreesCelciusPerKilometer(left.DegreesCelsius / right.Kilometers);
+            return LapseRate<T>.FromDegreesCelciusPerKilometer(left.DegreesCelsius / right.Kilometers);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from <see cref="SpecificEntropy"/> times <see cref="TemperatureDelta"/>.</summary>
-        public static SpecificEnergy operator *(SpecificEntropy specificEntropy, TemperatureDelta temperatureDelta)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from <see cref="SpecificEntropy{T}"/> times <see cref="TemperatureDelta{T}"/>.</summary>
+        public static SpecificEnergy<T> operator *(SpecificEntropy<T> specificEntropy, TemperatureDelta<T> temperatureDelta )
         {
-            return SpecificEnergy.FromJoulesPerKilogram(specificEntropy.JoulesPerKilogramKelvin * temperatureDelta.Kelvins);
+            return SpecificEnergy<T>.FromJoulesPerKilogram(specificEntropy.JoulesPerKilogramKelvin * temperatureDelta.Kelvins);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from <see cref="TemperatureDelta"/> times <see cref="SpecificEntropy"/>.</summary>
-        public static SpecificEnergy operator *(TemperatureDelta temperatureDelta, SpecificEntropy specificEntropy)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from <see cref="TemperatureDelta{T}"/> times <see cref="SpecificEntropy{T}"/>.</summary>
+        public static SpecificEnergy<T> operator *(TemperatureDelta<T> temperatureDelta, SpecificEntropy<T> specificEntropy )
         {
             return specificEntropy * temperatureDelta;
         }
diff --git a/UnitsNet/CustomCode/Quantities/Torque.extra.cs b/UnitsNet/CustomCode/Quantities/Torque.extra.cs
index 26bd4f551b..55e68598f5 100644
--- a/UnitsNet/CustomCode/Quantities/Torque.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Torque.extra.cs
@@ -3,30 +3,30 @@
 
 namespace UnitsNet
 {
-    public partial struct Torque
+    public partial struct Torque<T>
     {
-        /// <summary>Get <see cref="Force"/> from <see cref="Torque"/> times <see cref="Length"/>.</summary>
-        public static Force operator /(Torque torque, Length length)
+        /// <summary>Get <see cref="Force{T}"/> from <see cref="Torque{T}"/> times <see cref="Length{T}"/>.</summary>
+        public static Force<T> operator /(Torque<T> torque, Length<T> length )
         {
-            return Force.FromNewtons(torque.NewtonMeters / length.Meters);
+            return Force<T>.FromNewtons(torque.NewtonMeters / length.Meters);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Torque"/> times <see cref="Force"/>.</summary>
-        public static Length operator /(Torque torque, Force force)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Torque{T}"/> times <see cref="Force{T}"/>.</summary>
+        public static Length<T> operator /(Torque<T> torque, Force<T> force )
         {
-            return Length.FromMeters(torque.NewtonMeters / force.Newtons);
+            return Length<T>.FromMeters(torque.NewtonMeters / force.Newtons);
         }
 
-        /// <summary>Get <see cref="RotationalStiffness"/> from <see cref="Torque"/> times <see cref="Angle"/>.</summary>
-        public static RotationalStiffness operator /(Torque torque, Angle angle)
+        /// <summary>Get <see cref="RotationalStiffness{T}"/> from <see cref="Torque{T}"/> times <see cref="Angle{T}"/>.</summary>
+        public static RotationalStiffness<T> operator /(Torque<T> torque, Angle<T> angle )
         {
-            return RotationalStiffness.FromNewtonMetersPerRadian(torque.NewtonMeters / angle.Radians);
+            return RotationalStiffness<T>.FromNewtonMetersPerRadian(torque.NewtonMeters / angle.Radians);
         }
 
-        /// <summary>Get <see cref="Angle"/> from <see cref="Torque"/> times <see cref="RotationalStiffness"/>.</summary>
-        public static Angle operator /(Torque torque, RotationalStiffness rotationalStiffness)
+        /// <summary>Get <see cref="Angle{T}"/> from <see cref="Torque{T}"/> times <see cref="RotationalStiffness{T}"/>.</summary>
+        public static Angle<T> operator /(Torque<T> torque, RotationalStiffness<T> rotationalStiffness )
         {
-            return Angle.FromRadians(torque.NewtonMeters / rotationalStiffness.NewtonMetersPerRadian);
+            return Angle<T>.FromRadians(torque.NewtonMeters / rotationalStiffness.NewtonMetersPerRadian);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/Volume.extra.cs b/UnitsNet/CustomCode/Quantities/Volume.extra.cs
index aab43915a4..8d3cf8e8fd 100644
--- a/UnitsNet/CustomCode/Quantities/Volume.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Volume.extra.cs
@@ -5,34 +5,34 @@
 
 namespace UnitsNet
 {
-    public partial struct Volume
+    public partial struct Volume<T>
     {
-        /// <summary>Get <see cref="Area"/> from <see cref="Volume"/> divided by <see cref="Length"/>.</summary>
-        public static Area operator /(Volume volume, Length length)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="Volume{T}"/> divided by <see cref="Length{T}"/>.</summary>
+        public static Area<T> operator /(Volume<T> volume, Length<T> length )
         {
-            return Area.FromSquareMeters(volume.CubicMeters / length.Meters);
+            return Area<T>.FromSquareMeters(volume.CubicMeters / length.Meters);
         }
 
-        /// <summary>Get <see cref="Length"/> from <see cref="Volume"/> divided by <see cref="Area"/>.</summary>
-        public static Length operator /(Volume volume, Area area)
+        /// <summary>Get <see cref="Length{T}"/> from <see cref="Volume{T}"/> divided by <see cref="Area{T}"/>.</summary>
+        public static Length<T> operator /(Volume<T> volume, Area<T> area )
         {
-            return Length.FromMeters(volume.CubicMeters / area.SquareMeters);
+            return Length<T>.FromMeters(volume.CubicMeters / area.SquareMeters);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="Volume"/> divided by <see cref="Duration"/>.</summary>
-        public static VolumeFlow operator /(Volume volume, Duration duration)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from <see cref="Volume{T}"/> divided by <see cref="Duration{T}"/>.</summary>
+        public static VolumeFlow<T> operator /(Volume<T> volume, Duration<T> duration )
         {
-            return VolumeFlow.FromCubicMetersPerSecond(volume.CubicMeters / duration.Seconds);
+            return VolumeFlow<T>.FromCubicMetersPerSecond(volume.CubicMeters / duration.Seconds);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="Volume"/> divided by <see cref="TimeSpan"/>.</summary>
-        public static VolumeFlow operator /(Volume volume, TimeSpan timeSpan)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from <see cref="Volume{T}"/> divided by <see cref="TimeSpan"/>.</summary>
+        public static VolumeFlow<T> operator /(Volume<T> volume, TimeSpan timeSpan)
         {
-            return VolumeFlow.FromCubicMetersPerSecond(volume.CubicMeters / timeSpan.TotalSeconds);
+            return VolumeFlow<T>.FromCubicMetersPerSecond(volume.CubicMeters / timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="TimeSpan"/> from <see cref="Volume"/> divided by <see cref="VolumeFlow"/>.</summary>
-        public static TimeSpan operator /(Volume volume, VolumeFlow volumeFlow)
+        /// <summary>Get <see cref="TimeSpan"/> from <see cref="Volume{T}"/> divided by <see cref="VolumeFlow{T}"/>.</summary>
+        public static TimeSpan operator /(Volume<T> volume, VolumeFlow<T> volumeFlow )
         {
             return TimeSpan.FromSeconds(volume.CubicMeters / volumeFlow.CubicMetersPerSecond);
         }
diff --git a/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs b/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs
index e90942cfd1..8dce4d284f 100644
--- a/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs
@@ -2,25 +2,25 @@
 
 namespace UnitsNet
 {
-    public partial struct VolumeConcentration
+    public partial struct VolumeConcentration<T>
     {
         /// <summary>
-        /// Get <see cref="MassConcentration" /> from this <see cref="VolumeConcentration" /> and component <see cref="Density" /> .
+        /// Get <see cref="MassConcentration{T}" /> from this <see cref="VolumeConcentration{T}" /> and component <see cref="Density{T}" /> .
         /// </summary>
         /// <param name="componentDensity"></param>
         /// <returns></returns>
-        public MassConcentration ToMassConcentration(Density componentDensity)
+        public MassConcentration<T> ToMassConcentration(Density<T> componentDensity )
         {
             return this * componentDensity;
         }
 
         /// <summary>
-        /// Get <see cref="Molarity" /> from this <see cref="VolumeConcentration" /> and component <see cref="Density"/> and <see cref="MolarMass"/> .
+        /// Get <see cref="Molarity{T}" /> from this <see cref="VolumeConcentration{T}" /> and component <see cref="Density{T}"/> and <see cref="MolarMass{T}"/> .
         /// </summary>
         /// <param name="componentDensity"></param>
         /// <param name="compontMolarMass"></param>
         /// <returns></returns>
-        public Molarity ToMolarity(Density componentDensity, MolarMass compontMolarMass)
+        public Molarity<T> ToMolarity(Density<T> componentDensity, MolarMass<T> compontMolarMass )
         {
             return this * componentDensity / compontMolarMass;
         }
@@ -28,20 +28,20 @@ public Molarity ToMolarity(Density componentDensity, MolarMass compontMolarMass)
         #region Static Methods
 
         /// <summary>
-        ///     Get <see cref="VolumeConcentration" /> from a component <see cref="Volume" /> and total mixture <see cref="Volume" /> .
+        ///     Get <see cref="VolumeConcentration{T}" /> from a component <see cref="Volume{T}" /> and total mixture <see cref="Volume{T}" /> .
         /// </summary>
-        public static VolumeConcentration FromVolumes(Volume componentVolume, Volume mixtureMass)
+        public static VolumeConcentration<T> FromVolumes(Volume<T> componentVolume, Volume<T> mixtureMass )
         {
-            return new VolumeConcentration(componentVolume / mixtureMass, VolumeConcentrationUnit.DecimalFraction);
+            return new VolumeConcentration<T>( componentVolume / mixtureMass, VolumeConcentrationUnit.DecimalFraction);
         }
 
         /// <summary>
-        ///     Get a <see cref="VolumeConcentration"/> from <see cref="Molarity" /> and a component <see cref="Density" /> and <see cref="MolarMass" />.
+        ///     Get a <see cref="VolumeConcentration{T}"/> from <see cref="Molarity{T}" /> and a component <see cref="Density{T}" /> and <see cref="MolarMass{T}" />.
         /// </summary>
         /// <param name="molarity"></param>
         /// <param name="componentDensity"></param>
         /// <param name="componentMolarMass"></param>
-        public static VolumeConcentration FromMolarity(Molarity molarity, Density componentDensity, MolarMass componentMolarMass)
+        public static VolumeConcentration<T> FromMolarity(Molarity<T> molarity, Density<T> componentDensity, MolarMass<T> componentMolarMass )
         {
             return molarity * componentMolarMass / componentDensity;
         }
@@ -51,16 +51,16 @@ public static VolumeConcentration FromMolarity(Molarity molarity, Density compon
 
         #region Operators
 
-        /// <summary>Get <see cref="MassConcentration" /> from <see cref="VolumeConcentration" /> times the component <see cref="Density" />.</summary>
-        public static MassConcentration operator *(VolumeConcentration volumeConcentration, Density componentDensity)
+        /// <summary>Get <see cref="MassConcentration{T}" /> from <see cref="VolumeConcentration{T}" /> times the component <see cref="Density{T}" />.</summary>
+        public static MassConcentration<T> operator *(VolumeConcentration<T> volumeConcentration, Density<T> componentDensity )
         {
-            return MassConcentration.FromKilogramsPerCubicMeter(volumeConcentration.DecimalFractions * componentDensity.KilogramsPerCubicMeter);
+            return MassConcentration<T>.FromKilogramsPerCubicMeter(volumeConcentration.DecimalFractions * componentDensity.KilogramsPerCubicMeter);
         }
         
-        /// <summary>Get <see cref="MassConcentration" /> from <see cref="VolumeConcentration" /> times the component <see cref="Density" />.</summary>
-        public static MassConcentration operator *(Density componentDensity, VolumeConcentration volumeConcentration)
+        /// <summary>Get <see cref="MassConcentration{T}" /> from <see cref="VolumeConcentration{T}" /> times the component <see cref="Density{T}" />.</summary>
+        public static MassConcentration<T> operator *(Density<T> componentDensity, VolumeConcentration<T> volumeConcentration )
         {
-            return MassConcentration.FromKilogramsPerCubicMeter(volumeConcentration.DecimalFractions * componentDensity.KilogramsPerCubicMeter);
+            return MassConcentration<T>.FromKilogramsPerCubicMeter(volumeConcentration.DecimalFractions * componentDensity.KilogramsPerCubicMeter);
         }
         
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/VolumeFlow.extra.cs b/UnitsNet/CustomCode/Quantities/VolumeFlow.extra.cs
index 51e71e8180..4c5d12f078 100644
--- a/UnitsNet/CustomCode/Quantities/VolumeFlow.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/VolumeFlow.extra.cs
@@ -5,42 +5,42 @@
 
 namespace UnitsNet
 {
-    public partial struct VolumeFlow
+    public partial struct VolumeFlow<T>
     {
-        /// <summary>Get <see cref="Volume"/> from <see cref="VolumeFlow"/> times <see cref="TimeSpan"/>.</summary>
-        public static Volume operator *(VolumeFlow volumeFlow, TimeSpan timeSpan)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="VolumeFlow{T}"/> times <see cref="TimeSpan"/>.</summary>
+        public static Volume<T> operator *(VolumeFlow<T> volumeFlow, TimeSpan timeSpan)
         {
-            return Volume.FromCubicMeters(volumeFlow.CubicMetersPerSecond * timeSpan.TotalSeconds);
+            return Volume<T>.FromCubicMeters(volumeFlow.CubicMetersPerSecond * timeSpan.TotalSeconds);
         }
 
-        /// <summary>Get <see cref="Volume"/> from <see cref="VolumeFlow"/> times <see cref="Duration"/>.</summary>
-        public static Volume operator *(VolumeFlow volumeFlow, Duration duration)
+        /// <summary>Get <see cref="Volume{T}"/> from <see cref="VolumeFlow{T}"/> times <see cref="Duration{T}"/>.</summary>
+        public static Volume<T> operator *(VolumeFlow<T> volumeFlow, Duration<T> duration )
         {
-            return Volume.FromCubicMeters(volumeFlow.CubicMetersPerSecond * duration.Seconds);
+            return Volume<T>.FromCubicMeters(volumeFlow.CubicMetersPerSecond * duration.Seconds);
         }
 
-        /// <summary>Get <see cref="Speed"/> from <see cref="VolumeFlow"/> divided by <see cref="Area"/>.</summary>
-        public static Speed operator /(VolumeFlow volumeFlow, Area area)
+        /// <summary>Get <see cref="Speed{T}"/> from <see cref="VolumeFlow{T}"/> divided by <see cref="Area{T}"/>.</summary>
+        public static Speed<T> operator /(VolumeFlow<T> volumeFlow, Area<T> area )
         {
-            return Speed.FromMetersPerSecond(volumeFlow.CubicMetersPerSecond / area.SquareMeters);
+            return Speed<T>.FromMetersPerSecond(volumeFlow.CubicMetersPerSecond / area.SquareMeters);
         }
 
-        /// <summary>Get <see cref="Area"/> from <see cref="VolumeFlow"/> divided by <see cref="Speed"/>.</summary>
-        public static Area operator /(VolumeFlow volumeFlow, Speed speed)
+        /// <summary>Get <see cref="Area{T}"/> from <see cref="VolumeFlow{T}"/> divided by <see cref="Speed{T}"/>.</summary>
+        public static Area<T> operator /(VolumeFlow<T> volumeFlow, Speed<T> speed )
         {
-            return Area.FromSquareMeters(volumeFlow.CubicMetersPerSecond / speed.MetersPerSecond);
+            return Area<T>.FromSquareMeters(volumeFlow.CubicMetersPerSecond / speed.MetersPerSecond);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="VolumeFlow"/> times <see cref="Density"/>.</summary>
-        public static MassFlow operator *(VolumeFlow volumeFlow, Density density)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="VolumeFlow{T}"/> times <see cref="Density{T}"/>.</summary>
+        public static MassFlow<T> operator *(VolumeFlow<T> volumeFlow, Density<T> density )
         {
-            return MassFlow.FromKilogramsPerSecond(volumeFlow.CubicMetersPerSecond * density.KilogramsPerCubicMeter);
+            return MassFlow<T>.FromKilogramsPerSecond(volumeFlow.CubicMetersPerSecond * density.KilogramsPerCubicMeter);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from <see cref="Density"/> times <see cref="VolumeFlow"/>.</summary>
-        public static MassFlow operator *(Density density, VolumeFlow volumeFlow)
+        /// <summary>Get <see cref="MassFlow{T}"/> from <see cref="Density{T}"/> times <see cref="VolumeFlow{T}"/>.</summary>
+        public static MassFlow<T> operator *(Density<T> density, VolumeFlow<T> volumeFlow )
         {
-            return MassFlow.FromKilogramsPerSecond(volumeFlow.CubicMetersPerSecond * density.KilogramsPerCubicMeter);
+            return MassFlow<T>.FromKilogramsPerSecond(volumeFlow.CubicMetersPerSecond * density.KilogramsPerCubicMeter);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantity.cs b/UnitsNet/CustomCode/Quantity.cs
index d0ee9e929c..a0479ea568 100644
--- a/UnitsNet/CustomCode/Quantity.cs
+++ b/UnitsNet/CustomCode/Quantity.cs
@@ -33,7 +33,7 @@ static Quantity()
         public static string[] Names { get; }
 
         /// <summary>
-        /// All quantity information objects, such as <see cref="Length.Info"/> and <see cref="Mass.Info"/>.
+        /// All quantity information objects, such as <see cref="Length{T}.Info"/> and <see cref="Mass{T}.Info"/>.
         /// </summary>
         public static QuantityInfo[] Infos => InfosLazy.Value;
 
@@ -44,9 +44,9 @@ static Quantity()
         /// <param name="unit">Unit enum value.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="ArgumentException">Unit value is not a know unit enum type.</exception>
-        public static IQuantity From(QuantityValue value, Enum unit)
+        public static IQuantity From<T>( QuantityValue value, Enum unit)
         {
-            if (TryFrom(value, unit, out IQuantity? quantity))
+            if (TryFrom<T>(value, unit, out IQuantity? quantity))
                 return quantity!;
 
             throw new ArgumentException(
@@ -54,7 +54,7 @@ public static IQuantity From(QuantityValue value, Enum unit)
         }
 
         /// <inheritdoc cref="TryFrom(QuantityValue,System.Enum,out UnitsNet.IQuantity)"/>
-        public static bool TryFrom(double value, Enum unit, out IQuantity? quantity)
+        public static bool TryFrom<T>(double value, Enum unit, out IQuantity? quantity)
         {
             // Implicit cast to QuantityValue would prevent TryFrom from being called,
             // so we need to explicitly check this here for double arguments.
@@ -64,34 +64,34 @@ public static bool TryFrom(double value, Enum unit, out IQuantity? quantity)
                 return false;
             }
 
-            return TryFrom((QuantityValue)value, unit, out quantity);
+            return TryFrom<T>((QuantityValue)value, unit, out quantity);
         }
 
         /// <inheritdoc cref="Parse(IFormatProvider, System.Type,string)"/>
-        public static IQuantity Parse(Type quantityType, string quantityString) => Parse(null, quantityType, quantityString);
+        public static IQuantity Parse<T>( Type quantityType, string quantityString) => Parse<T>( null, quantityType, quantityString);
 
         /// <summary>
         ///     Dynamically parse a quantity string representation.
         /// </summary>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        /// <param name="quantityType">Type of quantity, such as <see cref="Length"/>.</param>
+        /// <param name="quantityType">Type of quantity, such as <see cref="Length{T}"/>.</param>
         /// <param name="quantityString">Quantity string representation, such as "1.5 kg". Must be compatible with given quantity type.</param>
         /// <returns>The parsed quantity.</returns>
         /// <exception cref="ArgumentException">Type must be of type UnitsNet.IQuantity -or- Type is not a known quantity type.</exception>
-        public static IQuantity Parse(IFormatProvider? formatProvider, Type quantityType, string quantityString)
+        public static IQuantity Parse<T>(IFormatProvider? formatProvider, Type quantityType, string quantityString)
         {
             if (!typeof(IQuantity).Wrap().IsAssignableFrom(quantityType))
                 throw new ArgumentException($"Type {quantityType} must be of type UnitsNet.IQuantity.");
 
-            if (TryParse(formatProvider, quantityType, quantityString, out IQuantity? quantity))
+            if (TryParse<T>(formatProvider, quantityType, quantityString, out IQuantity? quantity))
                 return quantity!;
 
             throw new ArgumentException($"Quantity string could not be parsed to quantity {quantityType}.");
         }
 
         /// <inheritdoc cref="TryParse(IFormatProvider,System.Type,string,out UnitsNet.IQuantity)"/>
-        public static bool TryParse(Type quantityType, string quantityString, out IQuantity? quantity) =>
-            TryParse(null, quantityType, quantityString, out quantity);
+        public static bool TryParse<T>(Type quantityType, string quantityString, out IQuantity? quantity) =>
+            TryParse<T>(null, quantityType, quantityString, out quantity);
 
         /// <summary>
         ///     Get information about the given quantity type.
diff --git a/UnitsNet/CustomCode/QuantityParser.cs b/UnitsNet/CustomCode/QuantityParser.cs
index a0054f5779..3e42a097ee 100644
--- a/UnitsNet/CustomCode/QuantityParser.cs
+++ b/UnitsNet/CustomCode/QuantityParser.cs
@@ -13,6 +13,10 @@
 namespace UnitsNet
 {
 
+    internal delegate TQuantity QuantityFromDelegate<in TValue, out TQuantity, in TUnitType>(TValue value, TUnitType fromUnit)
+        where TValue : struct
+        where TQuantity : IQuantity
+        where TUnitType : Enum;
     internal delegate TQuantity QuantityFromDelegate<out TQuantity, in TUnitType>(QuantityValue value, TUnitType fromUnit)
         where TQuantity : IQuantity
         where TUnitType : Enum;
@@ -41,9 +45,10 @@ static QuantityParser()
         }
 
         [SuppressMessage("ReSharper", "UseStringInterpolation")]
-        internal TQuantity Parse<TQuantity, TUnitType>([NotNull] string str,
+        internal TQuantity Parse<TValue, TQuantity, TUnitType>([NotNull] string str,
             IFormatProvider? formatProvider,
-            [NotNull] QuantityFromDelegate<TQuantity, TUnitType> fromDelegate)
+            [NotNull] QuantityFromDelegate<TValue, TQuantity, TUnitType> fromDelegate)
+            where TValue : struct
             where TQuantity : IQuantity
             where TUnitType : Enum
         {
@@ -70,10 +75,11 @@ internal TQuantity Parse<TQuantity, TUnitType>([NotNull] string str,
         }
 
         [SuppressMessage("ReSharper", "UseStringInterpolation")]
-        internal bool TryParse<TQuantity, TUnitType>(string? str,
+        internal bool TryParse<TValue, TQuantity, TUnitType>(string? str,
             IFormatProvider? formatProvider,
-            [NotNull] QuantityFromDelegate<TQuantity, TUnitType> fromDelegate,
+            [NotNull] QuantityFromDelegate<TValue, TQuantity, TUnitType> fromDelegate,
             out TQuantity result)
+            where TValue : struct
             where TQuantity : struct, IQuantity
             where TUnitType : struct, Enum
         {
@@ -101,10 +107,11 @@ internal bool TryParse<TQuantity, TUnitType>(string? str,
         ///     Workaround for C# not allowing to pass on 'out' param from type Length to IQuantity, even though the are compatible.
         /// </summary>
         [SuppressMessage("ReSharper", "UseStringInterpolation")]
-        internal bool TryParse<TQuantity, TUnitType>([NotNull] string str,
+        internal bool TryParse<TValue, TQuantity, TUnitType>([NotNull] string str,
             IFormatProvider? formatProvider,
-            [NotNull] QuantityFromDelegate<TQuantity, TUnitType> fromDelegate,
+            [NotNull] QuantityFromDelegate<TValue, TQuantity, TUnitType> fromDelegate,
             out IQuantity? result)
+            where TValue : struct
             where TQuantity : struct, IQuantity
             where TUnitType : struct, Enum
         {
diff --git a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
index a0b52ff101..353351bc34 100644
--- a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
+++ b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
@@ -27,7 +27,7 @@ public sealed partial class UnitAbbreviationsCache
         ///     if no abbreviations are found with a given culture.
         /// </summary>
         /// <example>
-        ///     User wants to call <see cref="UnitParser.Parse{TUnitType}" /> or <see cref="Length.ToString()" /> with Russian
+        ///     User wants to call <see cref="UnitParser.Parse{TUnitType}" /> or <see cref="Length{T}.ToString()" /> with Russian
         ///     culture, but no translation is defined, so we return the US English definition as a last resort. If it's not
         ///     defined there either, an exception is thrown.
         /// </example>
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index f40bd32c21..d261ed5fb6 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Acceleration, in physics, is the rate at which the velocity of an object changes over time. An object's acceleration is the net result of any and all forces acting on the object, as described by Newton's Second Law. The SI unit for acceleration is the Meter per second squared (m/s²). Accelerations are vector quantities (they have magnitude and direction) and add according to the parallelogram law. As a vector, the calculated net force is equal to the product of the object's mass (a scalar quantity) and the acceleration.
     /// </summary>
-    public partial struct Acceleration : IQuantity<AccelerationUnit>, IEquatable<Acceleration>, IComparable, IComparable<Acceleration>, IConvertible, IFormattable
+    public partial struct Acceleration<T> : IQuantityT<AccelerationUnit, T>, IEquatable<Acceleration<T>>, IComparable, IComparable<Acceleration<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -76,12 +72,12 @@ static Acceleration()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Acceleration(double value, AccelerationUnit unit)
+        public Acceleration(T value, AccelerationUnit unit)
         {
             if(unit == AccelerationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -93,14 +89,14 @@ public Acceleration(double value, AccelerationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Acceleration(double value, UnitSystem unitSystem)
+        public Acceleration(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -115,19 +111,19 @@ public Acceleration(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Acceleration, which is MeterPerSecondSquared. All conversions go via this value.
+        ///     The base unit of <see cref="Acceleration{T}" />, which is MeterPerSecondSquared. All conversions go via this value.
         /// </summary>
         public static AccelerationUnit BaseUnit { get; } = AccelerationUnit.MeterPerSecondSquared;
 
         /// <summary>
-        /// Represents the largest possible value of Acceleration
+        /// Represents the largest possible value of <see cref="Acceleration{T}" />
         /// </summary>
-        public static Acceleration MaxValue { get; } = new Acceleration(double.MaxValue, BaseUnit);
+        public static Acceleration<T> MaxValue { get; } = new Acceleration<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Acceleration
+        /// Represents the smallest possible value of <see cref="Acceleration{T}" />
         /// </summary>
-        public static Acceleration MinValue { get; } = new Acceleration(double.MinValue, BaseUnit);
+        public static Acceleration<T> MinValue { get; } = new Acceleration<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -136,14 +132,14 @@ public Acceleration(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Acceleration;
 
         /// <summary>
-        ///     All units of measurement for the Acceleration quantity.
+        ///     All units of measurement for the <see cref="Acceleration{T}" /> quantity.
         /// </summary>
         public static AccelerationUnit[] Units { get; } = Enum.GetValues(typeof(AccelerationUnit)).Cast<AccelerationUnit>().Except(new AccelerationUnit[]{ AccelerationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit MeterPerSecondSquared.
         /// </summary>
-        public static Acceleration Zero { get; } = new Acceleration(0, BaseUnit);
+        public static Acceleration<T> Zero { get; } = new Acceleration<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -152,7 +148,9 @@ public Acceleration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -168,86 +166,86 @@ public Acceleration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Acceleration.QuantityType;
+        public QuantityType Type => Acceleration<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Acceleration.BaseDimensions;
+        public BaseDimensions Dimensions => Acceleration<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Acceleration in CentimetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in CentimetersPerSecondSquared.
         /// </summary>
-        public double CentimetersPerSecondSquared => As(AccelerationUnit.CentimeterPerSecondSquared);
+        public T CentimetersPerSecondSquared => As(AccelerationUnit.CentimeterPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in DecimetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in DecimetersPerSecondSquared.
         /// </summary>
-        public double DecimetersPerSecondSquared => As(AccelerationUnit.DecimeterPerSecondSquared);
+        public T DecimetersPerSecondSquared => As(AccelerationUnit.DecimeterPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in FeetPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in FeetPerSecondSquared.
         /// </summary>
-        public double FeetPerSecondSquared => As(AccelerationUnit.FootPerSecondSquared);
+        public T FeetPerSecondSquared => As(AccelerationUnit.FootPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in InchesPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in InchesPerSecondSquared.
         /// </summary>
-        public double InchesPerSecondSquared => As(AccelerationUnit.InchPerSecondSquared);
+        public T InchesPerSecondSquared => As(AccelerationUnit.InchPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in KilometersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in KilometersPerSecondSquared.
         /// </summary>
-        public double KilometersPerSecondSquared => As(AccelerationUnit.KilometerPerSecondSquared);
+        public T KilometersPerSecondSquared => As(AccelerationUnit.KilometerPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in KnotsPerHour.
+        ///     Get <see cref="Acceleration{T}" /> in KnotsPerHour.
         /// </summary>
-        public double KnotsPerHour => As(AccelerationUnit.KnotPerHour);
+        public T KnotsPerHour => As(AccelerationUnit.KnotPerHour);
 
         /// <summary>
-        ///     Get Acceleration in KnotsPerMinute.
+        ///     Get <see cref="Acceleration{T}" /> in KnotsPerMinute.
         /// </summary>
-        public double KnotsPerMinute => As(AccelerationUnit.KnotPerMinute);
+        public T KnotsPerMinute => As(AccelerationUnit.KnotPerMinute);
 
         /// <summary>
-        ///     Get Acceleration in KnotsPerSecond.
+        ///     Get <see cref="Acceleration{T}" /> in KnotsPerSecond.
         /// </summary>
-        public double KnotsPerSecond => As(AccelerationUnit.KnotPerSecond);
+        public T KnotsPerSecond => As(AccelerationUnit.KnotPerSecond);
 
         /// <summary>
-        ///     Get Acceleration in MetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in MetersPerSecondSquared.
         /// </summary>
-        public double MetersPerSecondSquared => As(AccelerationUnit.MeterPerSecondSquared);
+        public T MetersPerSecondSquared => As(AccelerationUnit.MeterPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in MicrometersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in MicrometersPerSecondSquared.
         /// </summary>
-        public double MicrometersPerSecondSquared => As(AccelerationUnit.MicrometerPerSecondSquared);
+        public T MicrometersPerSecondSquared => As(AccelerationUnit.MicrometerPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in MillimetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in MillimetersPerSecondSquared.
         /// </summary>
-        public double MillimetersPerSecondSquared => As(AccelerationUnit.MillimeterPerSecondSquared);
+        public T MillimetersPerSecondSquared => As(AccelerationUnit.MillimeterPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in MillistandardGravity.
+        ///     Get <see cref="Acceleration{T}" /> in MillistandardGravity.
         /// </summary>
-        public double MillistandardGravity => As(AccelerationUnit.MillistandardGravity);
+        public T MillistandardGravity => As(AccelerationUnit.MillistandardGravity);
 
         /// <summary>
-        ///     Get Acceleration in NanometersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> in NanometersPerSecondSquared.
         /// </summary>
-        public double NanometersPerSecondSquared => As(AccelerationUnit.NanometerPerSecondSquared);
+        public T NanometersPerSecondSquared => As(AccelerationUnit.NanometerPerSecondSquared);
 
         /// <summary>
-        ///     Get Acceleration in StandardGravity.
+        ///     Get <see cref="Acceleration{T}" /> in StandardGravity.
         /// </summary>
-        public double StandardGravity => As(AccelerationUnit.StandardGravity);
+        public T StandardGravity => As(AccelerationUnit.StandardGravity);
 
         #endregion
 
@@ -279,141 +277,127 @@ public static string GetAbbreviation(AccelerationUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Acceleration from CentimetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from CentimetersPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromCentimetersPerSecondSquared(QuantityValue centimeterspersecondsquared)
+        public static Acceleration<T> FromCentimetersPerSecondSquared(T centimeterspersecondsquared)
         {
-            double value = (double) centimeterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared);
+            return new Acceleration<T>(centimeterspersecondsquared, AccelerationUnit.CentimeterPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from DecimetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from DecimetersPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromDecimetersPerSecondSquared(QuantityValue decimeterspersecondsquared)
+        public static Acceleration<T> FromDecimetersPerSecondSquared(T decimeterspersecondsquared)
         {
-            double value = (double) decimeterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared);
+            return new Acceleration<T>(decimeterspersecondsquared, AccelerationUnit.DecimeterPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from FeetPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from FeetPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromFeetPerSecondSquared(QuantityValue feetpersecondsquared)
+        public static Acceleration<T> FromFeetPerSecondSquared(T feetpersecondsquared)
         {
-            double value = (double) feetpersecondsquared;
-            return new Acceleration(value, AccelerationUnit.FootPerSecondSquared);
+            return new Acceleration<T>(feetpersecondsquared, AccelerationUnit.FootPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from InchesPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from InchesPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromInchesPerSecondSquared(QuantityValue inchespersecondsquared)
+        public static Acceleration<T> FromInchesPerSecondSquared(T inchespersecondsquared)
         {
-            double value = (double) inchespersecondsquared;
-            return new Acceleration(value, AccelerationUnit.InchPerSecondSquared);
+            return new Acceleration<T>(inchespersecondsquared, AccelerationUnit.InchPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from KilometersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from KilometersPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKilometersPerSecondSquared(QuantityValue kilometerspersecondsquared)
+        public static Acceleration<T> FromKilometersPerSecondSquared(T kilometerspersecondsquared)
         {
-            double value = (double) kilometerspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared);
+            return new Acceleration<T>(kilometerspersecondsquared, AccelerationUnit.KilometerPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from KnotsPerHour.
+        ///     Get <see cref="Acceleration{T}" /> from KnotsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerHour(QuantityValue knotsperhour)
+        public static Acceleration<T> FromKnotsPerHour(T knotsperhour)
         {
-            double value = (double) knotsperhour;
-            return new Acceleration(value, AccelerationUnit.KnotPerHour);
+            return new Acceleration<T>(knotsperhour, AccelerationUnit.KnotPerHour);
         }
         /// <summary>
-        ///     Get Acceleration from KnotsPerMinute.
+        ///     Get <see cref="Acceleration{T}" /> from KnotsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerMinute(QuantityValue knotsperminute)
+        public static Acceleration<T> FromKnotsPerMinute(T knotsperminute)
         {
-            double value = (double) knotsperminute;
-            return new Acceleration(value, AccelerationUnit.KnotPerMinute);
+            return new Acceleration<T>(knotsperminute, AccelerationUnit.KnotPerMinute);
         }
         /// <summary>
-        ///     Get Acceleration from KnotsPerSecond.
+        ///     Get <see cref="Acceleration{T}" /> from KnotsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerSecond(QuantityValue knotspersecond)
+        public static Acceleration<T> FromKnotsPerSecond(T knotspersecond)
         {
-            double value = (double) knotspersecond;
-            return new Acceleration(value, AccelerationUnit.KnotPerSecond);
+            return new Acceleration<T>(knotspersecond, AccelerationUnit.KnotPerSecond);
         }
         /// <summary>
-        ///     Get Acceleration from MetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from MetersPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMetersPerSecondSquared(QuantityValue meterspersecondsquared)
+        public static Acceleration<T> FromMetersPerSecondSquared(T meterspersecondsquared)
         {
-            double value = (double) meterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared);
+            return new Acceleration<T>(meterspersecondsquared, AccelerationUnit.MeterPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from MicrometersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from MicrometersPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMicrometersPerSecondSquared(QuantityValue micrometerspersecondsquared)
+        public static Acceleration<T> FromMicrometersPerSecondSquared(T micrometerspersecondsquared)
         {
-            double value = (double) micrometerspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared);
+            return new Acceleration<T>(micrometerspersecondsquared, AccelerationUnit.MicrometerPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from MillimetersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from MillimetersPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMillimetersPerSecondSquared(QuantityValue millimeterspersecondsquared)
+        public static Acceleration<T> FromMillimetersPerSecondSquared(T millimeterspersecondsquared)
         {
-            double value = (double) millimeterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared);
+            return new Acceleration<T>(millimeterspersecondsquared, AccelerationUnit.MillimeterPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from MillistandardGravity.
+        ///     Get <see cref="Acceleration{T}" /> from MillistandardGravity.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMillistandardGravity(QuantityValue millistandardgravity)
+        public static Acceleration<T> FromMillistandardGravity(T millistandardgravity)
         {
-            double value = (double) millistandardgravity;
-            return new Acceleration(value, AccelerationUnit.MillistandardGravity);
+            return new Acceleration<T>(millistandardgravity, AccelerationUnit.MillistandardGravity);
         }
         /// <summary>
-        ///     Get Acceleration from NanometersPerSecondSquared.
+        ///     Get <see cref="Acceleration{T}" /> from NanometersPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromNanometersPerSecondSquared(QuantityValue nanometerspersecondsquared)
+        public static Acceleration<T> FromNanometersPerSecondSquared(T nanometerspersecondsquared)
         {
-            double value = (double) nanometerspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared);
+            return new Acceleration<T>(nanometerspersecondsquared, AccelerationUnit.NanometerPerSecondSquared);
         }
         /// <summary>
-        ///     Get Acceleration from StandardGravity.
+        ///     Get <see cref="Acceleration{T}" /> from StandardGravity.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromStandardGravity(QuantityValue standardgravity)
+        public static Acceleration<T> FromStandardGravity(T standardgravity)
         {
-            double value = (double) standardgravity;
-            return new Acceleration(value, AccelerationUnit.StandardGravity);
+            return new Acceleration<T>(standardgravity, AccelerationUnit.StandardGravity);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AccelerationUnit" /> to <see cref="Acceleration" />.
+        ///     Dynamically convert from value and unit enum <see cref="AccelerationUnit" /> to <see cref="Acceleration{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Acceleration unit value.</returns>
-        public static Acceleration From(QuantityValue value, AccelerationUnit fromUnit)
+        /// <returns><see cref="Acceleration{T}" /> unit value.</returns>
+        public static Acceleration<T> From(T value, AccelerationUnit fromUnit)
         {
-            return new Acceleration((double)value, fromUnit);
+            return new Acceleration<T>(value, fromUnit);
         }
 
         #endregion
@@ -442,7 +426,7 @@ public static Acceleration From(QuantityValue value, AccelerationUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Acceleration Parse(string str)
+        public static Acceleration<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -470,9 +454,9 @@ public static Acceleration Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Acceleration Parse(string str, IFormatProvider? provider)
+        public static Acceleration<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Acceleration, AccelerationUnit>(
+            return QuantityParser.Default.Parse<T, Acceleration<T>, AccelerationUnit>(
                 str,
                 provider,
                 From);
@@ -486,7 +470,7 @@ public static Acceleration Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Acceleration result)
+        public static bool TryParse(string? str, out Acceleration<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -501,9 +485,9 @@ public static bool TryParse(string? str, out Acceleration result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Acceleration result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Acceleration<T> result)
         {
-            return QuantityParser.Default.TryParse<Acceleration, AccelerationUnit>(
+            return QuantityParser.Default.TryParse<T, Acceleration<T>, AccelerationUnit>(
                 str,
                 provider,
                 From,
@@ -565,45 +549,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Accel
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Acceleration operator -(Acceleration right)
+        public static Acceleration<T> operator -(Acceleration<T> right)
         {
-            return new Acceleration(-right.Value, right.Unit);
+            return new Acceleration<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from adding two <see cref="Acceleration"/>.</summary>
-        public static Acceleration operator +(Acceleration left, Acceleration right)
+        /// <summary>Get <see cref="Acceleration{T}"/> from adding two <see cref="Acceleration{T}"/>.</summary>
+        public static Acceleration<T> operator +(Acceleration<T> left, Acceleration<T> right)
         {
-            return new Acceleration(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Acceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from subtracting two <see cref="Acceleration"/>.</summary>
-        public static Acceleration operator -(Acceleration left, Acceleration right)
+        /// <summary>Get <see cref="Acceleration{T}"/> from subtracting two <see cref="Acceleration{T}"/>.</summary>
+        public static Acceleration<T> operator -(Acceleration<T> left, Acceleration<T> right)
         {
-            return new Acceleration(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Acceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from multiplying value and <see cref="Acceleration"/>.</summary>
-        public static Acceleration operator *(double left, Acceleration right)
+        /// <summary>Get <see cref="Acceleration{T}"/> from multiplying value and <see cref="Acceleration{T}"/>.</summary>
+        public static Acceleration<T> operator *(T left, Acceleration<T> right)
         {
-            return new Acceleration(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Acceleration<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from multiplying value and <see cref="Acceleration"/>.</summary>
-        public static Acceleration operator *(Acceleration left, double right)
+        /// <summary>Get <see cref="Acceleration{T}"/> from multiplying value and <see cref="Acceleration{T}"/>.</summary>
+        public static Acceleration<T> operator *(Acceleration<T> left, T right)
         {
-            return new Acceleration(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Acceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Acceleration"/> from dividing <see cref="Acceleration"/> by value.</summary>
-        public static Acceleration operator /(Acceleration left, double right)
+        /// <summary>Get <see cref="Acceleration{T}"/> from dividing <see cref="Acceleration{T}"/> by value.</summary>
+        public static Acceleration<T> operator /(Acceleration<T> left, T right)
         {
-            return new Acceleration(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Acceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Acceleration"/> by <see cref="Acceleration"/>.</summary>
-        public static double operator /(Acceleration left, Acceleration right)
+        /// <summary>Get ratio value from dividing <see cref="Acceleration{T}"/> by <see cref="Acceleration{T}"/>.</summary>
+        public static T operator /(Acceleration<T> left, Acceleration<T> right)
         {
-            return left.MetersPerSecondSquared / right.MetersPerSecondSquared;
+            return CompiledLambdas.Divide(left.MetersPerSecondSquared, right.MetersPerSecondSquared);
         }
 
         #endregion
@@ -611,39 +600,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Accel
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Acceleration left, Acceleration right)
+        public static bool operator <=(Acceleration<T> left, Acceleration<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Acceleration left, Acceleration right)
+        public static bool operator >=(Acceleration<T> left, Acceleration<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Acceleration left, Acceleration right)
+        public static bool operator <(Acceleration<T> left, Acceleration<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Acceleration left, Acceleration right)
+        public static bool operator >(Acceleration<T> left, Acceleration<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Acceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Acceleration left, Acceleration right)
+        /// <remarks>Consider using <see cref="Equals(Acceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Acceleration<T> left, Acceleration<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Acceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Acceleration left, Acceleration right)
+        /// <remarks>Consider using <see cref="Equals(Acceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Acceleration<T> left, Acceleration<T> right)
         {
             return !(left == right);
         }
@@ -652,37 +641,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Accel
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Acceleration objAcceleration)) throw new ArgumentException("Expected type Acceleration.", nameof(obj));
+            if(!(obj is Acceleration<T> objAcceleration)) throw new ArgumentException("Expected type Acceleration.", nameof(obj));
 
             return CompareTo(objAcceleration);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Acceleration other)
+        public int CompareTo(Acceleration<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Acceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Acceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Acceleration objAcceleration))
+            if(obj is null || !(obj is Acceleration<T> objAcceleration))
                 return false;
 
             return Equals(objAcceleration);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Acceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Acceleration other)
+        /// <remarks>Consider using <see cref="Equals(Acceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Acceleration<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Acceleration within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Acceleration{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -720,21 +709,19 @@ public bool Equals(Acceleration other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Acceleration other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Acceleration<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Acceleration.</returns>
+        /// <returns>A hash code for the current <see cref="Acceleration{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -748,17 +735,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(AccelerationUnit unit)
+        public T As(AccelerationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -778,17 +765,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is AccelerationUnit unitAsAccelerationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AccelerationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsAccelerationUnit);
+            var asValue = As(unitAsAccelerationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<AccelerationUnit>.As(AccelerationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Acceleration to another Acceleration with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Acceleration{T}" /> to another <see cref="Acceleration{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Acceleration with the specified unit.</returns>
-        public Acceleration ToUnit(AccelerationUnit unit)
+        /// <returns>A <see cref="Acceleration{T}" /> with the specified unit.</returns>
+        public Acceleration<T> ToUnit(AccelerationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Acceleration(convertedValue, unit);
+            return new Acceleration<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -801,7 +793,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Acceleration ToUnit(UnitSystem unitSystem)
+        public Acceleration<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -821,32 +813,38 @@ public Acceleration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AccelerationUnit> IQuantity<AccelerationUnit>.ToUnit(AccelerationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<AccelerationUnit, T> IQuantityT<AccelerationUnit, T>.ToUnit(AccelerationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<AccelerationUnit> IQuantity<AccelerationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<AccelerationUnit, T> IQuantityT<AccelerationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case AccelerationUnit.CentimeterPerSecondSquared: return (_value) * 1e-2d;
-                case AccelerationUnit.DecimeterPerSecondSquared: return (_value) * 1e-1d;
-                case AccelerationUnit.FootPerSecondSquared: return _value*0.304800;
-                case AccelerationUnit.InchPerSecondSquared: return _value*0.0254;
-                case AccelerationUnit.KilometerPerSecondSquared: return (_value) * 1e3d;
-                case AccelerationUnit.KnotPerHour: return _value*0.5144444444444/3600;
-                case AccelerationUnit.KnotPerMinute: return _value*0.5144444444444/60;
-                case AccelerationUnit.KnotPerSecond: return _value*0.5144444444444;
-                case AccelerationUnit.MeterPerSecondSquared: return _value;
-                case AccelerationUnit.MicrometerPerSecondSquared: return (_value) * 1e-6d;
-                case AccelerationUnit.MillimeterPerSecondSquared: return (_value) * 1e-3d;
-                case AccelerationUnit.MillistandardGravity: return (_value*9.80665) * 1e-3d;
-                case AccelerationUnit.NanometerPerSecondSquared: return (_value) * 1e-9d;
-                case AccelerationUnit.StandardGravity: return _value*9.80665;
+                case AccelerationUnit.CentimeterPerSecondSquared: return (Value) * 1e-2d;
+                case AccelerationUnit.DecimeterPerSecondSquared: return (Value) * 1e-1d;
+                case AccelerationUnit.FootPerSecondSquared: return Value*0.304800;
+                case AccelerationUnit.InchPerSecondSquared: return Value*0.0254;
+                case AccelerationUnit.KilometerPerSecondSquared: return (Value) * 1e3d;
+                case AccelerationUnit.KnotPerHour: return Value*0.5144444444444/3600;
+                case AccelerationUnit.KnotPerMinute: return Value*0.5144444444444/60;
+                case AccelerationUnit.KnotPerSecond: return Value*0.5144444444444;
+                case AccelerationUnit.MeterPerSecondSquared: return Value;
+                case AccelerationUnit.MicrometerPerSecondSquared: return (Value) * 1e-6d;
+                case AccelerationUnit.MillimeterPerSecondSquared: return (Value) * 1e-3d;
+                case AccelerationUnit.MillistandardGravity: return (Value*9.80665) * 1e-3d;
+                case AccelerationUnit.NanometerPerSecondSquared: return (Value) * 1e-9d;
+                case AccelerationUnit.StandardGravity: return Value*9.80665;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -857,16 +855,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Acceleration ToBaseUnit()
+        internal Acceleration<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Acceleration(baseUnitValue, BaseUnit);
+            return new Acceleration<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(AccelerationUnit unit)
+        private T GetValueAs(AccelerationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -982,57 +980,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Acceleration)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Acceleration<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Acceleration)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Acceleration<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Acceleration)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Acceleration<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1042,33 +1040,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Acceleration))
+            if(conversionType == typeof(Acceleration<T>))
                 return this;
             else if(conversionType == typeof(AccelerationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Acceleration.QuantityType;
+                return Acceleration<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Acceleration.Info;
+                return Acceleration<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Acceleration.BaseDimensions;
+                return Acceleration<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Acceleration)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Acceleration<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
index 969ee4af11..8854fbe15b 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Mole is the amount of substance containing Avagadro's Number (6.02 x 10 ^ 23) of real particles such as molecules,atoms, ions or radicals.
     /// </summary>
-    public partial struct AmountOfSubstance : IQuantity<AmountOfSubstanceUnit>, IEquatable<AmountOfSubstance>, IComparable, IComparable<AmountOfSubstance>, IConvertible, IFormattable
+    public partial struct AmountOfSubstance<T> : IQuantityT<AmountOfSubstanceUnit, T>, IEquatable<AmountOfSubstance<T>>, IComparable, IComparable<AmountOfSubstance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -77,12 +73,12 @@ static AmountOfSubstance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public AmountOfSubstance(double value, AmountOfSubstanceUnit unit)
+        public AmountOfSubstance(T value, AmountOfSubstanceUnit unit)
         {
             if(unit == AmountOfSubstanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -94,14 +90,14 @@ public AmountOfSubstance(double value, AmountOfSubstanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AmountOfSubstance(double value, UnitSystem unitSystem)
+        public AmountOfSubstance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -116,19 +112,19 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of AmountOfSubstance, which is Mole. All conversions go via this value.
+        ///     The base unit of <see cref="AmountOfSubstance{T}" />, which is Mole. All conversions go via this value.
         /// </summary>
         public static AmountOfSubstanceUnit BaseUnit { get; } = AmountOfSubstanceUnit.Mole;
 
         /// <summary>
-        /// Represents the largest possible value of AmountOfSubstance
+        /// Represents the largest possible value of <see cref="AmountOfSubstance{T}" />
         /// </summary>
-        public static AmountOfSubstance MaxValue { get; } = new AmountOfSubstance(double.MaxValue, BaseUnit);
+        public static AmountOfSubstance<T> MaxValue { get; } = new AmountOfSubstance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of AmountOfSubstance
+        /// Represents the smallest possible value of <see cref="AmountOfSubstance{T}" />
         /// </summary>
-        public static AmountOfSubstance MinValue { get; } = new AmountOfSubstance(double.MinValue, BaseUnit);
+        public static AmountOfSubstance<T> MinValue { get; } = new AmountOfSubstance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -137,14 +133,14 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.AmountOfSubstance;
 
         /// <summary>
-        ///     All units of measurement for the AmountOfSubstance quantity.
+        ///     All units of measurement for the <see cref="AmountOfSubstance{T}" /> quantity.
         /// </summary>
         public static AmountOfSubstanceUnit[] Units { get; } = Enum.GetValues(typeof(AmountOfSubstanceUnit)).Cast<AmountOfSubstanceUnit>().Except(new AmountOfSubstanceUnit[]{ AmountOfSubstanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Mole.
         /// </summary>
-        public static AmountOfSubstance Zero { get; } = new AmountOfSubstance(0, BaseUnit);
+        public static AmountOfSubstance<T> Zero { get; } = new AmountOfSubstance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -153,7 +149,9 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -169,91 +167,91 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => AmountOfSubstance.QuantityType;
+        public QuantityType Type => AmountOfSubstance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => AmountOfSubstance.BaseDimensions;
+        public BaseDimensions Dimensions => AmountOfSubstance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get AmountOfSubstance in Centimoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Centimoles.
         /// </summary>
-        public double Centimoles => As(AmountOfSubstanceUnit.Centimole);
+        public T Centimoles => As(AmountOfSubstanceUnit.Centimole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in CentipoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in CentipoundMoles.
         /// </summary>
-        public double CentipoundMoles => As(AmountOfSubstanceUnit.CentipoundMole);
+        public T CentipoundMoles => As(AmountOfSubstanceUnit.CentipoundMole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in Decimoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Decimoles.
         /// </summary>
-        public double Decimoles => As(AmountOfSubstanceUnit.Decimole);
+        public T Decimoles => As(AmountOfSubstanceUnit.Decimole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in DecipoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in DecipoundMoles.
         /// </summary>
-        public double DecipoundMoles => As(AmountOfSubstanceUnit.DecipoundMole);
+        public T DecipoundMoles => As(AmountOfSubstanceUnit.DecipoundMole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in Kilomoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Kilomoles.
         /// </summary>
-        public double Kilomoles => As(AmountOfSubstanceUnit.Kilomole);
+        public T Kilomoles => As(AmountOfSubstanceUnit.Kilomole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in KilopoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in KilopoundMoles.
         /// </summary>
-        public double KilopoundMoles => As(AmountOfSubstanceUnit.KilopoundMole);
+        public T KilopoundMoles => As(AmountOfSubstanceUnit.KilopoundMole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in Megamoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Megamoles.
         /// </summary>
-        public double Megamoles => As(AmountOfSubstanceUnit.Megamole);
+        public T Megamoles => As(AmountOfSubstanceUnit.Megamole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in Micromoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Micromoles.
         /// </summary>
-        public double Micromoles => As(AmountOfSubstanceUnit.Micromole);
+        public T Micromoles => As(AmountOfSubstanceUnit.Micromole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in MicropoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in MicropoundMoles.
         /// </summary>
-        public double MicropoundMoles => As(AmountOfSubstanceUnit.MicropoundMole);
+        public T MicropoundMoles => As(AmountOfSubstanceUnit.MicropoundMole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in Millimoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Millimoles.
         /// </summary>
-        public double Millimoles => As(AmountOfSubstanceUnit.Millimole);
+        public T Millimoles => As(AmountOfSubstanceUnit.Millimole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in MillipoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in MillipoundMoles.
         /// </summary>
-        public double MillipoundMoles => As(AmountOfSubstanceUnit.MillipoundMole);
+        public T MillipoundMoles => As(AmountOfSubstanceUnit.MillipoundMole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in Moles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Moles.
         /// </summary>
-        public double Moles => As(AmountOfSubstanceUnit.Mole);
+        public T Moles => As(AmountOfSubstanceUnit.Mole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in Nanomoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in Nanomoles.
         /// </summary>
-        public double Nanomoles => As(AmountOfSubstanceUnit.Nanomole);
+        public T Nanomoles => As(AmountOfSubstanceUnit.Nanomole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in NanopoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in NanopoundMoles.
         /// </summary>
-        public double NanopoundMoles => As(AmountOfSubstanceUnit.NanopoundMole);
+        public T NanopoundMoles => As(AmountOfSubstanceUnit.NanopoundMole);
 
         /// <summary>
-        ///     Get AmountOfSubstance in PoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> in PoundMoles.
         /// </summary>
-        public double PoundMoles => As(AmountOfSubstanceUnit.PoundMole);
+        public T PoundMoles => As(AmountOfSubstanceUnit.PoundMole);
 
         #endregion
 
@@ -285,150 +283,135 @@ public static string GetAbbreviation(AmountOfSubstanceUnit unit, IFormatProvider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get AmountOfSubstance from Centimoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Centimoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromCentimoles(QuantityValue centimoles)
+        public static AmountOfSubstance<T> FromCentimoles(T centimoles)
         {
-            double value = (double) centimoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole);
+            return new AmountOfSubstance<T>(centimoles, AmountOfSubstanceUnit.Centimole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from CentipoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from CentipoundMoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromCentipoundMoles(QuantityValue centipoundmoles)
+        public static AmountOfSubstance<T> FromCentipoundMoles(T centipoundmoles)
         {
-            double value = (double) centipoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole);
+            return new AmountOfSubstance<T>(centipoundmoles, AmountOfSubstanceUnit.CentipoundMole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from Decimoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Decimoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromDecimoles(QuantityValue decimoles)
+        public static AmountOfSubstance<T> FromDecimoles(T decimoles)
         {
-            double value = (double) decimoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole);
+            return new AmountOfSubstance<T>(decimoles, AmountOfSubstanceUnit.Decimole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from DecipoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from DecipoundMoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromDecipoundMoles(QuantityValue decipoundmoles)
+        public static AmountOfSubstance<T> FromDecipoundMoles(T decipoundmoles)
         {
-            double value = (double) decipoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole);
+            return new AmountOfSubstance<T>(decipoundmoles, AmountOfSubstanceUnit.DecipoundMole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from Kilomoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Kilomoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromKilomoles(QuantityValue kilomoles)
+        public static AmountOfSubstance<T> FromKilomoles(T kilomoles)
         {
-            double value = (double) kilomoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole);
+            return new AmountOfSubstance<T>(kilomoles, AmountOfSubstanceUnit.Kilomole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from KilopoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from KilopoundMoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromKilopoundMoles(QuantityValue kilopoundmoles)
+        public static AmountOfSubstance<T> FromKilopoundMoles(T kilopoundmoles)
         {
-            double value = (double) kilopoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole);
+            return new AmountOfSubstance<T>(kilopoundmoles, AmountOfSubstanceUnit.KilopoundMole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from Megamoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Megamoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMegamoles(QuantityValue megamoles)
+        public static AmountOfSubstance<T> FromMegamoles(T megamoles)
         {
-            double value = (double) megamoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole);
+            return new AmountOfSubstance<T>(megamoles, AmountOfSubstanceUnit.Megamole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from Micromoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Micromoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMicromoles(QuantityValue micromoles)
+        public static AmountOfSubstance<T> FromMicromoles(T micromoles)
         {
-            double value = (double) micromoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole);
+            return new AmountOfSubstance<T>(micromoles, AmountOfSubstanceUnit.Micromole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from MicropoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from MicropoundMoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMicropoundMoles(QuantityValue micropoundmoles)
+        public static AmountOfSubstance<T> FromMicropoundMoles(T micropoundmoles)
         {
-            double value = (double) micropoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole);
+            return new AmountOfSubstance<T>(micropoundmoles, AmountOfSubstanceUnit.MicropoundMole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from Millimoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Millimoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMillimoles(QuantityValue millimoles)
+        public static AmountOfSubstance<T> FromMillimoles(T millimoles)
         {
-            double value = (double) millimoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole);
+            return new AmountOfSubstance<T>(millimoles, AmountOfSubstanceUnit.Millimole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from MillipoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from MillipoundMoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMillipoundMoles(QuantityValue millipoundmoles)
+        public static AmountOfSubstance<T> FromMillipoundMoles(T millipoundmoles)
         {
-            double value = (double) millipoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole);
+            return new AmountOfSubstance<T>(millipoundmoles, AmountOfSubstanceUnit.MillipoundMole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from Moles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Moles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMoles(QuantityValue moles)
+        public static AmountOfSubstance<T> FromMoles(T moles)
         {
-            double value = (double) moles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole);
+            return new AmountOfSubstance<T>(moles, AmountOfSubstanceUnit.Mole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from Nanomoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from Nanomoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromNanomoles(QuantityValue nanomoles)
+        public static AmountOfSubstance<T> FromNanomoles(T nanomoles)
         {
-            double value = (double) nanomoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole);
+            return new AmountOfSubstance<T>(nanomoles, AmountOfSubstanceUnit.Nanomole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from NanopoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from NanopoundMoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromNanopoundMoles(QuantityValue nanopoundmoles)
+        public static AmountOfSubstance<T> FromNanopoundMoles(T nanopoundmoles)
         {
-            double value = (double) nanopoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole);
+            return new AmountOfSubstance<T>(nanopoundmoles, AmountOfSubstanceUnit.NanopoundMole);
         }
         /// <summary>
-        ///     Get AmountOfSubstance from PoundMoles.
+        ///     Get <see cref="AmountOfSubstance{T}" /> from PoundMoles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromPoundMoles(QuantityValue poundmoles)
+        public static AmountOfSubstance<T> FromPoundMoles(T poundmoles)
         {
-            double value = (double) poundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole);
+            return new AmountOfSubstance<T>(poundmoles, AmountOfSubstanceUnit.PoundMole);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AmountOfSubstanceUnit" /> to <see cref="AmountOfSubstance" />.
+        ///     Dynamically convert from value and unit enum <see cref="AmountOfSubstanceUnit" /> to <see cref="AmountOfSubstance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AmountOfSubstance unit value.</returns>
-        public static AmountOfSubstance From(QuantityValue value, AmountOfSubstanceUnit fromUnit)
+        /// <returns><see cref="AmountOfSubstance{T}" /> unit value.</returns>
+        public static AmountOfSubstance<T> From(T value, AmountOfSubstanceUnit fromUnit)
         {
-            return new AmountOfSubstance((double)value, fromUnit);
+            return new AmountOfSubstance<T>(value, fromUnit);
         }
 
         #endregion
@@ -457,7 +440,7 @@ public static AmountOfSubstance From(QuantityValue value, AmountOfSubstanceUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static AmountOfSubstance Parse(string str)
+        public static AmountOfSubstance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -485,9 +468,9 @@ public static AmountOfSubstance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static AmountOfSubstance Parse(string str, IFormatProvider? provider)
+        public static AmountOfSubstance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<AmountOfSubstance, AmountOfSubstanceUnit>(
+            return QuantityParser.Default.Parse<T, AmountOfSubstance<T>, AmountOfSubstanceUnit>(
                 str,
                 provider,
                 From);
@@ -501,7 +484,7 @@ public static AmountOfSubstance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out AmountOfSubstance result)
+        public static bool TryParse(string? str, out AmountOfSubstance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -516,9 +499,9 @@ public static bool TryParse(string? str, out AmountOfSubstance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out AmountOfSubstance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out AmountOfSubstance<T> result)
         {
-            return QuantityParser.Default.TryParse<AmountOfSubstance, AmountOfSubstanceUnit>(
+            return QuantityParser.Default.TryParse<T, AmountOfSubstance<T>, AmountOfSubstanceUnit>(
                 str,
                 provider,
                 From,
@@ -580,45 +563,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Amoun
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static AmountOfSubstance operator -(AmountOfSubstance right)
+        public static AmountOfSubstance<T> operator -(AmountOfSubstance<T> right)
         {
-            return new AmountOfSubstance(-right.Value, right.Unit);
+            return new AmountOfSubstance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="AmountOfSubstance"/> from adding two <see cref="AmountOfSubstance"/>.</summary>
-        public static AmountOfSubstance operator +(AmountOfSubstance left, AmountOfSubstance right)
+        /// <summary>Get <see cref="AmountOfSubstance{T}"/> from adding two <see cref="AmountOfSubstance{T}"/>.</summary>
+        public static AmountOfSubstance<T> operator +(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
-            return new AmountOfSubstance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new AmountOfSubstance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AmountOfSubstance"/> from subtracting two <see cref="AmountOfSubstance"/>.</summary>
-        public static AmountOfSubstance operator -(AmountOfSubstance left, AmountOfSubstance right)
+        /// <summary>Get <see cref="AmountOfSubstance{T}"/> from subtracting two <see cref="AmountOfSubstance{T}"/>.</summary>
+        public static AmountOfSubstance<T> operator -(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
-            return new AmountOfSubstance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new AmountOfSubstance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AmountOfSubstance"/> from multiplying value and <see cref="AmountOfSubstance"/>.</summary>
-        public static AmountOfSubstance operator *(double left, AmountOfSubstance right)
+        /// <summary>Get <see cref="AmountOfSubstance{T}"/> from multiplying value and <see cref="AmountOfSubstance{T}"/>.</summary>
+        public static AmountOfSubstance<T> operator *(T left, AmountOfSubstance<T> right)
         {
-            return new AmountOfSubstance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new AmountOfSubstance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="AmountOfSubstance"/> from multiplying value and <see cref="AmountOfSubstance"/>.</summary>
-        public static AmountOfSubstance operator *(AmountOfSubstance left, double right)
+        /// <summary>Get <see cref="AmountOfSubstance{T}"/> from multiplying value and <see cref="AmountOfSubstance{T}"/>.</summary>
+        public static AmountOfSubstance<T> operator *(AmountOfSubstance<T> left, T right)
         {
-            return new AmountOfSubstance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new AmountOfSubstance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AmountOfSubstance"/> from dividing <see cref="AmountOfSubstance"/> by value.</summary>
-        public static AmountOfSubstance operator /(AmountOfSubstance left, double right)
+        /// <summary>Get <see cref="AmountOfSubstance{T}"/> from dividing <see cref="AmountOfSubstance{T}"/> by value.</summary>
+        public static AmountOfSubstance<T> operator /(AmountOfSubstance<T> left, T right)
         {
-            return new AmountOfSubstance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new AmountOfSubstance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="AmountOfSubstance"/> by <see cref="AmountOfSubstance"/>.</summary>
-        public static double operator /(AmountOfSubstance left, AmountOfSubstance right)
+        /// <summary>Get ratio value from dividing <see cref="AmountOfSubstance{T}"/> by <see cref="AmountOfSubstance{T}"/>.</summary>
+        public static T operator /(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
-            return left.Moles / right.Moles;
+            return CompiledLambdas.Divide(left.Moles, right.Moles);
         }
 
         #endregion
@@ -626,39 +614,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Amoun
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(AmountOfSubstance left, AmountOfSubstance right)
+        public static bool operator <=(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(AmountOfSubstance left, AmountOfSubstance right)
+        public static bool operator >=(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(AmountOfSubstance left, AmountOfSubstance right)
+        public static bool operator <(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(AmountOfSubstance left, AmountOfSubstance right)
+        public static bool operator >(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(AmountOfSubstance left, AmountOfSubstance right)
+        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(AmountOfSubstance left, AmountOfSubstance right)
+        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(AmountOfSubstance<T> left, AmountOfSubstance<T> right)
         {
             return !(left == right);
         }
@@ -667,37 +655,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Amoun
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is AmountOfSubstance objAmountOfSubstance)) throw new ArgumentException("Expected type AmountOfSubstance.", nameof(obj));
+            if(!(obj is AmountOfSubstance<T> objAmountOfSubstance)) throw new ArgumentException("Expected type AmountOfSubstance.", nameof(obj));
 
             return CompareTo(objAmountOfSubstance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(AmountOfSubstance other)
+        public int CompareTo(AmountOfSubstance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is AmountOfSubstance objAmountOfSubstance))
+            if(obj is null || !(obj is AmountOfSubstance<T> objAmountOfSubstance))
                 return false;
 
             return Equals(objAmountOfSubstance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(AmountOfSubstance other)
+        /// <remarks>Consider using <see cref="Equals(AmountOfSubstance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(AmountOfSubstance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another AmountOfSubstance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="AmountOfSubstance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -735,21 +723,19 @@ public bool Equals(AmountOfSubstance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(AmountOfSubstance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(AmountOfSubstance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current AmountOfSubstance.</returns>
+        /// <returns>A hash code for the current <see cref="AmountOfSubstance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -763,17 +749,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(AmountOfSubstanceUnit unit)
+        public T As(AmountOfSubstanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -793,17 +779,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is AmountOfSubstanceUnit unitAsAmountOfSubstanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmountOfSubstanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsAmountOfSubstanceUnit);
+            var asValue = As(unitAsAmountOfSubstanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<AmountOfSubstanceUnit>.As(AmountOfSubstanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this AmountOfSubstance to another AmountOfSubstance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="AmountOfSubstance{T}" /> to another <see cref="AmountOfSubstance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A AmountOfSubstance with the specified unit.</returns>
-        public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit)
+        /// <returns>A <see cref="AmountOfSubstance{T}" /> with the specified unit.</returns>
+        public AmountOfSubstance<T> ToUnit(AmountOfSubstanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new AmountOfSubstance(convertedValue, unit);
+            return new AmountOfSubstance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -816,7 +807,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public AmountOfSubstance ToUnit(UnitSystem unitSystem)
+        public AmountOfSubstance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -836,33 +827,39 @@ public AmountOfSubstance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AmountOfSubstanceUnit> IQuantity<AmountOfSubstanceUnit>.ToUnit(AmountOfSubstanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<AmountOfSubstanceUnit, T> IQuantityT<AmountOfSubstanceUnit, T>.ToUnit(AmountOfSubstanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<AmountOfSubstanceUnit> IQuantity<AmountOfSubstanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<AmountOfSubstanceUnit, T> IQuantityT<AmountOfSubstanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case AmountOfSubstanceUnit.Centimole: return (_value) * 1e-2d;
-                case AmountOfSubstanceUnit.CentipoundMole: return (_value*453.59237) * 1e-2d;
-                case AmountOfSubstanceUnit.Decimole: return (_value) * 1e-1d;
-                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;
-                case AmountOfSubstanceUnit.MillipoundMole: return (_value*453.59237) * 1e-3d;
-                case AmountOfSubstanceUnit.Mole: return _value;
-                case AmountOfSubstanceUnit.Nanomole: return (_value) * 1e-9d;
-                case AmountOfSubstanceUnit.NanopoundMole: return (_value*453.59237) * 1e-9d;
-                case AmountOfSubstanceUnit.PoundMole: return _value*453.59237;
+                case AmountOfSubstanceUnit.Centimole: return (Value) * 1e-2d;
+                case AmountOfSubstanceUnit.CentipoundMole: return (Value*453.59237) * 1e-2d;
+                case AmountOfSubstanceUnit.Decimole: return (Value) * 1e-1d;
+                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;
+                case AmountOfSubstanceUnit.MillipoundMole: return (Value*453.59237) * 1e-3d;
+                case AmountOfSubstanceUnit.Mole: return Value;
+                case AmountOfSubstanceUnit.Nanomole: return (Value) * 1e-9d;
+                case AmountOfSubstanceUnit.NanopoundMole: return (Value*453.59237) * 1e-9d;
+                case AmountOfSubstanceUnit.PoundMole: return Value*453.59237;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -873,16 +870,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal AmountOfSubstance ToBaseUnit()
+        internal AmountOfSubstance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new AmountOfSubstance(baseUnitValue, BaseUnit);
+            return new AmountOfSubstance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(AmountOfSubstanceUnit unit)
+        private T GetValueAs(AmountOfSubstanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -999,57 +996,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AmountOfSubstance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AmountOfSubstance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AmountOfSubstance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AmountOfSubstance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AmountOfSubstance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AmountOfSubstance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1059,33 +1056,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(AmountOfSubstance))
+            if(conversionType == typeof(AmountOfSubstance<T>))
                 return this;
             else if(conversionType == typeof(AmountOfSubstanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return AmountOfSubstance.QuantityType;
+                return AmountOfSubstance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return AmountOfSubstance.Info;
+                return AmountOfSubstance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return AmountOfSubstance.BaseDimensions;
+                return AmountOfSubstance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(AmountOfSubstance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(AmountOfSubstance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
index 315b035405..9f73706069 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The strength of a signal expressed in decibels (dB) relative to one volt RMS.
     /// </summary>
-    public partial struct AmplitudeRatio : IQuantity<AmplitudeRatioUnit>, IEquatable<AmplitudeRatio>, IComparable, IComparable<AmplitudeRatio>, IConvertible, IFormattable
+    public partial struct AmplitudeRatio<T> : IQuantityT<AmplitudeRatioUnit, T>, IEquatable<AmplitudeRatio<T>>, IComparable, IComparable<AmplitudeRatio<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static AmplitudeRatio()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
+        public AmplitudeRatio(T value, AmplitudeRatioUnit unit)
         {
             if(unit == AmplitudeRatioUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AmplitudeRatio(double value, UnitSystem unitSystem)
+        public AmplitudeRatio(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public AmplitudeRatio(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of AmplitudeRatio, which is DecibelVolt. All conversions go via this value.
+        ///     The base unit of <see cref="AmplitudeRatio{T}" />, which is DecibelVolt. All conversions go via this value.
         /// </summary>
         public static AmplitudeRatioUnit BaseUnit { get; } = AmplitudeRatioUnit.DecibelVolt;
 
         /// <summary>
-        /// Represents the largest possible value of AmplitudeRatio
+        /// Represents the largest possible value of <see cref="AmplitudeRatio{T}" />
         /// </summary>
-        public static AmplitudeRatio MaxValue { get; } = new AmplitudeRatio(double.MaxValue, BaseUnit);
+        public static AmplitudeRatio<T> MaxValue { get; } = new AmplitudeRatio<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of AmplitudeRatio
+        /// Represents the smallest possible value of <see cref="AmplitudeRatio{T}" />
         /// </summary>
-        public static AmplitudeRatio MinValue { get; } = new AmplitudeRatio(double.MinValue, BaseUnit);
+        public static AmplitudeRatio<T> MinValue { get; } = new AmplitudeRatio<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public AmplitudeRatio(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.AmplitudeRatio;
 
         /// <summary>
-        ///     All units of measurement for the AmplitudeRatio quantity.
+        ///     All units of measurement for the <see cref="AmplitudeRatio{T}" /> quantity.
         /// </summary>
         public static AmplitudeRatioUnit[] Units { get; } = Enum.GetValues(typeof(AmplitudeRatioUnit)).Cast<AmplitudeRatioUnit>().Except(new AmplitudeRatioUnit[]{ AmplitudeRatioUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DecibelVolt.
         /// </summary>
-        public static AmplitudeRatio Zero { get; } = new AmplitudeRatio(0, BaseUnit);
+        public static AmplitudeRatio<T> Zero { get; } = new AmplitudeRatio<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public AmplitudeRatio(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,36 +156,36 @@ public AmplitudeRatio(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => AmplitudeRatio.QuantityType;
+        public QuantityType Type => AmplitudeRatio<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => AmplitudeRatio.BaseDimensions;
+        public BaseDimensions Dimensions => AmplitudeRatio<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get AmplitudeRatio in DecibelMicrovolts.
+        ///     Get <see cref="AmplitudeRatio{T}" /> in DecibelMicrovolts.
         /// </summary>
-        public double DecibelMicrovolts => As(AmplitudeRatioUnit.DecibelMicrovolt);
+        public T DecibelMicrovolts => As(AmplitudeRatioUnit.DecibelMicrovolt);
 
         /// <summary>
-        ///     Get AmplitudeRatio in DecibelMillivolts.
+        ///     Get <see cref="AmplitudeRatio{T}" /> in DecibelMillivolts.
         /// </summary>
-        public double DecibelMillivolts => As(AmplitudeRatioUnit.DecibelMillivolt);
+        public T DecibelMillivolts => As(AmplitudeRatioUnit.DecibelMillivolt);
 
         /// <summary>
-        ///     Get AmplitudeRatio in DecibelsUnloaded.
+        ///     Get <see cref="AmplitudeRatio{T}" /> in DecibelsUnloaded.
         /// </summary>
-        public double DecibelsUnloaded => As(AmplitudeRatioUnit.DecibelUnloaded);
+        public T DecibelsUnloaded => As(AmplitudeRatioUnit.DecibelUnloaded);
 
         /// <summary>
-        ///     Get AmplitudeRatio in DecibelVolts.
+        ///     Get <see cref="AmplitudeRatio{T}" /> in DecibelVolts.
         /// </summary>
-        public double DecibelVolts => As(AmplitudeRatioUnit.DecibelVolt);
+        public T DecibelVolts => As(AmplitudeRatioUnit.DecibelVolt);
 
         #endregion
 
@@ -219,51 +217,47 @@ public static string GetAbbreviation(AmplitudeRatioUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get AmplitudeRatio from DecibelMicrovolts.
+        ///     Get <see cref="AmplitudeRatio{T}" /> from DecibelMicrovolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelMicrovolts(QuantityValue decibelmicrovolts)
+        public static AmplitudeRatio<T> FromDecibelMicrovolts(T decibelmicrovolts)
         {
-            double value = (double) decibelmicrovolts;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt);
+            return new AmplitudeRatio<T>(decibelmicrovolts, AmplitudeRatioUnit.DecibelMicrovolt);
         }
         /// <summary>
-        ///     Get AmplitudeRatio from DecibelMillivolts.
+        ///     Get <see cref="AmplitudeRatio{T}" /> from DecibelMillivolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelMillivolts(QuantityValue decibelmillivolts)
+        public static AmplitudeRatio<T> FromDecibelMillivolts(T decibelmillivolts)
         {
-            double value = (double) decibelmillivolts;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt);
+            return new AmplitudeRatio<T>(decibelmillivolts, AmplitudeRatioUnit.DecibelMillivolt);
         }
         /// <summary>
-        ///     Get AmplitudeRatio from DecibelsUnloaded.
+        ///     Get <see cref="AmplitudeRatio{T}" /> from DecibelsUnloaded.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelsUnloaded(QuantityValue decibelsunloaded)
+        public static AmplitudeRatio<T> FromDecibelsUnloaded(T decibelsunloaded)
         {
-            double value = (double) decibelsunloaded;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded);
+            return new AmplitudeRatio<T>(decibelsunloaded, AmplitudeRatioUnit.DecibelUnloaded);
         }
         /// <summary>
-        ///     Get AmplitudeRatio from DecibelVolts.
+        ///     Get <see cref="AmplitudeRatio{T}" /> from DecibelVolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelVolts(QuantityValue decibelvolts)
+        public static AmplitudeRatio<T> FromDecibelVolts(T decibelvolts)
         {
-            double value = (double) decibelvolts;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt);
+            return new AmplitudeRatio<T>(decibelvolts, AmplitudeRatioUnit.DecibelVolt);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AmplitudeRatioUnit" /> to <see cref="AmplitudeRatio" />.
+        ///     Dynamically convert from value and unit enum <see cref="AmplitudeRatioUnit" /> to <see cref="AmplitudeRatio{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AmplitudeRatio unit value.</returns>
-        public static AmplitudeRatio From(QuantityValue value, AmplitudeRatioUnit fromUnit)
+        /// <returns><see cref="AmplitudeRatio{T}" /> unit value.</returns>
+        public static AmplitudeRatio<T> From(T value, AmplitudeRatioUnit fromUnit)
         {
-            return new AmplitudeRatio((double)value, fromUnit);
+            return new AmplitudeRatio<T>(value, fromUnit);
         }
 
         #endregion
@@ -292,7 +286,7 @@ public static AmplitudeRatio From(QuantityValue value, AmplitudeRatioUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static AmplitudeRatio Parse(string str)
+        public static AmplitudeRatio<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -320,9 +314,9 @@ public static AmplitudeRatio Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static AmplitudeRatio Parse(string str, IFormatProvider? provider)
+        public static AmplitudeRatio<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<AmplitudeRatio, AmplitudeRatioUnit>(
+            return QuantityParser.Default.Parse<T, AmplitudeRatio<T>, AmplitudeRatioUnit>(
                 str,
                 provider,
                 From);
@@ -336,7 +330,7 @@ public static AmplitudeRatio Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out AmplitudeRatio result)
+        public static bool TryParse(string? str, out AmplitudeRatio<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -351,9 +345,9 @@ public static bool TryParse(string? str, out AmplitudeRatio result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out AmplitudeRatio result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out AmplitudeRatio<T> result)
         {
-            return QuantityParser.Default.TryParse<AmplitudeRatio, AmplitudeRatioUnit>(
+            return QuantityParser.Default.TryParse<T, AmplitudeRatio<T>, AmplitudeRatioUnit>(
                 str,
                 provider,
                 From,
@@ -415,50 +409,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ampli
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static AmplitudeRatio operator -(AmplitudeRatio right)
+        public static AmplitudeRatio<T> operator -(AmplitudeRatio<T> right)
         {
-            return new AmplitudeRatio(-right.Value, right.Unit);
+            return new AmplitudeRatio<T>(-right.Value, right.Unit);
         }
 
-        /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic addition of two <see cref="AmplitudeRatio"/>.</summary>
-        public static AmplitudeRatio operator +(AmplitudeRatio left, AmplitudeRatio right)
+        /// <summary>Get <see cref="AmplitudeRatio{T}"/> from logarithmic addition of two <see cref="AmplitudeRatio{T}"/>.</summary>
+        public static AmplitudeRatio<T> operator +(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
             // Logarithmic addition
             // Formula: 20*log10(10^(x/20) + 10^(y/20))
-            return new AmplitudeRatio(20*Math.Log10(Math.Pow(10, left.Value/20) + Math.Pow(10, right.GetValueAs(left.Unit)/20)), left.Unit);
+            return new AmplitudeRatio<T>(20*Math.Log10(Math.Pow(10, left.Value/20) + Math.Pow(10, right.GetValueAs(left.Unit)/20)), left.Unit);
         }
 
-        /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic subtraction of two <see cref="AmplitudeRatio"/>.</summary>
-        public static AmplitudeRatio operator -(AmplitudeRatio left, AmplitudeRatio right)
+        /// <summary>Get <see cref="AmplitudeRatio{T}"/> from logarithmic subtraction of two <see cref="AmplitudeRatio{T}"/>.</summary>
+        public static AmplitudeRatio<T> operator -(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
             // Logarithmic subtraction
             // Formula: 20*log10(10^(x/20) - 10^(y/20))
-            return new AmplitudeRatio(20*Math.Log10(Math.Pow(10, left.Value/20) - Math.Pow(10, right.GetValueAs(left.Unit)/20)), left.Unit);
+            return new AmplitudeRatio<T>(20*Math.Log10(Math.Pow(10, left.Value/20) - Math.Pow(10, right.GetValueAs(left.Unit)/20)), left.Unit);
         }
 
-        /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic multiplication of value and <see cref="AmplitudeRatio"/>.</summary>
-        public static AmplitudeRatio operator *(double left, AmplitudeRatio right)
+        /// <summary>Get <see cref="AmplitudeRatio{T}"/> from logarithmic multiplication of value and <see cref="AmplitudeRatio{T}"/>.</summary>
+        public static AmplitudeRatio<T> operator *(double left, AmplitudeRatio<T> right)
         {
             // Logarithmic multiplication = addition
-            return new AmplitudeRatio(left + right.Value, right.Unit);
+            return new AmplitudeRatio<T>(left + right.Value, right.Unit);
         }
 
-        /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic multiplication of value and <see cref="AmplitudeRatio"/>.</summary>
-        public static AmplitudeRatio operator *(AmplitudeRatio left, double right)
+        /// <summary>Get <see cref="AmplitudeRatio{T}"/> from logarithmic multiplication of value and <see cref="AmplitudeRatio{T}"/>.</summary>
+        public static AmplitudeRatio<T> operator *(AmplitudeRatio<T> left, double right)
         {
             // Logarithmic multiplication = addition
-            return new AmplitudeRatio(left.Value + (double)right, left.Unit);
+            return new AmplitudeRatio<T>(left.Value + (double)right, left.Unit);
         }
 
-        /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic division of <see cref="AmplitudeRatio"/> by value.</summary>
-        public static AmplitudeRatio operator /(AmplitudeRatio left, double right)
+        /// <summary>Get <see cref="AmplitudeRatio{T}"/> from logarithmic division of <see cref="AmplitudeRatio{T}"/> by value.</summary>
+        public static AmplitudeRatio<T> operator /(AmplitudeRatio<T> left, double right)
         {
             // Logarithmic division = subtraction
-            return new AmplitudeRatio(left.Value - (double)right, left.Unit);
+            return new AmplitudeRatio<T>(left.Value - (double)right, left.Unit);
         }
 
-        /// <summary>Get ratio value from logarithmic division of <see cref="AmplitudeRatio"/> by <see cref="AmplitudeRatio"/>.</summary>
-        public static double operator /(AmplitudeRatio left, AmplitudeRatio right)
+        /// <summary>Get ratio value from logarithmic division of <see cref="AmplitudeRatio{T}"/> by <see cref="AmplitudeRatio{T}"/>.</summary>
+        public static double operator /(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
             // Logarithmic division = subtraction
             return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit));
@@ -469,39 +463,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ampli
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(AmplitudeRatio left, AmplitudeRatio right)
+        public static bool operator <=(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(AmplitudeRatio left, AmplitudeRatio right)
+        public static bool operator >=(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(AmplitudeRatio left, AmplitudeRatio right)
+        public static bool operator <(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(AmplitudeRatio left, AmplitudeRatio right)
+        public static bool operator >(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(AmplitudeRatio left, AmplitudeRatio right)
+        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(AmplitudeRatio left, AmplitudeRatio right)
+        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(AmplitudeRatio<T> left, AmplitudeRatio<T> right)
         {
             return !(left == right);
         }
@@ -510,37 +504,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ampli
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is AmplitudeRatio objAmplitudeRatio)) throw new ArgumentException("Expected type AmplitudeRatio.", nameof(obj));
+            if(!(obj is AmplitudeRatio<T> objAmplitudeRatio)) throw new ArgumentException("Expected type AmplitudeRatio.", nameof(obj));
 
             return CompareTo(objAmplitudeRatio);
         }
 
         /// <inheritdoc />
-        public int CompareTo(AmplitudeRatio other)
+        public int CompareTo(AmplitudeRatio<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is AmplitudeRatio objAmplitudeRatio))
+            if(obj is null || !(obj is AmplitudeRatio<T> objAmplitudeRatio))
                 return false;
 
             return Equals(objAmplitudeRatio);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(AmplitudeRatio other)
+        /// <remarks>Consider using <see cref="Equals(AmplitudeRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(AmplitudeRatio<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another AmplitudeRatio within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="AmplitudeRatio{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -578,21 +572,19 @@ public bool Equals(AmplitudeRatio other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(AmplitudeRatio other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(AmplitudeRatio<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current AmplitudeRatio.</returns>
+        /// <returns>A hash code for the current <see cref="AmplitudeRatio{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -606,17 +598,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(AmplitudeRatioUnit unit)
+        public T As(AmplitudeRatioUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -636,17 +628,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is AmplitudeRatioUnit unitAsAmplitudeRatioUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmplitudeRatioUnit)} is supported.", nameof(unit));
 
-            return As(unitAsAmplitudeRatioUnit);
+            var asValue = As(unitAsAmplitudeRatioUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<AmplitudeRatioUnit>.As(AmplitudeRatioUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this AmplitudeRatio to another AmplitudeRatio with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="AmplitudeRatio{T}" /> to another <see cref="AmplitudeRatio{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A AmplitudeRatio with the specified unit.</returns>
-        public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit)
+        /// <returns>A <see cref="AmplitudeRatio{T}" /> with the specified unit.</returns>
+        public AmplitudeRatio<T> ToUnit(AmplitudeRatioUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new AmplitudeRatio(convertedValue, unit);
+            return new AmplitudeRatio<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -659,7 +656,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public AmplitudeRatio ToUnit(UnitSystem unitSystem)
+        public AmplitudeRatio<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -679,22 +676,28 @@ public AmplitudeRatio ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AmplitudeRatioUnit> IQuantity<AmplitudeRatioUnit>.ToUnit(AmplitudeRatioUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<AmplitudeRatioUnit, T> IQuantityT<AmplitudeRatioUnit, T>.ToUnit(AmplitudeRatioUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<AmplitudeRatioUnit> IQuantity<AmplitudeRatioUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<AmplitudeRatioUnit, T> IQuantityT<AmplitudeRatioUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case AmplitudeRatioUnit.DecibelMicrovolt: return _value - 120;
-                case AmplitudeRatioUnit.DecibelMillivolt: return _value - 60;
-                case AmplitudeRatioUnit.DecibelUnloaded: return _value - 2.218487499;
-                case AmplitudeRatioUnit.DecibelVolt: return _value;
+                case AmplitudeRatioUnit.DecibelMicrovolt: return Value - 120;
+                case AmplitudeRatioUnit.DecibelMillivolt: return Value - 60;
+                case AmplitudeRatioUnit.DecibelUnloaded: return Value - 2.218487499;
+                case AmplitudeRatioUnit.DecibelVolt: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -705,16 +708,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal AmplitudeRatio ToBaseUnit()
+        internal AmplitudeRatio<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new AmplitudeRatio(baseUnitValue, BaseUnit);
+            return new AmplitudeRatio<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(AmplitudeRatioUnit unit)
+        private T GetValueAs(AmplitudeRatioUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -820,57 +823,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AmplitudeRatio)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AmplitudeRatio<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AmplitudeRatio)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AmplitudeRatio<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AmplitudeRatio)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AmplitudeRatio<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -880,33 +883,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(AmplitudeRatio))
+            if(conversionType == typeof(AmplitudeRatio<T>))
                 return this;
             else if(conversionType == typeof(AmplitudeRatioUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return AmplitudeRatio.QuantityType;
+                return AmplitudeRatio<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return AmplitudeRatio.Info;
+                return AmplitudeRatio<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return AmplitudeRatio.BaseDimensions;
+                return AmplitudeRatio<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(AmplitudeRatio)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(AmplitudeRatio<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
index f9e013df61..98d9db6694 100644
--- a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In geometry, an angle is the figure formed by two rays, called the sides of the angle, sharing a common endpoint, called the vertex of the angle.
     /// </summary>
-    public partial struct Angle : IQuantity<AngleUnit>, IEquatable<Angle>, IComparable, IComparable<Angle>, IConvertible, IFormattable
+    public partial struct Angle<T> : IQuantityT<AngleUnit, T>, IEquatable<Angle<T>>, IComparable, IComparable<Angle<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -76,12 +72,12 @@ static Angle()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Angle(double value, AngleUnit unit)
+        public Angle(T value, AngleUnit unit)
         {
             if(unit == AngleUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -93,14 +89,14 @@ public Angle(double value, AngleUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Angle(double value, UnitSystem unitSystem)
+        public Angle(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -115,19 +111,19 @@ public Angle(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Angle, which is Degree. All conversions go via this value.
+        ///     The base unit of <see cref="Angle{T}" />, which is Degree. All conversions go via this value.
         /// </summary>
         public static AngleUnit BaseUnit { get; } = AngleUnit.Degree;
 
         /// <summary>
-        /// Represents the largest possible value of Angle
+        /// Represents the largest possible value of <see cref="Angle{T}" />
         /// </summary>
-        public static Angle MaxValue { get; } = new Angle(double.MaxValue, BaseUnit);
+        public static Angle<T> MaxValue { get; } = new Angle<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Angle
+        /// Represents the smallest possible value of <see cref="Angle{T}" />
         /// </summary>
-        public static Angle MinValue { get; } = new Angle(double.MinValue, BaseUnit);
+        public static Angle<T> MinValue { get; } = new Angle<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -136,14 +132,14 @@ public Angle(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Angle;
 
         /// <summary>
-        ///     All units of measurement for the Angle quantity.
+        ///     All units of measurement for the <see cref="Angle{T}" /> quantity.
         /// </summary>
         public static AngleUnit[] Units { get; } = Enum.GetValues(typeof(AngleUnit)).Cast<AngleUnit>().Except(new AngleUnit[]{ AngleUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Degree.
         /// </summary>
-        public static Angle Zero { get; } = new Angle(0, BaseUnit);
+        public static Angle<T> Zero { get; } = new Angle<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -152,7 +148,9 @@ public Angle(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -168,86 +166,86 @@ public Angle(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Angle.QuantityType;
+        public QuantityType Type => Angle<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Angle.BaseDimensions;
+        public BaseDimensions Dimensions => Angle<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Angle in Arcminutes.
+        ///     Get <see cref="Angle{T}" /> in Arcminutes.
         /// </summary>
-        public double Arcminutes => As(AngleUnit.Arcminute);
+        public T Arcminutes => As(AngleUnit.Arcminute);
 
         /// <summary>
-        ///     Get Angle in Arcseconds.
+        ///     Get <see cref="Angle{T}" /> in Arcseconds.
         /// </summary>
-        public double Arcseconds => As(AngleUnit.Arcsecond);
+        public T Arcseconds => As(AngleUnit.Arcsecond);
 
         /// <summary>
-        ///     Get Angle in Centiradians.
+        ///     Get <see cref="Angle{T}" /> in Centiradians.
         /// </summary>
-        public double Centiradians => As(AngleUnit.Centiradian);
+        public T Centiradians => As(AngleUnit.Centiradian);
 
         /// <summary>
-        ///     Get Angle in Deciradians.
+        ///     Get <see cref="Angle{T}" /> in Deciradians.
         /// </summary>
-        public double Deciradians => As(AngleUnit.Deciradian);
+        public T Deciradians => As(AngleUnit.Deciradian);
 
         /// <summary>
-        ///     Get Angle in Degrees.
+        ///     Get <see cref="Angle{T}" /> in Degrees.
         /// </summary>
-        public double Degrees => As(AngleUnit.Degree);
+        public T Degrees => As(AngleUnit.Degree);
 
         /// <summary>
-        ///     Get Angle in Gradians.
+        ///     Get <see cref="Angle{T}" /> in Gradians.
         /// </summary>
-        public double Gradians => As(AngleUnit.Gradian);
+        public T Gradians => As(AngleUnit.Gradian);
 
         /// <summary>
-        ///     Get Angle in Microdegrees.
+        ///     Get <see cref="Angle{T}" /> in Microdegrees.
         /// </summary>
-        public double Microdegrees => As(AngleUnit.Microdegree);
+        public T Microdegrees => As(AngleUnit.Microdegree);
 
         /// <summary>
-        ///     Get Angle in Microradians.
+        ///     Get <see cref="Angle{T}" /> in Microradians.
         /// </summary>
-        public double Microradians => As(AngleUnit.Microradian);
+        public T Microradians => As(AngleUnit.Microradian);
 
         /// <summary>
-        ///     Get Angle in Millidegrees.
+        ///     Get <see cref="Angle{T}" /> in Millidegrees.
         /// </summary>
-        public double Millidegrees => As(AngleUnit.Millidegree);
+        public T Millidegrees => As(AngleUnit.Millidegree);
 
         /// <summary>
-        ///     Get Angle in Milliradians.
+        ///     Get <see cref="Angle{T}" /> in Milliradians.
         /// </summary>
-        public double Milliradians => As(AngleUnit.Milliradian);
+        public T Milliradians => As(AngleUnit.Milliradian);
 
         /// <summary>
-        ///     Get Angle in Nanodegrees.
+        ///     Get <see cref="Angle{T}" /> in Nanodegrees.
         /// </summary>
-        public double Nanodegrees => As(AngleUnit.Nanodegree);
+        public T Nanodegrees => As(AngleUnit.Nanodegree);
 
         /// <summary>
-        ///     Get Angle in Nanoradians.
+        ///     Get <see cref="Angle{T}" /> in Nanoradians.
         /// </summary>
-        public double Nanoradians => As(AngleUnit.Nanoradian);
+        public T Nanoradians => As(AngleUnit.Nanoradian);
 
         /// <summary>
-        ///     Get Angle in Radians.
+        ///     Get <see cref="Angle{T}" /> in Radians.
         /// </summary>
-        public double Radians => As(AngleUnit.Radian);
+        public T Radians => As(AngleUnit.Radian);
 
         /// <summary>
-        ///     Get Angle in Revolutions.
+        ///     Get <see cref="Angle{T}" /> in Revolutions.
         /// </summary>
-        public double Revolutions => As(AngleUnit.Revolution);
+        public T Revolutions => As(AngleUnit.Revolution);
 
         #endregion
 
@@ -279,141 +277,127 @@ public static string GetAbbreviation(AngleUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Angle from Arcminutes.
+        ///     Get <see cref="Angle{T}" /> from Arcminutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromArcminutes(QuantityValue arcminutes)
+        public static Angle<T> FromArcminutes(T arcminutes)
         {
-            double value = (double) arcminutes;
-            return new Angle(value, AngleUnit.Arcminute);
+            return new Angle<T>(arcminutes, AngleUnit.Arcminute);
         }
         /// <summary>
-        ///     Get Angle from Arcseconds.
+        ///     Get <see cref="Angle{T}" /> from Arcseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromArcseconds(QuantityValue arcseconds)
+        public static Angle<T> FromArcseconds(T arcseconds)
         {
-            double value = (double) arcseconds;
-            return new Angle(value, AngleUnit.Arcsecond);
+            return new Angle<T>(arcseconds, AngleUnit.Arcsecond);
         }
         /// <summary>
-        ///     Get Angle from Centiradians.
+        ///     Get <see cref="Angle{T}" /> from Centiradians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromCentiradians(QuantityValue centiradians)
+        public static Angle<T> FromCentiradians(T centiradians)
         {
-            double value = (double) centiradians;
-            return new Angle(value, AngleUnit.Centiradian);
+            return new Angle<T>(centiradians, AngleUnit.Centiradian);
         }
         /// <summary>
-        ///     Get Angle from Deciradians.
+        ///     Get <see cref="Angle{T}" /> from Deciradians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromDeciradians(QuantityValue deciradians)
+        public static Angle<T> FromDeciradians(T deciradians)
         {
-            double value = (double) deciradians;
-            return new Angle(value, AngleUnit.Deciradian);
+            return new Angle<T>(deciradians, AngleUnit.Deciradian);
         }
         /// <summary>
-        ///     Get Angle from Degrees.
+        ///     Get <see cref="Angle{T}" /> from Degrees.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromDegrees(QuantityValue degrees)
+        public static Angle<T> FromDegrees(T degrees)
         {
-            double value = (double) degrees;
-            return new Angle(value, AngleUnit.Degree);
+            return new Angle<T>(degrees, AngleUnit.Degree);
         }
         /// <summary>
-        ///     Get Angle from Gradians.
+        ///     Get <see cref="Angle{T}" /> from Gradians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromGradians(QuantityValue gradians)
+        public static Angle<T> FromGradians(T gradians)
         {
-            double value = (double) gradians;
-            return new Angle(value, AngleUnit.Gradian);
+            return new Angle<T>(gradians, AngleUnit.Gradian);
         }
         /// <summary>
-        ///     Get Angle from Microdegrees.
+        ///     Get <see cref="Angle{T}" /> from Microdegrees.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMicrodegrees(QuantityValue microdegrees)
+        public static Angle<T> FromMicrodegrees(T microdegrees)
         {
-            double value = (double) microdegrees;
-            return new Angle(value, AngleUnit.Microdegree);
+            return new Angle<T>(microdegrees, AngleUnit.Microdegree);
         }
         /// <summary>
-        ///     Get Angle from Microradians.
+        ///     Get <see cref="Angle{T}" /> from Microradians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMicroradians(QuantityValue microradians)
+        public static Angle<T> FromMicroradians(T microradians)
         {
-            double value = (double) microradians;
-            return new Angle(value, AngleUnit.Microradian);
+            return new Angle<T>(microradians, AngleUnit.Microradian);
         }
         /// <summary>
-        ///     Get Angle from Millidegrees.
+        ///     Get <see cref="Angle{T}" /> from Millidegrees.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMillidegrees(QuantityValue millidegrees)
+        public static Angle<T> FromMillidegrees(T millidegrees)
         {
-            double value = (double) millidegrees;
-            return new Angle(value, AngleUnit.Millidegree);
+            return new Angle<T>(millidegrees, AngleUnit.Millidegree);
         }
         /// <summary>
-        ///     Get Angle from Milliradians.
+        ///     Get <see cref="Angle{T}" /> from Milliradians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMilliradians(QuantityValue milliradians)
+        public static Angle<T> FromMilliradians(T milliradians)
         {
-            double value = (double) milliradians;
-            return new Angle(value, AngleUnit.Milliradian);
+            return new Angle<T>(milliradians, AngleUnit.Milliradian);
         }
         /// <summary>
-        ///     Get Angle from Nanodegrees.
+        ///     Get <see cref="Angle{T}" /> from Nanodegrees.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNanodegrees(QuantityValue nanodegrees)
+        public static Angle<T> FromNanodegrees(T nanodegrees)
         {
-            double value = (double) nanodegrees;
-            return new Angle(value, AngleUnit.Nanodegree);
+            return new Angle<T>(nanodegrees, AngleUnit.Nanodegree);
         }
         /// <summary>
-        ///     Get Angle from Nanoradians.
+        ///     Get <see cref="Angle{T}" /> from Nanoradians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNanoradians(QuantityValue nanoradians)
+        public static Angle<T> FromNanoradians(T nanoradians)
         {
-            double value = (double) nanoradians;
-            return new Angle(value, AngleUnit.Nanoradian);
+            return new Angle<T>(nanoradians, AngleUnit.Nanoradian);
         }
         /// <summary>
-        ///     Get Angle from Radians.
+        ///     Get <see cref="Angle{T}" /> from Radians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromRadians(QuantityValue radians)
+        public static Angle<T> FromRadians(T radians)
         {
-            double value = (double) radians;
-            return new Angle(value, AngleUnit.Radian);
+            return new Angle<T>(radians, AngleUnit.Radian);
         }
         /// <summary>
-        ///     Get Angle from Revolutions.
+        ///     Get <see cref="Angle{T}" /> from Revolutions.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromRevolutions(QuantityValue revolutions)
+        public static Angle<T> FromRevolutions(T revolutions)
         {
-            double value = (double) revolutions;
-            return new Angle(value, AngleUnit.Revolution);
+            return new Angle<T>(revolutions, AngleUnit.Revolution);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AngleUnit" /> to <see cref="Angle" />.
+        ///     Dynamically convert from value and unit enum <see cref="AngleUnit" /> to <see cref="Angle{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Angle unit value.</returns>
-        public static Angle From(QuantityValue value, AngleUnit fromUnit)
+        /// <returns><see cref="Angle{T}" /> unit value.</returns>
+        public static Angle<T> From(T value, AngleUnit fromUnit)
         {
-            return new Angle((double)value, fromUnit);
+            return new Angle<T>(value, fromUnit);
         }
 
         #endregion
@@ -442,7 +426,7 @@ public static Angle From(QuantityValue value, AngleUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Angle Parse(string str)
+        public static Angle<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -470,9 +454,9 @@ public static Angle Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Angle Parse(string str, IFormatProvider? provider)
+        public static Angle<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Angle, AngleUnit>(
+            return QuantityParser.Default.Parse<T, Angle<T>, AngleUnit>(
                 str,
                 provider,
                 From);
@@ -486,7 +470,7 @@ public static Angle Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Angle result)
+        public static bool TryParse(string? str, out Angle<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -501,9 +485,9 @@ public static bool TryParse(string? str, out Angle result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Angle result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Angle<T> result)
         {
-            return QuantityParser.Default.TryParse<Angle, AngleUnit>(
+            return QuantityParser.Default.TryParse<T, Angle<T>, AngleUnit>(
                 str,
                 provider,
                 From,
@@ -565,45 +549,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Angle
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Angle operator -(Angle right)
+        public static Angle<T> operator -(Angle<T> right)
         {
-            return new Angle(-right.Value, right.Unit);
+            return new Angle<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Angle"/> from adding two <see cref="Angle"/>.</summary>
-        public static Angle operator +(Angle left, Angle right)
+        /// <summary>Get <see cref="Angle{T}"/> from adding two <see cref="Angle{T}"/>.</summary>
+        public static Angle<T> operator +(Angle<T> left, Angle<T> right)
         {
-            return new Angle(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Angle<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Angle"/> from subtracting two <see cref="Angle"/>.</summary>
-        public static Angle operator -(Angle left, Angle right)
+        /// <summary>Get <see cref="Angle{T}"/> from subtracting two <see cref="Angle{T}"/>.</summary>
+        public static Angle<T> operator -(Angle<T> left, Angle<T> right)
         {
-            return new Angle(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Angle<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Angle"/> from multiplying value and <see cref="Angle"/>.</summary>
-        public static Angle operator *(double left, Angle right)
+        /// <summary>Get <see cref="Angle{T}"/> from multiplying value and <see cref="Angle{T}"/>.</summary>
+        public static Angle<T> operator *(T left, Angle<T> right)
         {
-            return new Angle(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Angle<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Angle"/> from multiplying value and <see cref="Angle"/>.</summary>
-        public static Angle operator *(Angle left, double right)
+        /// <summary>Get <see cref="Angle{T}"/> from multiplying value and <see cref="Angle{T}"/>.</summary>
+        public static Angle<T> operator *(Angle<T> left, T right)
         {
-            return new Angle(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Angle<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Angle"/> from dividing <see cref="Angle"/> by value.</summary>
-        public static Angle operator /(Angle left, double right)
+        /// <summary>Get <see cref="Angle{T}"/> from dividing <see cref="Angle{T}"/> by value.</summary>
+        public static Angle<T> operator /(Angle<T> left, T right)
         {
-            return new Angle(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Angle<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Angle"/> by <see cref="Angle"/>.</summary>
-        public static double operator /(Angle left, Angle right)
+        /// <summary>Get ratio value from dividing <see cref="Angle{T}"/> by <see cref="Angle{T}"/>.</summary>
+        public static T operator /(Angle<T> left, Angle<T> right)
         {
-            return left.Degrees / right.Degrees;
+            return CompiledLambdas.Divide(left.Degrees, right.Degrees);
         }
 
         #endregion
@@ -611,39 +600,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Angle
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Angle left, Angle right)
+        public static bool operator <=(Angle<T> left, Angle<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Angle left, Angle right)
+        public static bool operator >=(Angle<T> left, Angle<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Angle left, Angle right)
+        public static bool operator <(Angle<T> left, Angle<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Angle left, Angle right)
+        public static bool operator >(Angle<T> left, Angle<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Angle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Angle left, Angle right)
+        /// <remarks>Consider using <see cref="Equals(Angle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Angle<T> left, Angle<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Angle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Angle left, Angle right)
+        /// <remarks>Consider using <see cref="Equals(Angle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Angle<T> left, Angle<T> right)
         {
             return !(left == right);
         }
@@ -652,37 +641,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Angle
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Angle objAngle)) throw new ArgumentException("Expected type Angle.", nameof(obj));
+            if(!(obj is Angle<T> objAngle)) throw new ArgumentException("Expected type Angle.", nameof(obj));
 
             return CompareTo(objAngle);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Angle other)
+        public int CompareTo(Angle<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Angle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Angle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Angle objAngle))
+            if(obj is null || !(obj is Angle<T> objAngle))
                 return false;
 
             return Equals(objAngle);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Angle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Angle other)
+        /// <remarks>Consider using <see cref="Equals(Angle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Angle<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Angle within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Angle{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -720,21 +709,19 @@ public bool Equals(Angle other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Angle other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Angle<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Angle.</returns>
+        /// <returns>A hash code for the current <see cref="Angle{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -748,17 +735,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(AngleUnit unit)
+        public T As(AngleUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -778,17 +765,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is AngleUnit unitAsAngleUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AngleUnit)} is supported.", nameof(unit));
 
-            return As(unitAsAngleUnit);
+            var asValue = As(unitAsAngleUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<AngleUnit>.As(AngleUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Angle to another Angle with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Angle{T}" /> to another <see cref="Angle{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Angle with the specified unit.</returns>
-        public Angle ToUnit(AngleUnit unit)
+        /// <returns>A <see cref="Angle{T}" /> with the specified unit.</returns>
+        public Angle<T> ToUnit(AngleUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Angle(convertedValue, unit);
+            return new Angle<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -801,7 +793,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Angle ToUnit(UnitSystem unitSystem)
+        public Angle<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -821,32 +813,38 @@ public Angle ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AngleUnit> IQuantity<AngleUnit>.ToUnit(AngleUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<AngleUnit, T> IQuantityT<AngleUnit, T>.ToUnit(AngleUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<AngleUnit> IQuantity<AngleUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<AngleUnit, T> IQuantityT<AngleUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case AngleUnit.Arcminute: return _value/60;
-                case AngleUnit.Arcsecond: return _value/3600;
-                case AngleUnit.Centiradian: return (_value*180/Math.PI) * 1e-2d;
-                case AngleUnit.Deciradian: return (_value*180/Math.PI) * 1e-1d;
-                case AngleUnit.Degree: return _value;
-                case AngleUnit.Gradian: return _value*0.9;
-                case AngleUnit.Microdegree: return (_value) * 1e-6d;
-                case AngleUnit.Microradian: return (_value*180/Math.PI) * 1e-6d;
-                case AngleUnit.Millidegree: return (_value) * 1e-3d;
-                case AngleUnit.Milliradian: return (_value*180/Math.PI) * 1e-3d;
-                case AngleUnit.Nanodegree: return (_value) * 1e-9d;
-                case AngleUnit.Nanoradian: return (_value*180/Math.PI) * 1e-9d;
-                case AngleUnit.Radian: return _value*180/Math.PI;
-                case AngleUnit.Revolution: return _value*360;
+                case AngleUnit.Arcminute: return Value/60;
+                case AngleUnit.Arcsecond: return Value/3600;
+                case AngleUnit.Centiradian: return (Value*180/Math.PI) * 1e-2d;
+                case AngleUnit.Deciradian: return (Value*180/Math.PI) * 1e-1d;
+                case AngleUnit.Degree: return Value;
+                case AngleUnit.Gradian: return Value*0.9;
+                case AngleUnit.Microdegree: return (Value) * 1e-6d;
+                case AngleUnit.Microradian: return (Value*180/Math.PI) * 1e-6d;
+                case AngleUnit.Millidegree: return (Value) * 1e-3d;
+                case AngleUnit.Milliradian: return (Value*180/Math.PI) * 1e-3d;
+                case AngleUnit.Nanodegree: return (Value) * 1e-9d;
+                case AngleUnit.Nanoradian: return (Value*180/Math.PI) * 1e-9d;
+                case AngleUnit.Radian: return Value*180/Math.PI;
+                case AngleUnit.Revolution: return Value*360;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -857,16 +855,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Angle ToBaseUnit()
+        internal Angle<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Angle(baseUnitValue, BaseUnit);
+            return new Angle<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(AngleUnit unit)
+        private T GetValueAs(AngleUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -982,57 +980,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Angle)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Angle<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Angle)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Angle<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Angle)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Angle<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1042,33 +1040,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Angle))
+            if(conversionType == typeof(Angle<T>))
                 return this;
             else if(conversionType == typeof(AngleUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Angle.QuantityType;
+                return Angle<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Angle.Info;
+                return Angle<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Angle.BaseDimensions;
+                return Angle<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Angle)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Angle<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
index 071b53dfdd..b4567ea2df 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     A unit for expressing the integral of apparent power over time, equal to the product of 1 volt-ampere and 1 hour, or to 3600 joules.
     /// </summary>
-    public partial struct ApparentEnergy : IQuantity<ApparentEnergyUnit>, IEquatable<ApparentEnergy>, IComparable, IComparable<ApparentEnergy>, IConvertible, IFormattable
+    public partial struct ApparentEnergy<T> : IQuantityT<ApparentEnergyUnit, T>, IEquatable<ApparentEnergy<T>>, IComparable, IComparable<ApparentEnergy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static ApparentEnergy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ApparentEnergy(double value, ApparentEnergyUnit unit)
+        public ApparentEnergy(T value, ApparentEnergyUnit unit)
         {
             if(unit == ApparentEnergyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public ApparentEnergy(double value, ApparentEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ApparentEnergy(double value, UnitSystem unitSystem)
+        public ApparentEnergy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public ApparentEnergy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ApparentEnergy, which is VoltampereHour. All conversions go via this value.
+        ///     The base unit of <see cref="ApparentEnergy{T}" />, which is VoltampereHour. All conversions go via this value.
         /// </summary>
         public static ApparentEnergyUnit BaseUnit { get; } = ApparentEnergyUnit.VoltampereHour;
 
         /// <summary>
-        /// Represents the largest possible value of ApparentEnergy
+        /// Represents the largest possible value of <see cref="ApparentEnergy{T}" />
         /// </summary>
-        public static ApparentEnergy MaxValue { get; } = new ApparentEnergy(double.MaxValue, BaseUnit);
+        public static ApparentEnergy<T> MaxValue { get; } = new ApparentEnergy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ApparentEnergy
+        /// Represents the smallest possible value of <see cref="ApparentEnergy{T}" />
         /// </summary>
-        public static ApparentEnergy MinValue { get; } = new ApparentEnergy(double.MinValue, BaseUnit);
+        public static ApparentEnergy<T> MinValue { get; } = new ApparentEnergy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public ApparentEnergy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ApparentEnergy;
 
         /// <summary>
-        ///     All units of measurement for the ApparentEnergy quantity.
+        ///     All units of measurement for the <see cref="ApparentEnergy{T}" /> quantity.
         /// </summary>
         public static ApparentEnergyUnit[] Units { get; } = Enum.GetValues(typeof(ApparentEnergyUnit)).Cast<ApparentEnergyUnit>().Except(new ApparentEnergyUnit[]{ ApparentEnergyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit VoltampereHour.
         /// </summary>
-        public static ApparentEnergy Zero { get; } = new ApparentEnergy(0, BaseUnit);
+        public static ApparentEnergy<T> Zero { get; } = new ApparentEnergy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public ApparentEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public ApparentEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ApparentEnergy.QuantityType;
+        public QuantityType Type => ApparentEnergy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ApparentEnergy.BaseDimensions;
+        public BaseDimensions Dimensions => ApparentEnergy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ApparentEnergy in KilovoltampereHours.
+        ///     Get <see cref="ApparentEnergy{T}" /> in KilovoltampereHours.
         /// </summary>
-        public double KilovoltampereHours => As(ApparentEnergyUnit.KilovoltampereHour);
+        public T KilovoltampereHours => As(ApparentEnergyUnit.KilovoltampereHour);
 
         /// <summary>
-        ///     Get ApparentEnergy in MegavoltampereHours.
+        ///     Get <see cref="ApparentEnergy{T}" /> in MegavoltampereHours.
         /// </summary>
-        public double MegavoltampereHours => As(ApparentEnergyUnit.MegavoltampereHour);
+        public T MegavoltampereHours => As(ApparentEnergyUnit.MegavoltampereHour);
 
         /// <summary>
-        ///     Get ApparentEnergy in VoltampereHours.
+        ///     Get <see cref="ApparentEnergy{T}" /> in VoltampereHours.
         /// </summary>
-        public double VoltampereHours => As(ApparentEnergyUnit.VoltampereHour);
+        public T VoltampereHours => As(ApparentEnergyUnit.VoltampereHour);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(ApparentEnergyUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ApparentEnergy from KilovoltampereHours.
+        ///     Get <see cref="ApparentEnergy{T}" /> from KilovoltampereHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromKilovoltampereHours(QuantityValue kilovoltamperehours)
+        public static ApparentEnergy<T> FromKilovoltampereHours(T kilovoltamperehours)
         {
-            double value = (double) kilovoltamperehours;
-            return new ApparentEnergy(value, ApparentEnergyUnit.KilovoltampereHour);
+            return new ApparentEnergy<T>(kilovoltamperehours, ApparentEnergyUnit.KilovoltampereHour);
         }
         /// <summary>
-        ///     Get ApparentEnergy from MegavoltampereHours.
+        ///     Get <see cref="ApparentEnergy{T}" /> from MegavoltampereHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromMegavoltampereHours(QuantityValue megavoltamperehours)
+        public static ApparentEnergy<T> FromMegavoltampereHours(T megavoltamperehours)
         {
-            double value = (double) megavoltamperehours;
-            return new ApparentEnergy(value, ApparentEnergyUnit.MegavoltampereHour);
+            return new ApparentEnergy<T>(megavoltamperehours, ApparentEnergyUnit.MegavoltampereHour);
         }
         /// <summary>
-        ///     Get ApparentEnergy from VoltampereHours.
+        ///     Get <see cref="ApparentEnergy{T}" /> from VoltampereHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromVoltampereHours(QuantityValue voltamperehours)
+        public static ApparentEnergy<T> FromVoltampereHours(T voltamperehours)
         {
-            double value = (double) voltamperehours;
-            return new ApparentEnergy(value, ApparentEnergyUnit.VoltampereHour);
+            return new ApparentEnergy<T>(voltamperehours, ApparentEnergyUnit.VoltampereHour);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ApparentEnergyUnit" /> to <see cref="ApparentEnergy" />.
+        ///     Dynamically convert from value and unit enum <see cref="ApparentEnergyUnit" /> to <see cref="ApparentEnergy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ApparentEnergy unit value.</returns>
-        public static ApparentEnergy From(QuantityValue value, ApparentEnergyUnit fromUnit)
+        /// <returns><see cref="ApparentEnergy{T}" /> unit value.</returns>
+        public static ApparentEnergy<T> From(T value, ApparentEnergyUnit fromUnit)
         {
-            return new ApparentEnergy((double)value, fromUnit);
+            return new ApparentEnergy<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static ApparentEnergy From(QuantityValue value, ApparentEnergyUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ApparentEnergy Parse(string str)
+        public static ApparentEnergy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static ApparentEnergy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ApparentEnergy Parse(string str, IFormatProvider? provider)
+        public static ApparentEnergy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ApparentEnergy, ApparentEnergyUnit>(
+            return QuantityParser.Default.Parse<T, ApparentEnergy<T>, ApparentEnergyUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static ApparentEnergy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ApparentEnergy result)
+        public static bool TryParse(string? str, out ApparentEnergy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out ApparentEnergy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ApparentEnergy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ApparentEnergy<T> result)
         {
-            return QuantityParser.Default.TryParse<ApparentEnergy, ApparentEnergyUnit>(
+            return QuantityParser.Default.TryParse<T, ApparentEnergy<T>, ApparentEnergyUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Appar
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ApparentEnergy operator -(ApparentEnergy right)
+        public static ApparentEnergy<T> operator -(ApparentEnergy<T> right)
         {
-            return new ApparentEnergy(-right.Value, right.Unit);
+            return new ApparentEnergy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentEnergy"/> from adding two <see cref="ApparentEnergy"/>.</summary>
-        public static ApparentEnergy operator +(ApparentEnergy left, ApparentEnergy right)
+        /// <summary>Get <see cref="ApparentEnergy{T}"/> from adding two <see cref="ApparentEnergy{T}"/>.</summary>
+        public static ApparentEnergy<T> operator +(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
-            return new ApparentEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ApparentEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentEnergy"/> from subtracting two <see cref="ApparentEnergy"/>.</summary>
-        public static ApparentEnergy operator -(ApparentEnergy left, ApparentEnergy right)
+        /// <summary>Get <see cref="ApparentEnergy{T}"/> from subtracting two <see cref="ApparentEnergy{T}"/>.</summary>
+        public static ApparentEnergy<T> operator -(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
-            return new ApparentEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ApparentEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentEnergy"/> from multiplying value and <see cref="ApparentEnergy"/>.</summary>
-        public static ApparentEnergy operator *(double left, ApparentEnergy right)
+        /// <summary>Get <see cref="ApparentEnergy{T}"/> from multiplying value and <see cref="ApparentEnergy{T}"/>.</summary>
+        public static ApparentEnergy<T> operator *(T left, ApparentEnergy<T> right)
         {
-            return new ApparentEnergy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ApparentEnergy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentEnergy"/> from multiplying value and <see cref="ApparentEnergy"/>.</summary>
-        public static ApparentEnergy operator *(ApparentEnergy left, double right)
+        /// <summary>Get <see cref="ApparentEnergy{T}"/> from multiplying value and <see cref="ApparentEnergy{T}"/>.</summary>
+        public static ApparentEnergy<T> operator *(ApparentEnergy<T> left, T right)
         {
-            return new ApparentEnergy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ApparentEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentEnergy"/> from dividing <see cref="ApparentEnergy"/> by value.</summary>
-        public static ApparentEnergy operator /(ApparentEnergy left, double right)
+        /// <summary>Get <see cref="ApparentEnergy{T}"/> from dividing <see cref="ApparentEnergy{T}"/> by value.</summary>
+        public static ApparentEnergy<T> operator /(ApparentEnergy<T> left, T right)
         {
-            return new ApparentEnergy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ApparentEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ApparentEnergy"/> by <see cref="ApparentEnergy"/>.</summary>
-        public static double operator /(ApparentEnergy left, ApparentEnergy right)
+        /// <summary>Get ratio value from dividing <see cref="ApparentEnergy{T}"/> by <see cref="ApparentEnergy{T}"/>.</summary>
+        public static T operator /(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
-            return left.VoltampereHours / right.VoltampereHours;
+            return CompiledLambdas.Divide(left.VoltampereHours, right.VoltampereHours);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Appar
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ApparentEnergy left, ApparentEnergy right)
+        public static bool operator <=(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ApparentEnergy left, ApparentEnergy right)
+        public static bool operator >=(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ApparentEnergy left, ApparentEnergy right)
+        public static bool operator <(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ApparentEnergy left, ApparentEnergy right)
+        public static bool operator >(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ApparentEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ApparentEnergy left, ApparentEnergy right)
+        /// <remarks>Consider using <see cref="Equals(ApparentEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ApparentEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ApparentEnergy left, ApparentEnergy right)
+        /// <remarks>Consider using <see cref="Equals(ApparentEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ApparentEnergy<T> left, ApparentEnergy<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Appar
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ApparentEnergy objApparentEnergy)) throw new ArgumentException("Expected type ApparentEnergy.", nameof(obj));
+            if(!(obj is ApparentEnergy<T> objApparentEnergy)) throw new ArgumentException("Expected type ApparentEnergy.", nameof(obj));
 
             return CompareTo(objApparentEnergy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ApparentEnergy other)
+        public int CompareTo(ApparentEnergy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ApparentEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ApparentEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ApparentEnergy objApparentEnergy))
+            if(obj is null || !(obj is ApparentEnergy<T> objApparentEnergy))
                 return false;
 
             return Equals(objApparentEnergy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ApparentEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ApparentEnergy other)
+        /// <remarks>Consider using <see cref="Equals(ApparentEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ApparentEnergy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ApparentEnergy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ApparentEnergy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(ApparentEnergy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ApparentEnergy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ApparentEnergy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ApparentEnergy.</returns>
+        /// <returns>A hash code for the current <see cref="ApparentEnergy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ApparentEnergyUnit unit)
+        public T As(ApparentEnergyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ApparentEnergyUnit unitAsApparentEnergyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentEnergyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsApparentEnergyUnit);
+            var asValue = As(unitAsApparentEnergyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ApparentEnergyUnit>.As(ApparentEnergyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ApparentEnergy to another ApparentEnergy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ApparentEnergy{T}" /> to another <see cref="ApparentEnergy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ApparentEnergy with the specified unit.</returns>
-        public ApparentEnergy ToUnit(ApparentEnergyUnit unit)
+        /// <returns>A <see cref="ApparentEnergy{T}" /> with the specified unit.</returns>
+        public ApparentEnergy<T> ToUnit(ApparentEnergyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ApparentEnergy(convertedValue, unit);
+            return new ApparentEnergy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ApparentEnergy ToUnit(UnitSystem unitSystem)
+        public ApparentEnergy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public ApparentEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ApparentEnergyUnit> IQuantity<ApparentEnergyUnit>.ToUnit(ApparentEnergyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ApparentEnergyUnit, T> IQuantityT<ApparentEnergyUnit, T>.ToUnit(ApparentEnergyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ApparentEnergyUnit> IQuantity<ApparentEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ApparentEnergyUnit, T> IQuantityT<ApparentEnergyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ApparentEnergyUnit.KilovoltampereHour: return (_value) * 1e3d;
-                case ApparentEnergyUnit.MegavoltampereHour: return (_value) * 1e6d;
-                case ApparentEnergyUnit.VoltampereHour: return _value;
+                case ApparentEnergyUnit.KilovoltampereHour: return (Value) * 1e3d;
+                case ApparentEnergyUnit.MegavoltampereHour: return (Value) * 1e6d;
+                case ApparentEnergyUnit.VoltampereHour: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ApparentEnergy ToBaseUnit()
+        internal ApparentEnergy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ApparentEnergy(baseUnitValue, BaseUnit);
+            return new ApparentEnergy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ApparentEnergyUnit unit)
+        private T GetValueAs(ApparentEnergyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ApparentEnergy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ApparentEnergy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ApparentEnergy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ApparentEnergy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ApparentEnergy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ApparentEnergy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ApparentEnergy))
+            if(conversionType == typeof(ApparentEnergy<T>))
                 return this;
             else if(conversionType == typeof(ApparentEnergyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ApparentEnergy.QuantityType;
+                return ApparentEnergy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ApparentEnergy.Info;
+                return ApparentEnergy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ApparentEnergy.BaseDimensions;
+                return ApparentEnergy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ApparentEnergy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ApparentEnergy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
index 62da56ef09..27320b92ef 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Power engineers measure apparent power as the magnitude of the vector sum of active and reactive power. Apparent power is the product of the root-mean-square of voltage and current.
     /// </summary>
-    public partial struct ApparentPower : IQuantity<ApparentPowerUnit>, IEquatable<ApparentPower>, IComparable, IComparable<ApparentPower>, IConvertible, IFormattable
+    public partial struct ApparentPower<T> : IQuantityT<ApparentPowerUnit, T>, IEquatable<ApparentPower<T>>, IComparable, IComparable<ApparentPower<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static ApparentPower()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ApparentPower(double value, ApparentPowerUnit unit)
+        public ApparentPower(T value, ApparentPowerUnit unit)
         {
             if(unit == ApparentPowerUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public ApparentPower(double value, ApparentPowerUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ApparentPower(double value, UnitSystem unitSystem)
+        public ApparentPower(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public ApparentPower(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ApparentPower, which is Voltampere. All conversions go via this value.
+        ///     The base unit of <see cref="ApparentPower{T}" />, which is Voltampere. All conversions go via this value.
         /// </summary>
         public static ApparentPowerUnit BaseUnit { get; } = ApparentPowerUnit.Voltampere;
 
         /// <summary>
-        /// Represents the largest possible value of ApparentPower
+        /// Represents the largest possible value of <see cref="ApparentPower{T}" />
         /// </summary>
-        public static ApparentPower MaxValue { get; } = new ApparentPower(double.MaxValue, BaseUnit);
+        public static ApparentPower<T> MaxValue { get; } = new ApparentPower<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ApparentPower
+        /// Represents the smallest possible value of <see cref="ApparentPower{T}" />
         /// </summary>
-        public static ApparentPower MinValue { get; } = new ApparentPower(double.MinValue, BaseUnit);
+        public static ApparentPower<T> MinValue { get; } = new ApparentPower<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public ApparentPower(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ApparentPower;
 
         /// <summary>
-        ///     All units of measurement for the ApparentPower quantity.
+        ///     All units of measurement for the <see cref="ApparentPower{T}" /> quantity.
         /// </summary>
         public static ApparentPowerUnit[] Units { get; } = Enum.GetValues(typeof(ApparentPowerUnit)).Cast<ApparentPowerUnit>().Except(new ApparentPowerUnit[]{ ApparentPowerUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Voltampere.
         /// </summary>
-        public static ApparentPower Zero { get; } = new ApparentPower(0, BaseUnit);
+        public static ApparentPower<T> Zero { get; } = new ApparentPower<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public ApparentPower(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,36 +156,36 @@ public ApparentPower(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ApparentPower.QuantityType;
+        public QuantityType Type => ApparentPower<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ApparentPower.BaseDimensions;
+        public BaseDimensions Dimensions => ApparentPower<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ApparentPower in Gigavoltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> in Gigavoltamperes.
         /// </summary>
-        public double Gigavoltamperes => As(ApparentPowerUnit.Gigavoltampere);
+        public T Gigavoltamperes => As(ApparentPowerUnit.Gigavoltampere);
 
         /// <summary>
-        ///     Get ApparentPower in Kilovoltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> in Kilovoltamperes.
         /// </summary>
-        public double Kilovoltamperes => As(ApparentPowerUnit.Kilovoltampere);
+        public T Kilovoltamperes => As(ApparentPowerUnit.Kilovoltampere);
 
         /// <summary>
-        ///     Get ApparentPower in Megavoltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> in Megavoltamperes.
         /// </summary>
-        public double Megavoltamperes => As(ApparentPowerUnit.Megavoltampere);
+        public T Megavoltamperes => As(ApparentPowerUnit.Megavoltampere);
 
         /// <summary>
-        ///     Get ApparentPower in Voltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> in Voltamperes.
         /// </summary>
-        public double Voltamperes => As(ApparentPowerUnit.Voltampere);
+        public T Voltamperes => As(ApparentPowerUnit.Voltampere);
 
         #endregion
 
@@ -219,51 +217,47 @@ public static string GetAbbreviation(ApparentPowerUnit unit, IFormatProvider? pr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ApparentPower from Gigavoltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> from Gigavoltamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromGigavoltamperes(QuantityValue gigavoltamperes)
+        public static ApparentPower<T> FromGigavoltamperes(T gigavoltamperes)
         {
-            double value = (double) gigavoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Gigavoltampere);
+            return new ApparentPower<T>(gigavoltamperes, ApparentPowerUnit.Gigavoltampere);
         }
         /// <summary>
-        ///     Get ApparentPower from Kilovoltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> from Kilovoltamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromKilovoltamperes(QuantityValue kilovoltamperes)
+        public static ApparentPower<T> FromKilovoltamperes(T kilovoltamperes)
         {
-            double value = (double) kilovoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Kilovoltampere);
+            return new ApparentPower<T>(kilovoltamperes, ApparentPowerUnit.Kilovoltampere);
         }
         /// <summary>
-        ///     Get ApparentPower from Megavoltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> from Megavoltamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromMegavoltamperes(QuantityValue megavoltamperes)
+        public static ApparentPower<T> FromMegavoltamperes(T megavoltamperes)
         {
-            double value = (double) megavoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Megavoltampere);
+            return new ApparentPower<T>(megavoltamperes, ApparentPowerUnit.Megavoltampere);
         }
         /// <summary>
-        ///     Get ApparentPower from Voltamperes.
+        ///     Get <see cref="ApparentPower{T}" /> from Voltamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromVoltamperes(QuantityValue voltamperes)
+        public static ApparentPower<T> FromVoltamperes(T voltamperes)
         {
-            double value = (double) voltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Voltampere);
+            return new ApparentPower<T>(voltamperes, ApparentPowerUnit.Voltampere);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ApparentPowerUnit" /> to <see cref="ApparentPower" />.
+        ///     Dynamically convert from value and unit enum <see cref="ApparentPowerUnit" /> to <see cref="ApparentPower{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ApparentPower unit value.</returns>
-        public static ApparentPower From(QuantityValue value, ApparentPowerUnit fromUnit)
+        /// <returns><see cref="ApparentPower{T}" /> unit value.</returns>
+        public static ApparentPower<T> From(T value, ApparentPowerUnit fromUnit)
         {
-            return new ApparentPower((double)value, fromUnit);
+            return new ApparentPower<T>(value, fromUnit);
         }
 
         #endregion
@@ -292,7 +286,7 @@ public static ApparentPower From(QuantityValue value, ApparentPowerUnit fromUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ApparentPower Parse(string str)
+        public static ApparentPower<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -320,9 +314,9 @@ public static ApparentPower Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ApparentPower Parse(string str, IFormatProvider? provider)
+        public static ApparentPower<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ApparentPower, ApparentPowerUnit>(
+            return QuantityParser.Default.Parse<T, ApparentPower<T>, ApparentPowerUnit>(
                 str,
                 provider,
                 From);
@@ -336,7 +330,7 @@ public static ApparentPower Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ApparentPower result)
+        public static bool TryParse(string? str, out ApparentPower<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -351,9 +345,9 @@ public static bool TryParse(string? str, out ApparentPower result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ApparentPower result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ApparentPower<T> result)
         {
-            return QuantityParser.Default.TryParse<ApparentPower, ApparentPowerUnit>(
+            return QuantityParser.Default.TryParse<T, ApparentPower<T>, ApparentPowerUnit>(
                 str,
                 provider,
                 From,
@@ -415,45 +409,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Appar
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ApparentPower operator -(ApparentPower right)
+        public static ApparentPower<T> operator -(ApparentPower<T> right)
         {
-            return new ApparentPower(-right.Value, right.Unit);
+            return new ApparentPower<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentPower"/> from adding two <see cref="ApparentPower"/>.</summary>
-        public static ApparentPower operator +(ApparentPower left, ApparentPower right)
+        /// <summary>Get <see cref="ApparentPower{T}"/> from adding two <see cref="ApparentPower{T}"/>.</summary>
+        public static ApparentPower<T> operator +(ApparentPower<T> left, ApparentPower<T> right)
         {
-            return new ApparentPower(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ApparentPower<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentPower"/> from subtracting two <see cref="ApparentPower"/>.</summary>
-        public static ApparentPower operator -(ApparentPower left, ApparentPower right)
+        /// <summary>Get <see cref="ApparentPower{T}"/> from subtracting two <see cref="ApparentPower{T}"/>.</summary>
+        public static ApparentPower<T> operator -(ApparentPower<T> left, ApparentPower<T> right)
         {
-            return new ApparentPower(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ApparentPower<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentPower"/> from multiplying value and <see cref="ApparentPower"/>.</summary>
-        public static ApparentPower operator *(double left, ApparentPower right)
+        /// <summary>Get <see cref="ApparentPower{T}"/> from multiplying value and <see cref="ApparentPower{T}"/>.</summary>
+        public static ApparentPower<T> operator *(T left, ApparentPower<T> right)
         {
-            return new ApparentPower(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ApparentPower<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentPower"/> from multiplying value and <see cref="ApparentPower"/>.</summary>
-        public static ApparentPower operator *(ApparentPower left, double right)
+        /// <summary>Get <see cref="ApparentPower{T}"/> from multiplying value and <see cref="ApparentPower{T}"/>.</summary>
+        public static ApparentPower<T> operator *(ApparentPower<T> left, T right)
         {
-            return new ApparentPower(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ApparentPower<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ApparentPower"/> from dividing <see cref="ApparentPower"/> by value.</summary>
-        public static ApparentPower operator /(ApparentPower left, double right)
+        /// <summary>Get <see cref="ApparentPower{T}"/> from dividing <see cref="ApparentPower{T}"/> by value.</summary>
+        public static ApparentPower<T> operator /(ApparentPower<T> left, T right)
         {
-            return new ApparentPower(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ApparentPower<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ApparentPower"/> by <see cref="ApparentPower"/>.</summary>
-        public static double operator /(ApparentPower left, ApparentPower right)
+        /// <summary>Get ratio value from dividing <see cref="ApparentPower{T}"/> by <see cref="ApparentPower{T}"/>.</summary>
+        public static T operator /(ApparentPower<T> left, ApparentPower<T> right)
         {
-            return left.Voltamperes / right.Voltamperes;
+            return CompiledLambdas.Divide(left.Voltamperes, right.Voltamperes);
         }
 
         #endregion
@@ -461,39 +460,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Appar
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ApparentPower left, ApparentPower right)
+        public static bool operator <=(ApparentPower<T> left, ApparentPower<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ApparentPower left, ApparentPower right)
+        public static bool operator >=(ApparentPower<T> left, ApparentPower<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ApparentPower left, ApparentPower right)
+        public static bool operator <(ApparentPower<T> left, ApparentPower<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ApparentPower left, ApparentPower right)
+        public static bool operator >(ApparentPower<T> left, ApparentPower<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ApparentPower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ApparentPower left, ApparentPower right)
+        /// <remarks>Consider using <see cref="Equals(ApparentPower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ApparentPower<T> left, ApparentPower<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ApparentPower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ApparentPower left, ApparentPower right)
+        /// <remarks>Consider using <see cref="Equals(ApparentPower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ApparentPower<T> left, ApparentPower<T> right)
         {
             return !(left == right);
         }
@@ -502,37 +501,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Appar
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ApparentPower objApparentPower)) throw new ArgumentException("Expected type ApparentPower.", nameof(obj));
+            if(!(obj is ApparentPower<T> objApparentPower)) throw new ArgumentException("Expected type ApparentPower.", nameof(obj));
 
             return CompareTo(objApparentPower);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ApparentPower other)
+        public int CompareTo(ApparentPower<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ApparentPower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ApparentPower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ApparentPower objApparentPower))
+            if(obj is null || !(obj is ApparentPower<T> objApparentPower))
                 return false;
 
             return Equals(objApparentPower);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ApparentPower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ApparentPower other)
+        /// <remarks>Consider using <see cref="Equals(ApparentPower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ApparentPower<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ApparentPower within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ApparentPower{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -570,21 +569,19 @@ public bool Equals(ApparentPower other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ApparentPower other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ApparentPower<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ApparentPower.</returns>
+        /// <returns>A hash code for the current <see cref="ApparentPower{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -598,17 +595,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ApparentPowerUnit unit)
+        public T As(ApparentPowerUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -628,17 +625,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ApparentPowerUnit unitAsApparentPowerUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentPowerUnit)} is supported.", nameof(unit));
 
-            return As(unitAsApparentPowerUnit);
+            var asValue = As(unitAsApparentPowerUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ApparentPowerUnit>.As(ApparentPowerUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ApparentPower to another ApparentPower with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ApparentPower{T}" /> to another <see cref="ApparentPower{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ApparentPower with the specified unit.</returns>
-        public ApparentPower ToUnit(ApparentPowerUnit unit)
+        /// <returns>A <see cref="ApparentPower{T}" /> with the specified unit.</returns>
+        public ApparentPower<T> ToUnit(ApparentPowerUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ApparentPower(convertedValue, unit);
+            return new ApparentPower<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -651,7 +653,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ApparentPower ToUnit(UnitSystem unitSystem)
+        public ApparentPower<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -671,22 +673,28 @@ public ApparentPower ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ApparentPowerUnit> IQuantity<ApparentPowerUnit>.ToUnit(ApparentPowerUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ApparentPowerUnit, T> IQuantityT<ApparentPowerUnit, T>.ToUnit(ApparentPowerUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ApparentPowerUnit> IQuantity<ApparentPowerUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ApparentPowerUnit, T> IQuantityT<ApparentPowerUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ApparentPowerUnit.Gigavoltampere: return (_value) * 1e9d;
-                case ApparentPowerUnit.Kilovoltampere: return (_value) * 1e3d;
-                case ApparentPowerUnit.Megavoltampere: return (_value) * 1e6d;
-                case ApparentPowerUnit.Voltampere: return _value;
+                case ApparentPowerUnit.Gigavoltampere: return (Value) * 1e9d;
+                case ApparentPowerUnit.Kilovoltampere: return (Value) * 1e3d;
+                case ApparentPowerUnit.Megavoltampere: return (Value) * 1e6d;
+                case ApparentPowerUnit.Voltampere: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -697,16 +705,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ApparentPower ToBaseUnit()
+        internal ApparentPower<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ApparentPower(baseUnitValue, BaseUnit);
+            return new ApparentPower<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ApparentPowerUnit unit)
+        private T GetValueAs(ApparentPowerUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -812,57 +820,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ApparentPower)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ApparentPower<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ApparentPower)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ApparentPower<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ApparentPower)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ApparentPower<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -872,33 +880,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ApparentPower))
+            if(conversionType == typeof(ApparentPower<T>))
                 return this;
             else if(conversionType == typeof(ApparentPowerUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ApparentPower.QuantityType;
+                return ApparentPower<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ApparentPower.Info;
+                return ApparentPower<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ApparentPower.BaseDimensions;
+                return ApparentPower<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ApparentPower)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ApparentPower<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
index 3c08afb818..498c86a5f1 100644
--- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Area is a quantity that expresses the extent of a two-dimensional surface or shape, or planar lamina, in the plane. Area can be understood as the amount of material with a given thickness that would be necessary to fashion a model of the shape, or the amount of paint necessary to cover the surface with a single coat.[1] It is the two-dimensional analog of the length of a curve (a one-dimensional concept) or the volume of a solid (a three-dimensional concept).
     /// </summary>
-    public partial struct Area : IQuantity<AreaUnit>, IEquatable<Area>, IComparable, IComparable<Area>, IConvertible, IFormattable
+    public partial struct Area<T> : IQuantityT<AreaUnit, T>, IEquatable<Area<T>>, IComparable, IComparable<Area<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -76,12 +72,12 @@ static Area()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Area(double value, AreaUnit unit)
+        public Area(T value, AreaUnit unit)
         {
             if(unit == AreaUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -93,14 +89,14 @@ public Area(double value, AreaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Area(double value, UnitSystem unitSystem)
+        public Area(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -115,19 +111,19 @@ public Area(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Area, which is SquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Area{T}" />, which is SquareMeter. All conversions go via this value.
         /// </summary>
         public static AreaUnit BaseUnit { get; } = AreaUnit.SquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Area
+        /// Represents the largest possible value of <see cref="Area{T}" />
         /// </summary>
-        public static Area MaxValue { get; } = new Area(double.MaxValue, BaseUnit);
+        public static Area<T> MaxValue { get; } = new Area<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Area
+        /// Represents the smallest possible value of <see cref="Area{T}" />
         /// </summary>
-        public static Area MinValue { get; } = new Area(double.MinValue, BaseUnit);
+        public static Area<T> MinValue { get; } = new Area<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -136,14 +132,14 @@ public Area(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Area;
 
         /// <summary>
-        ///     All units of measurement for the Area quantity.
+        ///     All units of measurement for the <see cref="Area{T}" /> quantity.
         /// </summary>
         public static AreaUnit[] Units { get; } = Enum.GetValues(typeof(AreaUnit)).Cast<AreaUnit>().Except(new AreaUnit[]{ AreaUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit SquareMeter.
         /// </summary>
-        public static Area Zero { get; } = new Area(0, BaseUnit);
+        public static Area<T> Zero { get; } = new Area<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -152,7 +148,9 @@ public Area(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -168,86 +166,86 @@ public Area(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Area.QuantityType;
+        public QuantityType Type => Area<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Area.BaseDimensions;
+        public BaseDimensions Dimensions => Area<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Area in Acres.
+        ///     Get <see cref="Area{T}" /> in Acres.
         /// </summary>
-        public double Acres => As(AreaUnit.Acre);
+        public T Acres => As(AreaUnit.Acre);
 
         /// <summary>
-        ///     Get Area in Hectares.
+        ///     Get <see cref="Area{T}" /> in Hectares.
         /// </summary>
-        public double Hectares => As(AreaUnit.Hectare);
+        public T Hectares => As(AreaUnit.Hectare);
 
         /// <summary>
-        ///     Get Area in SquareCentimeters.
+        ///     Get <see cref="Area{T}" /> in SquareCentimeters.
         /// </summary>
-        public double SquareCentimeters => As(AreaUnit.SquareCentimeter);
+        public T SquareCentimeters => As(AreaUnit.SquareCentimeter);
 
         /// <summary>
-        ///     Get Area in SquareDecimeters.
+        ///     Get <see cref="Area{T}" /> in SquareDecimeters.
         /// </summary>
-        public double SquareDecimeters => As(AreaUnit.SquareDecimeter);
+        public T SquareDecimeters => As(AreaUnit.SquareDecimeter);
 
         /// <summary>
-        ///     Get Area in SquareFeet.
+        ///     Get <see cref="Area{T}" /> in SquareFeet.
         /// </summary>
-        public double SquareFeet => As(AreaUnit.SquareFoot);
+        public T SquareFeet => As(AreaUnit.SquareFoot);
 
         /// <summary>
-        ///     Get Area in SquareInches.
+        ///     Get <see cref="Area{T}" /> in SquareInches.
         /// </summary>
-        public double SquareInches => As(AreaUnit.SquareInch);
+        public T SquareInches => As(AreaUnit.SquareInch);
 
         /// <summary>
-        ///     Get Area in SquareKilometers.
+        ///     Get <see cref="Area{T}" /> in SquareKilometers.
         /// </summary>
-        public double SquareKilometers => As(AreaUnit.SquareKilometer);
+        public T SquareKilometers => As(AreaUnit.SquareKilometer);
 
         /// <summary>
-        ///     Get Area in SquareMeters.
+        ///     Get <see cref="Area{T}" /> in SquareMeters.
         /// </summary>
-        public double SquareMeters => As(AreaUnit.SquareMeter);
+        public T SquareMeters => As(AreaUnit.SquareMeter);
 
         /// <summary>
-        ///     Get Area in SquareMicrometers.
+        ///     Get <see cref="Area{T}" /> in SquareMicrometers.
         /// </summary>
-        public double SquareMicrometers => As(AreaUnit.SquareMicrometer);
+        public T SquareMicrometers => As(AreaUnit.SquareMicrometer);
 
         /// <summary>
-        ///     Get Area in SquareMiles.
+        ///     Get <see cref="Area{T}" /> in SquareMiles.
         /// </summary>
-        public double SquareMiles => As(AreaUnit.SquareMile);
+        public T SquareMiles => As(AreaUnit.SquareMile);
 
         /// <summary>
-        ///     Get Area in SquareMillimeters.
+        ///     Get <see cref="Area{T}" /> in SquareMillimeters.
         /// </summary>
-        public double SquareMillimeters => As(AreaUnit.SquareMillimeter);
+        public T SquareMillimeters => As(AreaUnit.SquareMillimeter);
 
         /// <summary>
-        ///     Get Area in SquareNauticalMiles.
+        ///     Get <see cref="Area{T}" /> in SquareNauticalMiles.
         /// </summary>
-        public double SquareNauticalMiles => As(AreaUnit.SquareNauticalMile);
+        public T SquareNauticalMiles => As(AreaUnit.SquareNauticalMile);
 
         /// <summary>
-        ///     Get Area in SquareYards.
+        ///     Get <see cref="Area{T}" /> in SquareYards.
         /// </summary>
-        public double SquareYards => As(AreaUnit.SquareYard);
+        public T SquareYards => As(AreaUnit.SquareYard);
 
         /// <summary>
-        ///     Get Area in UsSurveySquareFeet.
+        ///     Get <see cref="Area{T}" /> in UsSurveySquareFeet.
         /// </summary>
-        public double UsSurveySquareFeet => As(AreaUnit.UsSurveySquareFoot);
+        public T UsSurveySquareFeet => As(AreaUnit.UsSurveySquareFoot);
 
         #endregion
 
@@ -279,141 +277,127 @@ public static string GetAbbreviation(AreaUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Area from Acres.
+        ///     Get <see cref="Area{T}" /> from Acres.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromAcres(QuantityValue acres)
+        public static Area<T> FromAcres(T acres)
         {
-            double value = (double) acres;
-            return new Area(value, AreaUnit.Acre);
+            return new Area<T>(acres, AreaUnit.Acre);
         }
         /// <summary>
-        ///     Get Area from Hectares.
+        ///     Get <see cref="Area{T}" /> from Hectares.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromHectares(QuantityValue hectares)
+        public static Area<T> FromHectares(T hectares)
         {
-            double value = (double) hectares;
-            return new Area(value, AreaUnit.Hectare);
+            return new Area<T>(hectares, AreaUnit.Hectare);
         }
         /// <summary>
-        ///     Get Area from SquareCentimeters.
+        ///     Get <see cref="Area{T}" /> from SquareCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareCentimeters(QuantityValue squarecentimeters)
+        public static Area<T> FromSquareCentimeters(T squarecentimeters)
         {
-            double value = (double) squarecentimeters;
-            return new Area(value, AreaUnit.SquareCentimeter);
+            return new Area<T>(squarecentimeters, AreaUnit.SquareCentimeter);
         }
         /// <summary>
-        ///     Get Area from SquareDecimeters.
+        ///     Get <see cref="Area{T}" /> from SquareDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareDecimeters(QuantityValue squaredecimeters)
+        public static Area<T> FromSquareDecimeters(T squaredecimeters)
         {
-            double value = (double) squaredecimeters;
-            return new Area(value, AreaUnit.SquareDecimeter);
+            return new Area<T>(squaredecimeters, AreaUnit.SquareDecimeter);
         }
         /// <summary>
-        ///     Get Area from SquareFeet.
+        ///     Get <see cref="Area{T}" /> from SquareFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareFeet(QuantityValue squarefeet)
+        public static Area<T> FromSquareFeet(T squarefeet)
         {
-            double value = (double) squarefeet;
-            return new Area(value, AreaUnit.SquareFoot);
+            return new Area<T>(squarefeet, AreaUnit.SquareFoot);
         }
         /// <summary>
-        ///     Get Area from SquareInches.
+        ///     Get <see cref="Area{T}" /> from SquareInches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareInches(QuantityValue squareinches)
+        public static Area<T> FromSquareInches(T squareinches)
         {
-            double value = (double) squareinches;
-            return new Area(value, AreaUnit.SquareInch);
+            return new Area<T>(squareinches, AreaUnit.SquareInch);
         }
         /// <summary>
-        ///     Get Area from SquareKilometers.
+        ///     Get <see cref="Area{T}" /> from SquareKilometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareKilometers(QuantityValue squarekilometers)
+        public static Area<T> FromSquareKilometers(T squarekilometers)
         {
-            double value = (double) squarekilometers;
-            return new Area(value, AreaUnit.SquareKilometer);
+            return new Area<T>(squarekilometers, AreaUnit.SquareKilometer);
         }
         /// <summary>
-        ///     Get Area from SquareMeters.
+        ///     Get <see cref="Area{T}" /> from SquareMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMeters(QuantityValue squaremeters)
+        public static Area<T> FromSquareMeters(T squaremeters)
         {
-            double value = (double) squaremeters;
-            return new Area(value, AreaUnit.SquareMeter);
+            return new Area<T>(squaremeters, AreaUnit.SquareMeter);
         }
         /// <summary>
-        ///     Get Area from SquareMicrometers.
+        ///     Get <see cref="Area{T}" /> from SquareMicrometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMicrometers(QuantityValue squaremicrometers)
+        public static Area<T> FromSquareMicrometers(T squaremicrometers)
         {
-            double value = (double) squaremicrometers;
-            return new Area(value, AreaUnit.SquareMicrometer);
+            return new Area<T>(squaremicrometers, AreaUnit.SquareMicrometer);
         }
         /// <summary>
-        ///     Get Area from SquareMiles.
+        ///     Get <see cref="Area{T}" /> from SquareMiles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMiles(QuantityValue squaremiles)
+        public static Area<T> FromSquareMiles(T squaremiles)
         {
-            double value = (double) squaremiles;
-            return new Area(value, AreaUnit.SquareMile);
+            return new Area<T>(squaremiles, AreaUnit.SquareMile);
         }
         /// <summary>
-        ///     Get Area from SquareMillimeters.
+        ///     Get <see cref="Area{T}" /> from SquareMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMillimeters(QuantityValue squaremillimeters)
+        public static Area<T> FromSquareMillimeters(T squaremillimeters)
         {
-            double value = (double) squaremillimeters;
-            return new Area(value, AreaUnit.SquareMillimeter);
+            return new Area<T>(squaremillimeters, AreaUnit.SquareMillimeter);
         }
         /// <summary>
-        ///     Get Area from SquareNauticalMiles.
+        ///     Get <see cref="Area{T}" /> from SquareNauticalMiles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareNauticalMiles(QuantityValue squarenauticalmiles)
+        public static Area<T> FromSquareNauticalMiles(T squarenauticalmiles)
         {
-            double value = (double) squarenauticalmiles;
-            return new Area(value, AreaUnit.SquareNauticalMile);
+            return new Area<T>(squarenauticalmiles, AreaUnit.SquareNauticalMile);
         }
         /// <summary>
-        ///     Get Area from SquareYards.
+        ///     Get <see cref="Area{T}" /> from SquareYards.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareYards(QuantityValue squareyards)
+        public static Area<T> FromSquareYards(T squareyards)
         {
-            double value = (double) squareyards;
-            return new Area(value, AreaUnit.SquareYard);
+            return new Area<T>(squareyards, AreaUnit.SquareYard);
         }
         /// <summary>
-        ///     Get Area from UsSurveySquareFeet.
+        ///     Get <see cref="Area{T}" /> from UsSurveySquareFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromUsSurveySquareFeet(QuantityValue ussurveysquarefeet)
+        public static Area<T> FromUsSurveySquareFeet(T ussurveysquarefeet)
         {
-            double value = (double) ussurveysquarefeet;
-            return new Area(value, AreaUnit.UsSurveySquareFoot);
+            return new Area<T>(ussurveysquarefeet, AreaUnit.UsSurveySquareFoot);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AreaUnit" /> to <see cref="Area" />.
+        ///     Dynamically convert from value and unit enum <see cref="AreaUnit" /> to <see cref="Area{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Area unit value.</returns>
-        public static Area From(QuantityValue value, AreaUnit fromUnit)
+        /// <returns><see cref="Area{T}" /> unit value.</returns>
+        public static Area<T> From(T value, AreaUnit fromUnit)
         {
-            return new Area((double)value, fromUnit);
+            return new Area<T>(value, fromUnit);
         }
 
         #endregion
@@ -442,7 +426,7 @@ public static Area From(QuantityValue value, AreaUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Area Parse(string str)
+        public static Area<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -470,9 +454,9 @@ public static Area Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Area Parse(string str, IFormatProvider? provider)
+        public static Area<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Area, AreaUnit>(
+            return QuantityParser.Default.Parse<T, Area<T>, AreaUnit>(
                 str,
                 provider,
                 From);
@@ -486,7 +470,7 @@ public static Area Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Area result)
+        public static bool TryParse(string? str, out Area<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -501,9 +485,9 @@ public static bool TryParse(string? str, out Area result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Area result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Area<T> result)
         {
-            return QuantityParser.Default.TryParse<Area, AreaUnit>(
+            return QuantityParser.Default.TryParse<T, Area<T>, AreaUnit>(
                 str,
                 provider,
                 From,
@@ -565,45 +549,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaU
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Area operator -(Area right)
+        public static Area<T> operator -(Area<T> right)
         {
-            return new Area(-right.Value, right.Unit);
+            return new Area<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Area"/> from adding two <see cref="Area"/>.</summary>
-        public static Area operator +(Area left, Area right)
+        /// <summary>Get <see cref="Area{T}"/> from adding two <see cref="Area{T}"/>.</summary>
+        public static Area<T> operator +(Area<T> left, Area<T> right)
         {
-            return new Area(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Area<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Area"/> from subtracting two <see cref="Area"/>.</summary>
-        public static Area operator -(Area left, Area right)
+        /// <summary>Get <see cref="Area{T}"/> from subtracting two <see cref="Area{T}"/>.</summary>
+        public static Area<T> operator -(Area<T> left, Area<T> right)
         {
-            return new Area(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Area<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Area"/> from multiplying value and <see cref="Area"/>.</summary>
-        public static Area operator *(double left, Area right)
+        /// <summary>Get <see cref="Area{T}"/> from multiplying value and <see cref="Area{T}"/>.</summary>
+        public static Area<T> operator *(T left, Area<T> right)
         {
-            return new Area(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Area<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Area"/> from multiplying value and <see cref="Area"/>.</summary>
-        public static Area operator *(Area left, double right)
+        /// <summary>Get <see cref="Area{T}"/> from multiplying value and <see cref="Area{T}"/>.</summary>
+        public static Area<T> operator *(Area<T> left, T right)
         {
-            return new Area(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Area<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Area"/> from dividing <see cref="Area"/> by value.</summary>
-        public static Area operator /(Area left, double right)
+        /// <summary>Get <see cref="Area{T}"/> from dividing <see cref="Area{T}"/> by value.</summary>
+        public static Area<T> operator /(Area<T> left, T right)
         {
-            return new Area(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Area<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Area"/> by <see cref="Area"/>.</summary>
-        public static double operator /(Area left, Area right)
+        /// <summary>Get ratio value from dividing <see cref="Area{T}"/> by <see cref="Area{T}"/>.</summary>
+        public static T operator /(Area<T> left, Area<T> right)
         {
-            return left.SquareMeters / right.SquareMeters;
+            return CompiledLambdas.Divide(left.SquareMeters, right.SquareMeters);
         }
 
         #endregion
@@ -611,39 +600,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaU
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Area left, Area right)
+        public static bool operator <=(Area<T> left, Area<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Area left, Area right)
+        public static bool operator >=(Area<T> left, Area<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Area left, Area right)
+        public static bool operator <(Area<T> left, Area<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Area left, Area right)
+        public static bool operator >(Area<T> left, Area<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Area, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Area left, Area right)
+        /// <remarks>Consider using <see cref="Equals(Area{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Area<T> left, Area<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Area, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Area left, Area right)
+        /// <remarks>Consider using <see cref="Equals(Area{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Area<T> left, Area<T> right)
         {
             return !(left == right);
         }
@@ -652,37 +641,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaU
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Area objArea)) throw new ArgumentException("Expected type Area.", nameof(obj));
+            if(!(obj is Area<T> objArea)) throw new ArgumentException("Expected type Area.", nameof(obj));
 
             return CompareTo(objArea);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Area other)
+        public int CompareTo(Area<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Area, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Area{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Area objArea))
+            if(obj is null || !(obj is Area<T> objArea))
                 return false;
 
             return Equals(objArea);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Area, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Area other)
+        /// <remarks>Consider using <see cref="Equals(Area{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Area<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Area within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Area{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -720,21 +709,19 @@ public bool Equals(Area other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Area other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Area<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Area.</returns>
+        /// <returns>A hash code for the current <see cref="Area{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -748,17 +735,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(AreaUnit unit)
+        public T As(AreaUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -778,17 +765,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is AreaUnit unitAsAreaUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaUnit)} is supported.", nameof(unit));
 
-            return As(unitAsAreaUnit);
+            var asValue = As(unitAsAreaUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<AreaUnit>.As(AreaUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Area to another Area with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Area{T}" /> to another <see cref="Area{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Area with the specified unit.</returns>
-        public Area ToUnit(AreaUnit unit)
+        /// <returns>A <see cref="Area{T}" /> with the specified unit.</returns>
+        public Area<T> ToUnit(AreaUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Area(convertedValue, unit);
+            return new Area<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -801,7 +793,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Area ToUnit(UnitSystem unitSystem)
+        public Area<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -821,32 +813,38 @@ public Area ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AreaUnit> IQuantity<AreaUnit>.ToUnit(AreaUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<AreaUnit, T> IQuantityT<AreaUnit, T>.ToUnit(AreaUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<AreaUnit> IQuantity<AreaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<AreaUnit, T> IQuantityT<AreaUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case AreaUnit.Acre: return _value*4046.85642;
-                case AreaUnit.Hectare: return _value*1e4;
-                case AreaUnit.SquareCentimeter: return _value*1e-4;
-                case AreaUnit.SquareDecimeter: return _value*1e-2;
-                case AreaUnit.SquareFoot: return _value*0.092903;
-                case AreaUnit.SquareInch: return _value*0.00064516;
-                case AreaUnit.SquareKilometer: return _value*1e6;
-                case AreaUnit.SquareMeter: return _value;
-                case AreaUnit.SquareMicrometer: return _value*1e-12;
-                case AreaUnit.SquareMile: return _value*2.59e6;
-                case AreaUnit.SquareMillimeter: return _value*1e-6;
-                case AreaUnit.SquareNauticalMile: return _value*3429904;
-                case AreaUnit.SquareYard: return _value*0.836127;
-                case AreaUnit.UsSurveySquareFoot: return _value*0.09290341161;
+                case AreaUnit.Acre: return Value*4046.85642;
+                case AreaUnit.Hectare: return Value*1e4;
+                case AreaUnit.SquareCentimeter: return Value*1e-4;
+                case AreaUnit.SquareDecimeter: return Value*1e-2;
+                case AreaUnit.SquareFoot: return Value*0.092903;
+                case AreaUnit.SquareInch: return Value*0.00064516;
+                case AreaUnit.SquareKilometer: return Value*1e6;
+                case AreaUnit.SquareMeter: return Value;
+                case AreaUnit.SquareMicrometer: return Value*1e-12;
+                case AreaUnit.SquareMile: return Value*2.59e6;
+                case AreaUnit.SquareMillimeter: return Value*1e-6;
+                case AreaUnit.SquareNauticalMile: return Value*3429904;
+                case AreaUnit.SquareYard: return Value*0.836127;
+                case AreaUnit.UsSurveySquareFoot: return Value*0.09290341161;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -857,16 +855,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Area ToBaseUnit()
+        internal Area<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Area(baseUnitValue, BaseUnit);
+            return new Area<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(AreaUnit unit)
+        private T GetValueAs(AreaUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -982,57 +980,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Area)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Area<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Area)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Area<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Area)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Area<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1042,33 +1040,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Area))
+            if(conversionType == typeof(Area<T>))
                 return this;
             else if(conversionType == typeof(AreaUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Area.QuantityType;
+                return Area<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Area.Info;
+                return Area<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Area.BaseDimensions;
+                return Area<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Area)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Area<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
index 3dbdd60bd5..b4b5c0855e 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The area density of a two-dimensional object is calculated as the mass per unit area.
     /// </summary>
-    public partial struct AreaDensity : IQuantity<AreaDensityUnit>, IEquatable<AreaDensity>, IComparable, IComparable<AreaDensity>, IConvertible, IFormattable
+    public partial struct AreaDensity<T> : IQuantityT<AreaDensityUnit, T>, IEquatable<AreaDensity<T>>, IComparable, IComparable<AreaDensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -63,12 +59,12 @@ static AreaDensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public AreaDensity(double value, AreaDensityUnit unit)
+        public AreaDensity(T value, AreaDensityUnit unit)
         {
             if(unit == AreaDensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -80,14 +76,14 @@ public AreaDensity(double value, AreaDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AreaDensity(double value, UnitSystem unitSystem)
+        public AreaDensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -102,19 +98,19 @@ public AreaDensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of AreaDensity, which is KilogramPerSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="AreaDensity{T}" />, which is KilogramPerSquareMeter. All conversions go via this value.
         /// </summary>
         public static AreaDensityUnit BaseUnit { get; } = AreaDensityUnit.KilogramPerSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of AreaDensity
+        /// Represents the largest possible value of <see cref="AreaDensity{T}" />
         /// </summary>
-        public static AreaDensity MaxValue { get; } = new AreaDensity(double.MaxValue, BaseUnit);
+        public static AreaDensity<T> MaxValue { get; } = new AreaDensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of AreaDensity
+        /// Represents the smallest possible value of <see cref="AreaDensity{T}" />
         /// </summary>
-        public static AreaDensity MinValue { get; } = new AreaDensity(double.MinValue, BaseUnit);
+        public static AreaDensity<T> MinValue { get; } = new AreaDensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -123,14 +119,14 @@ public AreaDensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.AreaDensity;
 
         /// <summary>
-        ///     All units of measurement for the AreaDensity quantity.
+        ///     All units of measurement for the <see cref="AreaDensity{T}" /> quantity.
         /// </summary>
         public static AreaDensityUnit[] Units { get; } = Enum.GetValues(typeof(AreaDensityUnit)).Cast<AreaDensityUnit>().Except(new AreaDensityUnit[]{ AreaDensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramPerSquareMeter.
         /// </summary>
-        public static AreaDensity Zero { get; } = new AreaDensity(0, BaseUnit);
+        public static AreaDensity<T> Zero { get; } = new AreaDensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -139,7 +135,9 @@ public AreaDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -155,21 +153,21 @@ public AreaDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => AreaDensity.QuantityType;
+        public QuantityType Type => AreaDensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => AreaDensity.BaseDimensions;
+        public BaseDimensions Dimensions => AreaDensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get AreaDensity in KilogramsPerSquareMeter.
+        ///     Get <see cref="AreaDensity{T}" /> in KilogramsPerSquareMeter.
         /// </summary>
-        public double KilogramsPerSquareMeter => As(AreaDensityUnit.KilogramPerSquareMeter);
+        public T KilogramsPerSquareMeter => As(AreaDensityUnit.KilogramPerSquareMeter);
 
         #endregion
 
@@ -201,24 +199,23 @@ public static string GetAbbreviation(AreaDensityUnit unit, IFormatProvider? prov
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get AreaDensity from KilogramsPerSquareMeter.
+        ///     Get <see cref="AreaDensity{T}" /> from KilogramsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaDensity FromKilogramsPerSquareMeter(QuantityValue kilogramspersquaremeter)
+        public static AreaDensity<T> FromKilogramsPerSquareMeter(T kilogramspersquaremeter)
         {
-            double value = (double) kilogramspersquaremeter;
-            return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter);
+            return new AreaDensity<T>(kilogramspersquaremeter, AreaDensityUnit.KilogramPerSquareMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AreaDensityUnit" /> to <see cref="AreaDensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="AreaDensityUnit" /> to <see cref="AreaDensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AreaDensity unit value.</returns>
-        public static AreaDensity From(QuantityValue value, AreaDensityUnit fromUnit)
+        /// <returns><see cref="AreaDensity{T}" /> unit value.</returns>
+        public static AreaDensity<T> From(T value, AreaDensityUnit fromUnit)
         {
-            return new AreaDensity((double)value, fromUnit);
+            return new AreaDensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -247,7 +244,7 @@ public static AreaDensity From(QuantityValue value, AreaDensityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static AreaDensity Parse(string str)
+        public static AreaDensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -275,9 +272,9 @@ public static AreaDensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static AreaDensity Parse(string str, IFormatProvider? provider)
+        public static AreaDensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<AreaDensity, AreaDensityUnit>(
+            return QuantityParser.Default.Parse<T, AreaDensity<T>, AreaDensityUnit>(
                 str,
                 provider,
                 From);
@@ -291,7 +288,7 @@ public static AreaDensity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out AreaDensity result)
+        public static bool TryParse(string? str, out AreaDensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -306,9 +303,9 @@ public static bool TryParse(string? str, out AreaDensity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out AreaDensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out AreaDensity<T> result)
         {
-            return QuantityParser.Default.TryParse<AreaDensity, AreaDensityUnit>(
+            return QuantityParser.Default.TryParse<T, AreaDensity<T>, AreaDensityUnit>(
                 str,
                 provider,
                 From,
@@ -370,45 +367,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaD
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static AreaDensity operator -(AreaDensity right)
+        public static AreaDensity<T> operator -(AreaDensity<T> right)
         {
-            return new AreaDensity(-right.Value, right.Unit);
+            return new AreaDensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="AreaDensity"/> from adding two <see cref="AreaDensity"/>.</summary>
-        public static AreaDensity operator +(AreaDensity left, AreaDensity right)
+        /// <summary>Get <see cref="AreaDensity{T}"/> from adding two <see cref="AreaDensity{T}"/>.</summary>
+        public static AreaDensity<T> operator +(AreaDensity<T> left, AreaDensity<T> right)
         {
-            return new AreaDensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new AreaDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AreaDensity"/> from subtracting two <see cref="AreaDensity"/>.</summary>
-        public static AreaDensity operator -(AreaDensity left, AreaDensity right)
+        /// <summary>Get <see cref="AreaDensity{T}"/> from subtracting two <see cref="AreaDensity{T}"/>.</summary>
+        public static AreaDensity<T> operator -(AreaDensity<T> left, AreaDensity<T> right)
         {
-            return new AreaDensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new AreaDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AreaDensity"/> from multiplying value and <see cref="AreaDensity"/>.</summary>
-        public static AreaDensity operator *(double left, AreaDensity right)
+        /// <summary>Get <see cref="AreaDensity{T}"/> from multiplying value and <see cref="AreaDensity{T}"/>.</summary>
+        public static AreaDensity<T> operator *(T left, AreaDensity<T> right)
         {
-            return new AreaDensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new AreaDensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="AreaDensity"/> from multiplying value and <see cref="AreaDensity"/>.</summary>
-        public static AreaDensity operator *(AreaDensity left, double right)
+        /// <summary>Get <see cref="AreaDensity{T}"/> from multiplying value and <see cref="AreaDensity{T}"/>.</summary>
+        public static AreaDensity<T> operator *(AreaDensity<T> left, T right)
         {
-            return new AreaDensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new AreaDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AreaDensity"/> from dividing <see cref="AreaDensity"/> by value.</summary>
-        public static AreaDensity operator /(AreaDensity left, double right)
+        /// <summary>Get <see cref="AreaDensity{T}"/> from dividing <see cref="AreaDensity{T}"/> by value.</summary>
+        public static AreaDensity<T> operator /(AreaDensity<T> left, T right)
         {
-            return new AreaDensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new AreaDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="AreaDensity"/> by <see cref="AreaDensity"/>.</summary>
-        public static double operator /(AreaDensity left, AreaDensity right)
+        /// <summary>Get ratio value from dividing <see cref="AreaDensity{T}"/> by <see cref="AreaDensity{T}"/>.</summary>
+        public static T operator /(AreaDensity<T> left, AreaDensity<T> right)
         {
-            return left.KilogramsPerSquareMeter / right.KilogramsPerSquareMeter;
+            return CompiledLambdas.Divide(left.KilogramsPerSquareMeter, right.KilogramsPerSquareMeter);
         }
 
         #endregion
@@ -416,39 +418,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaD
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(AreaDensity left, AreaDensity right)
+        public static bool operator <=(AreaDensity<T> left, AreaDensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(AreaDensity left, AreaDensity right)
+        public static bool operator >=(AreaDensity<T> left, AreaDensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(AreaDensity left, AreaDensity right)
+        public static bool operator <(AreaDensity<T> left, AreaDensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(AreaDensity left, AreaDensity right)
+        public static bool operator >(AreaDensity<T> left, AreaDensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AreaDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(AreaDensity left, AreaDensity right)
+        /// <remarks>Consider using <see cref="Equals(AreaDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(AreaDensity<T> left, AreaDensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AreaDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(AreaDensity left, AreaDensity right)
+        /// <remarks>Consider using <see cref="Equals(AreaDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(AreaDensity<T> left, AreaDensity<T> right)
         {
             return !(left == right);
         }
@@ -457,37 +459,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaD
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is AreaDensity objAreaDensity)) throw new ArgumentException("Expected type AreaDensity.", nameof(obj));
+            if(!(obj is AreaDensity<T> objAreaDensity)) throw new ArgumentException("Expected type AreaDensity.", nameof(obj));
 
             return CompareTo(objAreaDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(AreaDensity other)
+        public int CompareTo(AreaDensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AreaDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(AreaDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is AreaDensity objAreaDensity))
+            if(obj is null || !(obj is AreaDensity<T> objAreaDensity))
                 return false;
 
             return Equals(objAreaDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AreaDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(AreaDensity other)
+        /// <remarks>Consider using <see cref="Equals(AreaDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(AreaDensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another AreaDensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="AreaDensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -525,21 +527,19 @@ public bool Equals(AreaDensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(AreaDensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(AreaDensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current AreaDensity.</returns>
+        /// <returns>A hash code for the current <see cref="AreaDensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -553,17 +553,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(AreaDensityUnit unit)
+        public T As(AreaDensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -583,17 +583,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is AreaDensityUnit unitAsAreaDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaDensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsAreaDensityUnit);
+            var asValue = As(unitAsAreaDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<AreaDensityUnit>.As(AreaDensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this AreaDensity to another AreaDensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="AreaDensity{T}" /> to another <see cref="AreaDensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A AreaDensity with the specified unit.</returns>
-        public AreaDensity ToUnit(AreaDensityUnit unit)
+        /// <returns>A <see cref="AreaDensity{T}" /> with the specified unit.</returns>
+        public AreaDensity<T> ToUnit(AreaDensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new AreaDensity(convertedValue, unit);
+            return new AreaDensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -606,7 +611,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public AreaDensity ToUnit(UnitSystem unitSystem)
+        public AreaDensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -626,19 +631,25 @@ public AreaDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AreaDensityUnit> IQuantity<AreaDensityUnit>.ToUnit(AreaDensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<AreaDensityUnit, T> IQuantityT<AreaDensityUnit, T>.ToUnit(AreaDensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<AreaDensityUnit> IQuantity<AreaDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<AreaDensityUnit, T> IQuantityT<AreaDensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case AreaDensityUnit.KilogramPerSquareMeter: return _value;
+                case AreaDensityUnit.KilogramPerSquareMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -649,16 +660,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal AreaDensity ToBaseUnit()
+        internal AreaDensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new AreaDensity(baseUnitValue, BaseUnit);
+            return new AreaDensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(AreaDensityUnit unit)
+        private T GetValueAs(AreaDensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -761,57 +772,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AreaDensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AreaDensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AreaDensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AreaDensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AreaDensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AreaDensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -821,33 +832,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(AreaDensity))
+            if(conversionType == typeof(AreaDensity<T>))
                 return this;
             else if(conversionType == typeof(AreaDensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return AreaDensity.QuantityType;
+                return AreaDensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return AreaDensity.Info;
+                return AreaDensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return AreaDensity.BaseDimensions;
+                return AreaDensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(AreaDensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(AreaDensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
index 72a6da6a62..60d4a40d33 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     A geometric property of an area that reflects how its points are distributed with regard to an axis.
     /// </summary>
-    public partial struct AreaMomentOfInertia : IQuantity<AreaMomentOfInertiaUnit>, IEquatable<AreaMomentOfInertia>, IComparable, IComparable<AreaMomentOfInertia>, IConvertible, IFormattable
+    public partial struct AreaMomentOfInertia<T> : IQuantityT<AreaMomentOfInertiaUnit, T>, IEquatable<AreaMomentOfInertia<T>>, IComparable, IComparable<AreaMomentOfInertia<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static AreaMomentOfInertia()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public AreaMomentOfInertia(double value, AreaMomentOfInertiaUnit unit)
+        public AreaMomentOfInertia(T value, AreaMomentOfInertiaUnit unit)
         {
             if(unit == AreaMomentOfInertiaUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public AreaMomentOfInertia(double value, AreaMomentOfInertiaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AreaMomentOfInertia(double value, UnitSystem unitSystem)
+        public AreaMomentOfInertia(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of AreaMomentOfInertia, which is MeterToTheFourth. All conversions go via this value.
+        ///     The base unit of <see cref="AreaMomentOfInertia{T}" />, which is MeterToTheFourth. All conversions go via this value.
         /// </summary>
         public static AreaMomentOfInertiaUnit BaseUnit { get; } = AreaMomentOfInertiaUnit.MeterToTheFourth;
 
         /// <summary>
-        /// Represents the largest possible value of AreaMomentOfInertia
+        /// Represents the largest possible value of <see cref="AreaMomentOfInertia{T}" />
         /// </summary>
-        public static AreaMomentOfInertia MaxValue { get; } = new AreaMomentOfInertia(double.MaxValue, BaseUnit);
+        public static AreaMomentOfInertia<T> MaxValue { get; } = new AreaMomentOfInertia<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of AreaMomentOfInertia
+        /// Represents the smallest possible value of <see cref="AreaMomentOfInertia{T}" />
         /// </summary>
-        public static AreaMomentOfInertia MinValue { get; } = new AreaMomentOfInertia(double.MinValue, BaseUnit);
+        public static AreaMomentOfInertia<T> MinValue { get; } = new AreaMomentOfInertia<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.AreaMomentOfInertia;
 
         /// <summary>
-        ///     All units of measurement for the AreaMomentOfInertia quantity.
+        ///     All units of measurement for the <see cref="AreaMomentOfInertia{T}" /> quantity.
         /// </summary>
         public static AreaMomentOfInertiaUnit[] Units { get; } = Enum.GetValues(typeof(AreaMomentOfInertiaUnit)).Cast<AreaMomentOfInertiaUnit>().Except(new AreaMomentOfInertiaUnit[]{ AreaMomentOfInertiaUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit MeterToTheFourth.
         /// </summary>
-        public static AreaMomentOfInertia Zero { get; } = new AreaMomentOfInertia(0, BaseUnit);
+        public static AreaMomentOfInertia<T> Zero { get; } = new AreaMomentOfInertia<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,46 +158,46 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => AreaMomentOfInertia.QuantityType;
+        public QuantityType Type => AreaMomentOfInertia<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => AreaMomentOfInertia.BaseDimensions;
+        public BaseDimensions Dimensions => AreaMomentOfInertia<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get AreaMomentOfInertia in CentimetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> in CentimetersToTheFourth.
         /// </summary>
-        public double CentimetersToTheFourth => As(AreaMomentOfInertiaUnit.CentimeterToTheFourth);
+        public T CentimetersToTheFourth => As(AreaMomentOfInertiaUnit.CentimeterToTheFourth);
 
         /// <summary>
-        ///     Get AreaMomentOfInertia in DecimetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> in DecimetersToTheFourth.
         /// </summary>
-        public double DecimetersToTheFourth => As(AreaMomentOfInertiaUnit.DecimeterToTheFourth);
+        public T DecimetersToTheFourth => As(AreaMomentOfInertiaUnit.DecimeterToTheFourth);
 
         /// <summary>
-        ///     Get AreaMomentOfInertia in FeetToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> in FeetToTheFourth.
         /// </summary>
-        public double FeetToTheFourth => As(AreaMomentOfInertiaUnit.FootToTheFourth);
+        public T FeetToTheFourth => As(AreaMomentOfInertiaUnit.FootToTheFourth);
 
         /// <summary>
-        ///     Get AreaMomentOfInertia in InchesToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> in InchesToTheFourth.
         /// </summary>
-        public double InchesToTheFourth => As(AreaMomentOfInertiaUnit.InchToTheFourth);
+        public T InchesToTheFourth => As(AreaMomentOfInertiaUnit.InchToTheFourth);
 
         /// <summary>
-        ///     Get AreaMomentOfInertia in MetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> in MetersToTheFourth.
         /// </summary>
-        public double MetersToTheFourth => As(AreaMomentOfInertiaUnit.MeterToTheFourth);
+        public T MetersToTheFourth => As(AreaMomentOfInertiaUnit.MeterToTheFourth);
 
         /// <summary>
-        ///     Get AreaMomentOfInertia in MillimetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> in MillimetersToTheFourth.
         /// </summary>
-        public double MillimetersToTheFourth => As(AreaMomentOfInertiaUnit.MillimeterToTheFourth);
+        public T MillimetersToTheFourth => As(AreaMomentOfInertiaUnit.MillimeterToTheFourth);
 
         #endregion
 
@@ -231,69 +229,63 @@ public static string GetAbbreviation(AreaMomentOfInertiaUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get AreaMomentOfInertia from CentimetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> from CentimetersToTheFourth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromCentimetersToTheFourth(QuantityValue centimeterstothefourth)
+        public static AreaMomentOfInertia<T> FromCentimetersToTheFourth(T centimeterstothefourth)
         {
-            double value = (double) centimeterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
+            return new AreaMomentOfInertia<T>(centimeterstothefourth, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
         }
         /// <summary>
-        ///     Get AreaMomentOfInertia from DecimetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> from DecimetersToTheFourth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromDecimetersToTheFourth(QuantityValue decimeterstothefourth)
+        public static AreaMomentOfInertia<T> FromDecimetersToTheFourth(T decimeterstothefourth)
         {
-            double value = (double) decimeterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
+            return new AreaMomentOfInertia<T>(decimeterstothefourth, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
         }
         /// <summary>
-        ///     Get AreaMomentOfInertia from FeetToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> from FeetToTheFourth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromFeetToTheFourth(QuantityValue feettothefourth)
+        public static AreaMomentOfInertia<T> FromFeetToTheFourth(T feettothefourth)
         {
-            double value = (double) feettothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth);
+            return new AreaMomentOfInertia<T>(feettothefourth, AreaMomentOfInertiaUnit.FootToTheFourth);
         }
         /// <summary>
-        ///     Get AreaMomentOfInertia from InchesToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> from InchesToTheFourth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromInchesToTheFourth(QuantityValue inchestothefourth)
+        public static AreaMomentOfInertia<T> FromInchesToTheFourth(T inchestothefourth)
         {
-            double value = (double) inchestothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth);
+            return new AreaMomentOfInertia<T>(inchestothefourth, AreaMomentOfInertiaUnit.InchToTheFourth);
         }
         /// <summary>
-        ///     Get AreaMomentOfInertia from MetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> from MetersToTheFourth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromMetersToTheFourth(QuantityValue meterstothefourth)
+        public static AreaMomentOfInertia<T> FromMetersToTheFourth(T meterstothefourth)
         {
-            double value = (double) meterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth);
+            return new AreaMomentOfInertia<T>(meterstothefourth, AreaMomentOfInertiaUnit.MeterToTheFourth);
         }
         /// <summary>
-        ///     Get AreaMomentOfInertia from MillimetersToTheFourth.
+        ///     Get <see cref="AreaMomentOfInertia{T}" /> from MillimetersToTheFourth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromMillimetersToTheFourth(QuantityValue millimeterstothefourth)
+        public static AreaMomentOfInertia<T> FromMillimetersToTheFourth(T millimeterstothefourth)
         {
-            double value = (double) millimeterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
+            return new AreaMomentOfInertia<T>(millimeterstothefourth, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AreaMomentOfInertiaUnit" /> to <see cref="AreaMomentOfInertia" />.
+        ///     Dynamically convert from value and unit enum <see cref="AreaMomentOfInertiaUnit" /> to <see cref="AreaMomentOfInertia{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AreaMomentOfInertia unit value.</returns>
-        public static AreaMomentOfInertia From(QuantityValue value, AreaMomentOfInertiaUnit fromUnit)
+        /// <returns><see cref="AreaMomentOfInertia{T}" /> unit value.</returns>
+        public static AreaMomentOfInertia<T> From(T value, AreaMomentOfInertiaUnit fromUnit)
         {
-            return new AreaMomentOfInertia((double)value, fromUnit);
+            return new AreaMomentOfInertia<T>(value, fromUnit);
         }
 
         #endregion
@@ -322,7 +314,7 @@ public static AreaMomentOfInertia From(QuantityValue value, AreaMomentOfInertiaU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static AreaMomentOfInertia Parse(string str)
+        public static AreaMomentOfInertia<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -350,9 +342,9 @@ public static AreaMomentOfInertia Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static AreaMomentOfInertia Parse(string str, IFormatProvider? provider)
+        public static AreaMomentOfInertia<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<AreaMomentOfInertia, AreaMomentOfInertiaUnit>(
+            return QuantityParser.Default.Parse<T, AreaMomentOfInertia<T>, AreaMomentOfInertiaUnit>(
                 str,
                 provider,
                 From);
@@ -366,7 +358,7 @@ public static AreaMomentOfInertia Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out AreaMomentOfInertia result)
+        public static bool TryParse(string? str, out AreaMomentOfInertia<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -381,9 +373,9 @@ public static bool TryParse(string? str, out AreaMomentOfInertia result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out AreaMomentOfInertia result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out AreaMomentOfInertia<T> result)
         {
-            return QuantityParser.Default.TryParse<AreaMomentOfInertia, AreaMomentOfInertiaUnit>(
+            return QuantityParser.Default.TryParse<T, AreaMomentOfInertia<T>, AreaMomentOfInertiaUnit>(
                 str,
                 provider,
                 From,
@@ -445,45 +437,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaM
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static AreaMomentOfInertia operator -(AreaMomentOfInertia right)
+        public static AreaMomentOfInertia<T> operator -(AreaMomentOfInertia<T> right)
         {
-            return new AreaMomentOfInertia(-right.Value, right.Unit);
+            return new AreaMomentOfInertia<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="AreaMomentOfInertia"/> from adding two <see cref="AreaMomentOfInertia"/>.</summary>
-        public static AreaMomentOfInertia operator +(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        /// <summary>Get <see cref="AreaMomentOfInertia{T}"/> from adding two <see cref="AreaMomentOfInertia{T}"/>.</summary>
+        public static AreaMomentOfInertia<T> operator +(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
-            return new AreaMomentOfInertia(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new AreaMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AreaMomentOfInertia"/> from subtracting two <see cref="AreaMomentOfInertia"/>.</summary>
-        public static AreaMomentOfInertia operator -(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        /// <summary>Get <see cref="AreaMomentOfInertia{T}"/> from subtracting two <see cref="AreaMomentOfInertia{T}"/>.</summary>
+        public static AreaMomentOfInertia<T> operator -(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
-            return new AreaMomentOfInertia(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new AreaMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AreaMomentOfInertia"/> from multiplying value and <see cref="AreaMomentOfInertia"/>.</summary>
-        public static AreaMomentOfInertia operator *(double left, AreaMomentOfInertia right)
+        /// <summary>Get <see cref="AreaMomentOfInertia{T}"/> from multiplying value and <see cref="AreaMomentOfInertia{T}"/>.</summary>
+        public static AreaMomentOfInertia<T> operator *(T left, AreaMomentOfInertia<T> right)
         {
-            return new AreaMomentOfInertia(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new AreaMomentOfInertia<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="AreaMomentOfInertia"/> from multiplying value and <see cref="AreaMomentOfInertia"/>.</summary>
-        public static AreaMomentOfInertia operator *(AreaMomentOfInertia left, double right)
+        /// <summary>Get <see cref="AreaMomentOfInertia{T}"/> from multiplying value and <see cref="AreaMomentOfInertia{T}"/>.</summary>
+        public static AreaMomentOfInertia<T> operator *(AreaMomentOfInertia<T> left, T right)
         {
-            return new AreaMomentOfInertia(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new AreaMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="AreaMomentOfInertia"/> from dividing <see cref="AreaMomentOfInertia"/> by value.</summary>
-        public static AreaMomentOfInertia operator /(AreaMomentOfInertia left, double right)
+        /// <summary>Get <see cref="AreaMomentOfInertia{T}"/> from dividing <see cref="AreaMomentOfInertia{T}"/> by value.</summary>
+        public static AreaMomentOfInertia<T> operator /(AreaMomentOfInertia<T> left, T right)
         {
-            return new AreaMomentOfInertia(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new AreaMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="AreaMomentOfInertia"/> by <see cref="AreaMomentOfInertia"/>.</summary>
-        public static double operator /(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        /// <summary>Get ratio value from dividing <see cref="AreaMomentOfInertia{T}"/> by <see cref="AreaMomentOfInertia{T}"/>.</summary>
+        public static T operator /(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
-            return left.MetersToTheFourth / right.MetersToTheFourth;
+            return CompiledLambdas.Divide(left.MetersToTheFourth, right.MetersToTheFourth);
         }
 
         #endregion
@@ -491,39 +488,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaM
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        public static bool operator <=(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        public static bool operator >=(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        public static bool operator <(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        public static bool operator >(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(AreaMomentOfInertia<T> left, AreaMomentOfInertia<T> right)
         {
             return !(left == right);
         }
@@ -532,37 +529,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out AreaM
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is AreaMomentOfInertia objAreaMomentOfInertia)) throw new ArgumentException("Expected type AreaMomentOfInertia.", nameof(obj));
+            if(!(obj is AreaMomentOfInertia<T> objAreaMomentOfInertia)) throw new ArgumentException("Expected type AreaMomentOfInertia.", nameof(obj));
 
             return CompareTo(objAreaMomentOfInertia);
         }
 
         /// <inheritdoc />
-        public int CompareTo(AreaMomentOfInertia other)
+        public int CompareTo(AreaMomentOfInertia<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is AreaMomentOfInertia objAreaMomentOfInertia))
+            if(obj is null || !(obj is AreaMomentOfInertia<T> objAreaMomentOfInertia))
                 return false;
 
             return Equals(objAreaMomentOfInertia);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(AreaMomentOfInertia other)
+        /// <remarks>Consider using <see cref="Equals(AreaMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(AreaMomentOfInertia<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another AreaMomentOfInertia within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="AreaMomentOfInertia{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -600,21 +597,19 @@ public bool Equals(AreaMomentOfInertia other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(AreaMomentOfInertia other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(AreaMomentOfInertia<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current AreaMomentOfInertia.</returns>
+        /// <returns>A hash code for the current <see cref="AreaMomentOfInertia{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -628,17 +623,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(AreaMomentOfInertiaUnit unit)
+        public T As(AreaMomentOfInertiaUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -658,17 +653,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is AreaMomentOfInertiaUnit unitAsAreaMomentOfInertiaUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaMomentOfInertiaUnit)} is supported.", nameof(unit));
 
-            return As(unitAsAreaMomentOfInertiaUnit);
+            var asValue = As(unitAsAreaMomentOfInertiaUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<AreaMomentOfInertiaUnit>.As(AreaMomentOfInertiaUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this AreaMomentOfInertia to another AreaMomentOfInertia with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="AreaMomentOfInertia{T}" /> to another <see cref="AreaMomentOfInertia{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A AreaMomentOfInertia with the specified unit.</returns>
-        public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit)
+        /// <returns>A <see cref="AreaMomentOfInertia{T}" /> with the specified unit.</returns>
+        public AreaMomentOfInertia<T> ToUnit(AreaMomentOfInertiaUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new AreaMomentOfInertia(convertedValue, unit);
+            return new AreaMomentOfInertia<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -681,7 +681,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public AreaMomentOfInertia ToUnit(UnitSystem unitSystem)
+        public AreaMomentOfInertia<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -701,24 +701,30 @@ public AreaMomentOfInertia ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AreaMomentOfInertiaUnit> IQuantity<AreaMomentOfInertiaUnit>.ToUnit(AreaMomentOfInertiaUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<AreaMomentOfInertiaUnit, T> IQuantityT<AreaMomentOfInertiaUnit, T>.ToUnit(AreaMomentOfInertiaUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<AreaMomentOfInertiaUnit> IQuantity<AreaMomentOfInertiaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<AreaMomentOfInertiaUnit, T> IQuantityT<AreaMomentOfInertiaUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case AreaMomentOfInertiaUnit.CentimeterToTheFourth: return _value/1e8;
-                case AreaMomentOfInertiaUnit.DecimeterToTheFourth: return _value/1e4;
-                case AreaMomentOfInertiaUnit.FootToTheFourth: return _value*Math.Pow(0.3048, 4);
-                case AreaMomentOfInertiaUnit.InchToTheFourth: return _value*Math.Pow(2.54e-2, 4);
-                case AreaMomentOfInertiaUnit.MeterToTheFourth: return _value;
-                case AreaMomentOfInertiaUnit.MillimeterToTheFourth: return _value/1e12;
+                case AreaMomentOfInertiaUnit.CentimeterToTheFourth: return Value/1e8;
+                case AreaMomentOfInertiaUnit.DecimeterToTheFourth: return Value/1e4;
+                case AreaMomentOfInertiaUnit.FootToTheFourth: return Value*Math.Pow(0.3048, 4);
+                case AreaMomentOfInertiaUnit.InchToTheFourth: return Value*Math.Pow(2.54e-2, 4);
+                case AreaMomentOfInertiaUnit.MeterToTheFourth: return Value;
+                case AreaMomentOfInertiaUnit.MillimeterToTheFourth: return Value/1e12;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -729,16 +735,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal AreaMomentOfInertia ToBaseUnit()
+        internal AreaMomentOfInertia<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new AreaMomentOfInertia(baseUnitValue, BaseUnit);
+            return new AreaMomentOfInertia<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(AreaMomentOfInertiaUnit unit)
+        private T GetValueAs(AreaMomentOfInertiaUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -846,57 +852,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -906,33 +912,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(AreaMomentOfInertia))
+            if(conversionType == typeof(AreaMomentOfInertia<T>))
                 return this;
             else if(conversionType == typeof(AreaMomentOfInertiaUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return AreaMomentOfInertia.QuantityType;
+                return AreaMomentOfInertia<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return AreaMomentOfInertia.Info;
+                return AreaMomentOfInertia<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return AreaMomentOfInertia.BaseDimensions;
+                return AreaMomentOfInertia<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(AreaMomentOfInertia<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
index e61dacd524..0e936d553a 100644
--- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Bit_rate
     /// </remarks>
-    public partial struct BitRate : IQuantity<BitRateUnit>, IDecimalQuantity, IEquatable<BitRate>, IComparable, IComparable<BitRate>, IConvertible, IFormattable
+    public partial struct BitRate<T> : IQuantityT<BitRateUnit, T>, IDecimalQuantity, IEquatable<BitRate<T>>, IComparable, IComparable<BitRate<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly decimal _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -91,12 +87,12 @@ static BitRate()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public BitRate(decimal value, BitRateUnit unit)
+        public BitRate(T value, BitRateUnit unit)
         {
             if(unit == BitRateUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = value;
+            Value = value;
             _unit = unit;
         }
 
@@ -108,14 +104,14 @@ public BitRate(decimal value, BitRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public BitRate(decimal value, UnitSystem unitSystem)
+        public BitRate(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = value;
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -130,19 +126,19 @@ public BitRate(decimal value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of BitRate, which is BitPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="BitRate{T}" />, which is BitPerSecond. All conversions go via this value.
         /// </summary>
         public static BitRateUnit BaseUnit { get; } = BitRateUnit.BitPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of BitRate
+        /// Represents the largest possible value of <see cref="BitRate{T}" />
         /// </summary>
-        public static BitRate MaxValue { get; } = new BitRate(decimal.MaxValue, BaseUnit);
+        public static BitRate<T> MaxValue { get; } = new BitRate<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of BitRate
+        /// Represents the smallest possible value of <see cref="BitRate{T}" />
         /// </summary>
-        public static BitRate MinValue { get; } = new BitRate(decimal.MinValue, BaseUnit);
+        public static BitRate<T> MinValue { get; } = new BitRate<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -151,14 +147,14 @@ public BitRate(decimal value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.BitRate;
 
         /// <summary>
-        ///     All units of measurement for the BitRate quantity.
+        ///     All units of measurement for the <see cref="BitRate{T}" /> quantity.
         /// </summary>
         public static BitRateUnit[] Units { get; } = Enum.GetValues(typeof(BitRateUnit)).Cast<BitRateUnit>().Except(new BitRateUnit[]{ BitRateUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit BitPerSecond.
         /// </summary>
-        public static BitRate Zero { get; } = new BitRate(0, BaseUnit);
+        public static BitRate<T> Zero { get; } = new BitRate<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -167,9 +163,9 @@ public BitRate(decimal value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public decimal Value => _value;
+        public T Value{ get; }
 
-        double IQuantity.Value => (double) _value;
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         /// <inheritdoc cref="IDecimalQuantity.Value"/>
         decimal IDecimalQuantity.Value => _value;
@@ -188,146 +184,146 @@ public BitRate(decimal value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => BitRate.QuantityType;
+        public QuantityType Type => BitRate<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => BitRate.BaseDimensions;
+        public BaseDimensions Dimensions => BitRate<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get BitRate in BitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in BitsPerSecond.
         /// </summary>
-        public double BitsPerSecond => As(BitRateUnit.BitPerSecond);
+        public T BitsPerSecond => As(BitRateUnit.BitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in BytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in BytesPerSecond.
         /// </summary>
-        public double BytesPerSecond => As(BitRateUnit.BytePerSecond);
+        public T BytesPerSecond => As(BitRateUnit.BytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in ExabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in ExabitsPerSecond.
         /// </summary>
-        public double ExabitsPerSecond => As(BitRateUnit.ExabitPerSecond);
+        public T ExabitsPerSecond => As(BitRateUnit.ExabitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in ExabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in ExabytesPerSecond.
         /// </summary>
-        public double ExabytesPerSecond => As(BitRateUnit.ExabytePerSecond);
+        public T ExabytesPerSecond => As(BitRateUnit.ExabytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in ExbibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in ExbibitsPerSecond.
         /// </summary>
-        public double ExbibitsPerSecond => As(BitRateUnit.ExbibitPerSecond);
+        public T ExbibitsPerSecond => As(BitRateUnit.ExbibitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in ExbibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in ExbibytesPerSecond.
         /// </summary>
-        public double ExbibytesPerSecond => As(BitRateUnit.ExbibytePerSecond);
+        public T ExbibytesPerSecond => As(BitRateUnit.ExbibytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in GibibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in GibibitsPerSecond.
         /// </summary>
-        public double GibibitsPerSecond => As(BitRateUnit.GibibitPerSecond);
+        public T GibibitsPerSecond => As(BitRateUnit.GibibitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in GibibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in GibibytesPerSecond.
         /// </summary>
-        public double GibibytesPerSecond => As(BitRateUnit.GibibytePerSecond);
+        public T GibibytesPerSecond => As(BitRateUnit.GibibytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in GigabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in GigabitsPerSecond.
         /// </summary>
-        public double GigabitsPerSecond => As(BitRateUnit.GigabitPerSecond);
+        public T GigabitsPerSecond => As(BitRateUnit.GigabitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in GigabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in GigabytesPerSecond.
         /// </summary>
-        public double GigabytesPerSecond => As(BitRateUnit.GigabytePerSecond);
+        public T GigabytesPerSecond => As(BitRateUnit.GigabytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in KibibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in KibibitsPerSecond.
         /// </summary>
-        public double KibibitsPerSecond => As(BitRateUnit.KibibitPerSecond);
+        public T KibibitsPerSecond => As(BitRateUnit.KibibitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in KibibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in KibibytesPerSecond.
         /// </summary>
-        public double KibibytesPerSecond => As(BitRateUnit.KibibytePerSecond);
+        public T KibibytesPerSecond => As(BitRateUnit.KibibytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in KilobitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in KilobitsPerSecond.
         /// </summary>
-        public double KilobitsPerSecond => As(BitRateUnit.KilobitPerSecond);
+        public T KilobitsPerSecond => As(BitRateUnit.KilobitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in KilobytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in KilobytesPerSecond.
         /// </summary>
-        public double KilobytesPerSecond => As(BitRateUnit.KilobytePerSecond);
+        public T KilobytesPerSecond => As(BitRateUnit.KilobytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in MebibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in MebibitsPerSecond.
         /// </summary>
-        public double MebibitsPerSecond => As(BitRateUnit.MebibitPerSecond);
+        public T MebibitsPerSecond => As(BitRateUnit.MebibitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in MebibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in MebibytesPerSecond.
         /// </summary>
-        public double MebibytesPerSecond => As(BitRateUnit.MebibytePerSecond);
+        public T MebibytesPerSecond => As(BitRateUnit.MebibytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in MegabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in MegabitsPerSecond.
         /// </summary>
-        public double MegabitsPerSecond => As(BitRateUnit.MegabitPerSecond);
+        public T MegabitsPerSecond => As(BitRateUnit.MegabitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in MegabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in MegabytesPerSecond.
         /// </summary>
-        public double MegabytesPerSecond => As(BitRateUnit.MegabytePerSecond);
+        public T MegabytesPerSecond => As(BitRateUnit.MegabytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in PebibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in PebibitsPerSecond.
         /// </summary>
-        public double PebibitsPerSecond => As(BitRateUnit.PebibitPerSecond);
+        public T PebibitsPerSecond => As(BitRateUnit.PebibitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in PebibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in PebibytesPerSecond.
         /// </summary>
-        public double PebibytesPerSecond => As(BitRateUnit.PebibytePerSecond);
+        public T PebibytesPerSecond => As(BitRateUnit.PebibytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in PetabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in PetabitsPerSecond.
         /// </summary>
-        public double PetabitsPerSecond => As(BitRateUnit.PetabitPerSecond);
+        public T PetabitsPerSecond => As(BitRateUnit.PetabitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in PetabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in PetabytesPerSecond.
         /// </summary>
-        public double PetabytesPerSecond => As(BitRateUnit.PetabytePerSecond);
+        public T PetabytesPerSecond => As(BitRateUnit.PetabytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in TebibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in TebibitsPerSecond.
         /// </summary>
-        public double TebibitsPerSecond => As(BitRateUnit.TebibitPerSecond);
+        public T TebibitsPerSecond => As(BitRateUnit.TebibitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in TebibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in TebibytesPerSecond.
         /// </summary>
-        public double TebibytesPerSecond => As(BitRateUnit.TebibytePerSecond);
+        public T TebibytesPerSecond => As(BitRateUnit.TebibytePerSecond);
 
         /// <summary>
-        ///     Get BitRate in TerabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in TerabitsPerSecond.
         /// </summary>
-        public double TerabitsPerSecond => As(BitRateUnit.TerabitPerSecond);
+        public T TerabitsPerSecond => As(BitRateUnit.TerabitPerSecond);
 
         /// <summary>
-        ///     Get BitRate in TerabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> in TerabytesPerSecond.
         /// </summary>
-        public double TerabytesPerSecond => As(BitRateUnit.TerabytePerSecond);
+        public T TerabytesPerSecond => As(BitRateUnit.TerabytePerSecond);
 
         #endregion
 
@@ -359,249 +355,223 @@ public static string GetAbbreviation(BitRateUnit unit, IFormatProvider? provider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get BitRate from BitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from BitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromBitsPerSecond(QuantityValue bitspersecond)
+        public static BitRate<T> FromBitsPerSecond(T bitspersecond)
         {
-            decimal value = (decimal) bitspersecond;
-            return new BitRate(value, BitRateUnit.BitPerSecond);
+            return new BitRate<T>(bitspersecond, BitRateUnit.BitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from BytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from BytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromBytesPerSecond(QuantityValue bytespersecond)
+        public static BitRate<T> FromBytesPerSecond(T bytespersecond)
         {
-            decimal value = (decimal) bytespersecond;
-            return new BitRate(value, BitRateUnit.BytePerSecond);
+            return new BitRate<T>(bytespersecond, BitRateUnit.BytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from ExabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from ExabitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExabitsPerSecond(QuantityValue exabitspersecond)
+        public static BitRate<T> FromExabitsPerSecond(T exabitspersecond)
         {
-            decimal value = (decimal) exabitspersecond;
-            return new BitRate(value, BitRateUnit.ExabitPerSecond);
+            return new BitRate<T>(exabitspersecond, BitRateUnit.ExabitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from ExabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from ExabytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExabytesPerSecond(QuantityValue exabytespersecond)
+        public static BitRate<T> FromExabytesPerSecond(T exabytespersecond)
         {
-            decimal value = (decimal) exabytespersecond;
-            return new BitRate(value, BitRateUnit.ExabytePerSecond);
+            return new BitRate<T>(exabytespersecond, BitRateUnit.ExabytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from ExbibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from ExbibitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExbibitsPerSecond(QuantityValue exbibitspersecond)
+        public static BitRate<T> FromExbibitsPerSecond(T exbibitspersecond)
         {
-            decimal value = (decimal) exbibitspersecond;
-            return new BitRate(value, BitRateUnit.ExbibitPerSecond);
+            return new BitRate<T>(exbibitspersecond, BitRateUnit.ExbibitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from ExbibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from ExbibytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExbibytesPerSecond(QuantityValue exbibytespersecond)
+        public static BitRate<T> FromExbibytesPerSecond(T exbibytespersecond)
         {
-            decimal value = (decimal) exbibytespersecond;
-            return new BitRate(value, BitRateUnit.ExbibytePerSecond);
+            return new BitRate<T>(exbibytespersecond, BitRateUnit.ExbibytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from GibibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from GibibitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGibibitsPerSecond(QuantityValue gibibitspersecond)
+        public static BitRate<T> FromGibibitsPerSecond(T gibibitspersecond)
         {
-            decimal value = (decimal) gibibitspersecond;
-            return new BitRate(value, BitRateUnit.GibibitPerSecond);
+            return new BitRate<T>(gibibitspersecond, BitRateUnit.GibibitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from GibibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from GibibytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGibibytesPerSecond(QuantityValue gibibytespersecond)
+        public static BitRate<T> FromGibibytesPerSecond(T gibibytespersecond)
         {
-            decimal value = (decimal) gibibytespersecond;
-            return new BitRate(value, BitRateUnit.GibibytePerSecond);
+            return new BitRate<T>(gibibytespersecond, BitRateUnit.GibibytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from GigabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from GigabitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGigabitsPerSecond(QuantityValue gigabitspersecond)
+        public static BitRate<T> FromGigabitsPerSecond(T gigabitspersecond)
         {
-            decimal value = (decimal) gigabitspersecond;
-            return new BitRate(value, BitRateUnit.GigabitPerSecond);
+            return new BitRate<T>(gigabitspersecond, BitRateUnit.GigabitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from GigabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from GigabytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGigabytesPerSecond(QuantityValue gigabytespersecond)
+        public static BitRate<T> FromGigabytesPerSecond(T gigabytespersecond)
         {
-            decimal value = (decimal) gigabytespersecond;
-            return new BitRate(value, BitRateUnit.GigabytePerSecond);
+            return new BitRate<T>(gigabytespersecond, BitRateUnit.GigabytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from KibibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from KibibitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKibibitsPerSecond(QuantityValue kibibitspersecond)
+        public static BitRate<T> FromKibibitsPerSecond(T kibibitspersecond)
         {
-            decimal value = (decimal) kibibitspersecond;
-            return new BitRate(value, BitRateUnit.KibibitPerSecond);
+            return new BitRate<T>(kibibitspersecond, BitRateUnit.KibibitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from KibibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from KibibytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKibibytesPerSecond(QuantityValue kibibytespersecond)
+        public static BitRate<T> FromKibibytesPerSecond(T kibibytespersecond)
         {
-            decimal value = (decimal) kibibytespersecond;
-            return new BitRate(value, BitRateUnit.KibibytePerSecond);
+            return new BitRate<T>(kibibytespersecond, BitRateUnit.KibibytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from KilobitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from KilobitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKilobitsPerSecond(QuantityValue kilobitspersecond)
+        public static BitRate<T> FromKilobitsPerSecond(T kilobitspersecond)
         {
-            decimal value = (decimal) kilobitspersecond;
-            return new BitRate(value, BitRateUnit.KilobitPerSecond);
+            return new BitRate<T>(kilobitspersecond, BitRateUnit.KilobitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from KilobytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from KilobytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKilobytesPerSecond(QuantityValue kilobytespersecond)
+        public static BitRate<T> FromKilobytesPerSecond(T kilobytespersecond)
         {
-            decimal value = (decimal) kilobytespersecond;
-            return new BitRate(value, BitRateUnit.KilobytePerSecond);
+            return new BitRate<T>(kilobytespersecond, BitRateUnit.KilobytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from MebibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from MebibitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMebibitsPerSecond(QuantityValue mebibitspersecond)
+        public static BitRate<T> FromMebibitsPerSecond(T mebibitspersecond)
         {
-            decimal value = (decimal) mebibitspersecond;
-            return new BitRate(value, BitRateUnit.MebibitPerSecond);
+            return new BitRate<T>(mebibitspersecond, BitRateUnit.MebibitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from MebibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from MebibytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMebibytesPerSecond(QuantityValue mebibytespersecond)
+        public static BitRate<T> FromMebibytesPerSecond(T mebibytespersecond)
         {
-            decimal value = (decimal) mebibytespersecond;
-            return new BitRate(value, BitRateUnit.MebibytePerSecond);
+            return new BitRate<T>(mebibytespersecond, BitRateUnit.MebibytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from MegabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from MegabitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMegabitsPerSecond(QuantityValue megabitspersecond)
+        public static BitRate<T> FromMegabitsPerSecond(T megabitspersecond)
         {
-            decimal value = (decimal) megabitspersecond;
-            return new BitRate(value, BitRateUnit.MegabitPerSecond);
+            return new BitRate<T>(megabitspersecond, BitRateUnit.MegabitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from MegabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from MegabytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMegabytesPerSecond(QuantityValue megabytespersecond)
+        public static BitRate<T> FromMegabytesPerSecond(T megabytespersecond)
         {
-            decimal value = (decimal) megabytespersecond;
-            return new BitRate(value, BitRateUnit.MegabytePerSecond);
+            return new BitRate<T>(megabytespersecond, BitRateUnit.MegabytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from PebibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from PebibitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPebibitsPerSecond(QuantityValue pebibitspersecond)
+        public static BitRate<T> FromPebibitsPerSecond(T pebibitspersecond)
         {
-            decimal value = (decimal) pebibitspersecond;
-            return new BitRate(value, BitRateUnit.PebibitPerSecond);
+            return new BitRate<T>(pebibitspersecond, BitRateUnit.PebibitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from PebibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from PebibytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPebibytesPerSecond(QuantityValue pebibytespersecond)
+        public static BitRate<T> FromPebibytesPerSecond(T pebibytespersecond)
         {
-            decimal value = (decimal) pebibytespersecond;
-            return new BitRate(value, BitRateUnit.PebibytePerSecond);
+            return new BitRate<T>(pebibytespersecond, BitRateUnit.PebibytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from PetabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from PetabitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPetabitsPerSecond(QuantityValue petabitspersecond)
+        public static BitRate<T> FromPetabitsPerSecond(T petabitspersecond)
         {
-            decimal value = (decimal) petabitspersecond;
-            return new BitRate(value, BitRateUnit.PetabitPerSecond);
+            return new BitRate<T>(petabitspersecond, BitRateUnit.PetabitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from PetabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from PetabytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPetabytesPerSecond(QuantityValue petabytespersecond)
+        public static BitRate<T> FromPetabytesPerSecond(T petabytespersecond)
         {
-            decimal value = (decimal) petabytespersecond;
-            return new BitRate(value, BitRateUnit.PetabytePerSecond);
+            return new BitRate<T>(petabytespersecond, BitRateUnit.PetabytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from TebibitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from TebibitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTebibitsPerSecond(QuantityValue tebibitspersecond)
+        public static BitRate<T> FromTebibitsPerSecond(T tebibitspersecond)
         {
-            decimal value = (decimal) tebibitspersecond;
-            return new BitRate(value, BitRateUnit.TebibitPerSecond);
+            return new BitRate<T>(tebibitspersecond, BitRateUnit.TebibitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from TebibytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from TebibytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTebibytesPerSecond(QuantityValue tebibytespersecond)
+        public static BitRate<T> FromTebibytesPerSecond(T tebibytespersecond)
         {
-            decimal value = (decimal) tebibytespersecond;
-            return new BitRate(value, BitRateUnit.TebibytePerSecond);
+            return new BitRate<T>(tebibytespersecond, BitRateUnit.TebibytePerSecond);
         }
         /// <summary>
-        ///     Get BitRate from TerabitsPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from TerabitsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTerabitsPerSecond(QuantityValue terabitspersecond)
+        public static BitRate<T> FromTerabitsPerSecond(T terabitspersecond)
         {
-            decimal value = (decimal) terabitspersecond;
-            return new BitRate(value, BitRateUnit.TerabitPerSecond);
+            return new BitRate<T>(terabitspersecond, BitRateUnit.TerabitPerSecond);
         }
         /// <summary>
-        ///     Get BitRate from TerabytesPerSecond.
+        ///     Get <see cref="BitRate{T}" /> from TerabytesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTerabytesPerSecond(QuantityValue terabytespersecond)
+        public static BitRate<T> FromTerabytesPerSecond(T terabytespersecond)
         {
-            decimal value = (decimal) terabytespersecond;
-            return new BitRate(value, BitRateUnit.TerabytePerSecond);
+            return new BitRate<T>(terabytespersecond, BitRateUnit.TerabytePerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="BitRateUnit" /> to <see cref="BitRate" />.
+        ///     Dynamically convert from value and unit enum <see cref="BitRateUnit" /> to <see cref="BitRate{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>BitRate unit value.</returns>
-        public static BitRate From(QuantityValue value, BitRateUnit fromUnit)
+        /// <returns><see cref="BitRate{T}" /> unit value.</returns>
+        public static BitRate<T> From(T value, BitRateUnit fromUnit)
         {
-            return new BitRate((decimal)value, fromUnit);
+            return new BitRate<T>(value, fromUnit);
         }
 
         #endregion
@@ -630,7 +600,7 @@ public static BitRate From(QuantityValue value, BitRateUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static BitRate Parse(string str)
+        public static BitRate<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -658,9 +628,9 @@ public static BitRate Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static BitRate Parse(string str, IFormatProvider? provider)
+        public static BitRate<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<BitRate, BitRateUnit>(
+            return QuantityParser.Default.Parse<T, BitRate<T>, BitRateUnit>(
                 str,
                 provider,
                 From);
@@ -674,7 +644,7 @@ public static BitRate Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out BitRate result)
+        public static bool TryParse(string? str, out BitRate<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -689,9 +659,9 @@ public static bool TryParse(string? str, out BitRate result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out BitRate result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out BitRate<T> result)
         {
-            return QuantityParser.Default.TryParse<BitRate, BitRateUnit>(
+            return QuantityParser.Default.TryParse<T, BitRate<T>, BitRateUnit>(
                 str,
                 provider,
                 From,
@@ -753,45 +723,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out BitRa
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static BitRate operator -(BitRate right)
+        public static BitRate<T> operator -(BitRate<T> right)
         {
-            return new BitRate(-right.Value, right.Unit);
+            return new BitRate<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="BitRate"/> from adding two <see cref="BitRate"/>.</summary>
-        public static BitRate operator +(BitRate left, BitRate right)
+        /// <summary>Get <see cref="BitRate{T}"/> from adding two <see cref="BitRate{T}"/>.</summary>
+        public static BitRate<T> operator +(BitRate<T> left, BitRate<T> right)
         {
-            return new BitRate(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new BitRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="BitRate"/> from subtracting two <see cref="BitRate"/>.</summary>
-        public static BitRate operator -(BitRate left, BitRate right)
+        /// <summary>Get <see cref="BitRate{T}"/> from subtracting two <see cref="BitRate{T}"/>.</summary>
+        public static BitRate<T> operator -(BitRate<T> left, BitRate<T> right)
         {
-            return new BitRate(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new BitRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="BitRate"/> from multiplying value and <see cref="BitRate"/>.</summary>
-        public static BitRate operator *(decimal left, BitRate right)
+        /// <summary>Get <see cref="BitRate{T}"/> from multiplying value and <see cref="BitRate{T}"/>.</summary>
+        public static BitRate<T> operator *(T left, BitRate<T> right)
         {
-            return new BitRate(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new BitRate<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="BitRate"/> from multiplying value and <see cref="BitRate"/>.</summary>
-        public static BitRate operator *(BitRate left, decimal right)
+        /// <summary>Get <see cref="BitRate{T}"/> from multiplying value and <see cref="BitRate{T}"/>.</summary>
+        public static BitRate<T> operator *(BitRate<T> left, T right)
         {
-            return new BitRate(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new BitRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="BitRate"/> from dividing <see cref="BitRate"/> by value.</summary>
-        public static BitRate operator /(BitRate left, decimal right)
+        /// <summary>Get <see cref="BitRate{T}"/> from dividing <see cref="BitRate{T}"/> by value.</summary>
+        public static BitRate<T> operator /(BitRate<T> left, T right)
         {
-            return new BitRate(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new BitRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="BitRate"/> by <see cref="BitRate"/>.</summary>
-        public static double operator /(BitRate left, BitRate right)
+        /// <summary>Get ratio value from dividing <see cref="BitRate{T}"/> by <see cref="BitRate{T}"/>.</summary>
+        public static T operator /(BitRate<T> left, BitRate<T> right)
         {
-            return left.BitsPerSecond / right.BitsPerSecond;
+            return CompiledLambdas.Divide(left.BitsPerSecond, right.BitsPerSecond);
         }
 
         #endregion
@@ -799,39 +774,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out BitRa
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(BitRate left, BitRate right)
+        public static bool operator <=(BitRate<T> left, BitRate<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(BitRate left, BitRate right)
+        public static bool operator >=(BitRate<T> left, BitRate<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(BitRate left, BitRate right)
+        public static bool operator <(BitRate<T> left, BitRate<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(BitRate left, BitRate right)
+        public static bool operator >(BitRate<T> left, BitRate<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(BitRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(BitRate left, BitRate right)
+        /// <remarks>Consider using <see cref="Equals(BitRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(BitRate<T> left, BitRate<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(BitRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(BitRate left, BitRate right)
+        /// <remarks>Consider using <see cref="Equals(BitRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(BitRate<T> left, BitRate<T> right)
         {
             return !(left == right);
         }
@@ -840,37 +815,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out BitRa
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is BitRate objBitRate)) throw new ArgumentException("Expected type BitRate.", nameof(obj));
+            if(!(obj is BitRate<T> objBitRate)) throw new ArgumentException("Expected type BitRate.", nameof(obj));
 
             return CompareTo(objBitRate);
         }
 
         /// <inheritdoc />
-        public int CompareTo(BitRate other)
+        public int CompareTo(BitRate<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(BitRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(BitRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is BitRate objBitRate))
+            if(obj is null || !(obj is BitRate<T> objBitRate))
                 return false;
 
             return Equals(objBitRate);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(BitRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(BitRate other)
+        /// <remarks>Consider using <see cref="Equals(BitRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(BitRate<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another BitRate within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="BitRate{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -908,21 +883,19 @@ public bool Equals(BitRate other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(BitRate other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(BitRate<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current BitRate.</returns>
+        /// <returns>A hash code for the current <see cref="BitRate{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -936,17 +909,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(BitRateUnit unit)
+        public T As(BitRateUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -966,17 +939,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is BitRateUnit unitAsBitRateUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BitRateUnit)} is supported.", nameof(unit));
 
-            return As(unitAsBitRateUnit);
+            var asValue = As(unitAsBitRateUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<BitRateUnit>.As(BitRateUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this BitRate to another BitRate with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="BitRate{T}" /> to another <see cref="BitRate{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A BitRate with the specified unit.</returns>
-        public BitRate ToUnit(BitRateUnit unit)
+        /// <returns>A <see cref="BitRate{T}" /> with the specified unit.</returns>
+        public BitRate<T> ToUnit(BitRateUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new BitRate(convertedValue, unit);
+            return new BitRate<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -989,7 +967,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public BitRate ToUnit(UnitSystem unitSystem)
+        public BitRate<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1009,44 +987,50 @@ public BitRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<BitRateUnit> IQuantity<BitRateUnit>.ToUnit(BitRateUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<BitRateUnit, T> IQuantityT<BitRateUnit, T>.ToUnit(BitRateUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<BitRateUnit> IQuantity<BitRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<BitRateUnit, T> IQuantityT<BitRateUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private decimal GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case BitRateUnit.BitPerSecond: return _value;
-                case BitRateUnit.BytePerSecond: return _value*8m;
-                case BitRateUnit.ExabitPerSecond: return (_value) * 1e18m;
-                case BitRateUnit.ExabytePerSecond: return (_value*8m) * 1e18m;
-                case BitRateUnit.ExbibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
-                case BitRateUnit.ExbibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
-                case BitRateUnit.GibibitPerSecond: return (_value) * (1024m * 1024 * 1024);
-                case BitRateUnit.GibibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024);
-                case BitRateUnit.GigabitPerSecond: return (_value) * 1e9m;
-                case BitRateUnit.GigabytePerSecond: return (_value*8m) * 1e9m;
-                case BitRateUnit.KibibitPerSecond: return (_value) * 1024m;
-                case BitRateUnit.KibibytePerSecond: return (_value*8m) * 1024m;
-                case BitRateUnit.KilobitPerSecond: return (_value) * 1e3m;
-                case BitRateUnit.KilobytePerSecond: return (_value*8m) * 1e3m;
-                case BitRateUnit.MebibitPerSecond: return (_value) * (1024m * 1024);
-                case BitRateUnit.MebibytePerSecond: return (_value*8m) * (1024m * 1024);
-                case BitRateUnit.MegabitPerSecond: return (_value) * 1e6m;
-                case BitRateUnit.MegabytePerSecond: return (_value*8m) * 1e6m;
-                case BitRateUnit.PebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024);
-                case BitRateUnit.PebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024);
-                case BitRateUnit.PetabitPerSecond: return (_value) * 1e15m;
-                case BitRateUnit.PetabytePerSecond: return (_value*8m) * 1e15m;
-                case BitRateUnit.TebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024);
-                case BitRateUnit.TebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024);
-                case BitRateUnit.TerabitPerSecond: return (_value) * 1e12m;
-                case BitRateUnit.TerabytePerSecond: return (_value*8m) * 1e12m;
+                case BitRateUnit.BitPerSecond: return Value;
+                case BitRateUnit.BytePerSecond: return Value*8m;
+                case BitRateUnit.ExabitPerSecond: return (Value) * 1e18m;
+                case BitRateUnit.ExabytePerSecond: return (Value*8m) * 1e18m;
+                case BitRateUnit.ExbibitPerSecond: return (Value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
+                case BitRateUnit.ExbibytePerSecond: return (Value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
+                case BitRateUnit.GibibitPerSecond: return (Value) * (1024m * 1024 * 1024);
+                case BitRateUnit.GibibytePerSecond: return (Value*8m) * (1024m * 1024 * 1024);
+                case BitRateUnit.GigabitPerSecond: return (Value) * 1e9m;
+                case BitRateUnit.GigabytePerSecond: return (Value*8m) * 1e9m;
+                case BitRateUnit.KibibitPerSecond: return (Value) * 1024m;
+                case BitRateUnit.KibibytePerSecond: return (Value*8m) * 1024m;
+                case BitRateUnit.KilobitPerSecond: return (Value) * 1e3m;
+                case BitRateUnit.KilobytePerSecond: return (Value*8m) * 1e3m;
+                case BitRateUnit.MebibitPerSecond: return (Value) * (1024m * 1024);
+                case BitRateUnit.MebibytePerSecond: return (Value*8m) * (1024m * 1024);
+                case BitRateUnit.MegabitPerSecond: return (Value) * 1e6m;
+                case BitRateUnit.MegabytePerSecond: return (Value*8m) * 1e6m;
+                case BitRateUnit.PebibitPerSecond: return (Value) * (1024m * 1024 * 1024 * 1024 * 1024);
+                case BitRateUnit.PebibytePerSecond: return (Value*8m) * (1024m * 1024 * 1024 * 1024 * 1024);
+                case BitRateUnit.PetabitPerSecond: return (Value) * 1e15m;
+                case BitRateUnit.PetabytePerSecond: return (Value*8m) * 1e15m;
+                case BitRateUnit.TebibitPerSecond: return (Value) * (1024m * 1024 * 1024 * 1024);
+                case BitRateUnit.TebibytePerSecond: return (Value*8m) * (1024m * 1024 * 1024 * 1024);
+                case BitRateUnit.TerabitPerSecond: return (Value) * 1e12m;
+                case BitRateUnit.TerabytePerSecond: return (Value*8m) * 1e12m;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1057,16 +1041,16 @@ private decimal GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal BitRate ToBaseUnit()
+        internal BitRate<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new BitRate(baseUnitValue, BaseUnit);
+            return new BitRate<T>(baseUnitValue, BaseUnit);
         }
 
-        private decimal GetValueAs(BitRateUnit unit)
+        private T GetValueAs(BitRateUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1194,57 +1178,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(BitRate)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(BitRate<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(BitRate)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(BitRate<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(BitRate)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(BitRate<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1254,33 +1238,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(BitRate))
+            if(conversionType == typeof(BitRate<T>))
                 return this;
             else if(conversionType == typeof(BitRateUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return BitRate.QuantityType;
+                return BitRate<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return BitRate.Info;
+                return BitRate<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return BitRate.BaseDimensions;
+                return BitRate<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(BitRate)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(BitRate<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
index 6716f2a13a..55a29a88a0 100644
--- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Brake specific fuel consumption (BSFC) is a measure of the fuel efficiency of any prime mover that burns fuel and produces rotational, or shaft, power. It is typically used for comparing the efficiency of internal combustion engines with a shaft output.
     /// </summary>
-    public partial struct BrakeSpecificFuelConsumption : IQuantity<BrakeSpecificFuelConsumptionUnit>, IEquatable<BrakeSpecificFuelConsumption>, IComparable, IComparable<BrakeSpecificFuelConsumption>, IConvertible, IFormattable
+    public partial struct BrakeSpecificFuelConsumption<T> : IQuantityT<BrakeSpecificFuelConsumptionUnit, T>, IEquatable<BrakeSpecificFuelConsumption<T>>, IComparable, IComparable<BrakeSpecificFuelConsumption<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static BrakeSpecificFuelConsumption()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public BrakeSpecificFuelConsumption(double value, BrakeSpecificFuelConsumptionUnit unit)
+        public BrakeSpecificFuelConsumption(T value, BrakeSpecificFuelConsumptionUnit unit)
         {
             if(unit == BrakeSpecificFuelConsumptionUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public BrakeSpecificFuelConsumption(double value, BrakeSpecificFuelConsumptionUn
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
+        public BrakeSpecificFuelConsumption(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of BrakeSpecificFuelConsumption, which is KilogramPerJoule. All conversions go via this value.
+        ///     The base unit of <see cref="BrakeSpecificFuelConsumption{T}" />, which is KilogramPerJoule. All conversions go via this value.
         /// </summary>
         public static BrakeSpecificFuelConsumptionUnit BaseUnit { get; } = BrakeSpecificFuelConsumptionUnit.KilogramPerJoule;
 
         /// <summary>
-        /// Represents the largest possible value of BrakeSpecificFuelConsumption
+        /// Represents the largest possible value of <see cref="BrakeSpecificFuelConsumption{T}" />
         /// </summary>
-        public static BrakeSpecificFuelConsumption MaxValue { get; } = new BrakeSpecificFuelConsumption(double.MaxValue, BaseUnit);
+        public static BrakeSpecificFuelConsumption<T> MaxValue { get; } = new BrakeSpecificFuelConsumption<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of BrakeSpecificFuelConsumption
+        /// Represents the smallest possible value of <see cref="BrakeSpecificFuelConsumption{T}" />
         /// </summary>
-        public static BrakeSpecificFuelConsumption MinValue { get; } = new BrakeSpecificFuelConsumption(double.MinValue, BaseUnit);
+        public static BrakeSpecificFuelConsumption<T> MinValue { get; } = new BrakeSpecificFuelConsumption<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.BrakeSpecificFuelConsumption;
 
         /// <summary>
-        ///     All units of measurement for the BrakeSpecificFuelConsumption quantity.
+        ///     All units of measurement for the <see cref="BrakeSpecificFuelConsumption{T}" /> quantity.
         /// </summary>
         public static BrakeSpecificFuelConsumptionUnit[] Units { get; } = Enum.GetValues(typeof(BrakeSpecificFuelConsumptionUnit)).Cast<BrakeSpecificFuelConsumptionUnit>().Except(new BrakeSpecificFuelConsumptionUnit[]{ BrakeSpecificFuelConsumptionUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramPerJoule.
         /// </summary>
-        public static BrakeSpecificFuelConsumption Zero { get; } = new BrakeSpecificFuelConsumption(0, BaseUnit);
+        public static BrakeSpecificFuelConsumption<T> Zero { get; } = new BrakeSpecificFuelConsumption<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => BrakeSpecificFuelConsumption.QuantityType;
+        public QuantityType Type => BrakeSpecificFuelConsumption<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => BrakeSpecificFuelConsumption.BaseDimensions;
+        public BaseDimensions Dimensions => BrakeSpecificFuelConsumption<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get BrakeSpecificFuelConsumption in GramsPerKiloWattHour.
+        ///     Get <see cref="BrakeSpecificFuelConsumption{T}" /> in GramsPerKiloWattHour.
         /// </summary>
-        public double GramsPerKiloWattHour => As(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
+        public T GramsPerKiloWattHour => As(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
 
         /// <summary>
-        ///     Get BrakeSpecificFuelConsumption in KilogramsPerJoule.
+        ///     Get <see cref="BrakeSpecificFuelConsumption{T}" /> in KilogramsPerJoule.
         /// </summary>
-        public double KilogramsPerJoule => As(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
+        public T KilogramsPerJoule => As(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
 
         /// <summary>
-        ///     Get BrakeSpecificFuelConsumption in PoundsPerMechanicalHorsepowerHour.
+        ///     Get <see cref="BrakeSpecificFuelConsumption{T}" /> in PoundsPerMechanicalHorsepowerHour.
         /// </summary>
-        public double PoundsPerMechanicalHorsepowerHour => As(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
+        public T PoundsPerMechanicalHorsepowerHour => As(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(BrakeSpecificFuelConsumptionUnit unit, IFor
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get BrakeSpecificFuelConsumption from GramsPerKiloWattHour.
+        ///     Get <see cref="BrakeSpecificFuelConsumption{T}" /> from GramsPerKiloWattHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(QuantityValue gramsperkilowatthour)
+        public static BrakeSpecificFuelConsumption<T> FromGramsPerKiloWattHour(T gramsperkilowatthour)
         {
-            double value = (double) gramsperkilowatthour;
-            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
+            return new BrakeSpecificFuelConsumption<T>(gramsperkilowatthour, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
         }
         /// <summary>
-        ///     Get BrakeSpecificFuelConsumption from KilogramsPerJoule.
+        ///     Get <see cref="BrakeSpecificFuelConsumption{T}" /> from KilogramsPerJoule.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(QuantityValue kilogramsperjoule)
+        public static BrakeSpecificFuelConsumption<T> FromKilogramsPerJoule(T kilogramsperjoule)
         {
-            double value = (double) kilogramsperjoule;
-            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
+            return new BrakeSpecificFuelConsumption<T>(kilogramsperjoule, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
         }
         /// <summary>
-        ///     Get BrakeSpecificFuelConsumption from PoundsPerMechanicalHorsepowerHour.
+        ///     Get <see cref="BrakeSpecificFuelConsumption{T}" /> from PoundsPerMechanicalHorsepowerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(QuantityValue poundspermechanicalhorsepowerhour)
+        public static BrakeSpecificFuelConsumption<T> FromPoundsPerMechanicalHorsepowerHour(T poundspermechanicalhorsepowerhour)
         {
-            double value = (double) poundspermechanicalhorsepowerhour;
-            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
+            return new BrakeSpecificFuelConsumption<T>(poundspermechanicalhorsepowerhour, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="BrakeSpecificFuelConsumptionUnit" /> to <see cref="BrakeSpecificFuelConsumption" />.
+        ///     Dynamically convert from value and unit enum <see cref="BrakeSpecificFuelConsumptionUnit" /> to <see cref="BrakeSpecificFuelConsumption{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>BrakeSpecificFuelConsumption unit value.</returns>
-        public static BrakeSpecificFuelConsumption From(QuantityValue value, BrakeSpecificFuelConsumptionUnit fromUnit)
+        /// <returns><see cref="BrakeSpecificFuelConsumption{T}" /> unit value.</returns>
+        public static BrakeSpecificFuelConsumption<T> From(T value, BrakeSpecificFuelConsumptionUnit fromUnit)
         {
-            return new BrakeSpecificFuelConsumption((double)value, fromUnit);
+            return new BrakeSpecificFuelConsumption<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static BrakeSpecificFuelConsumption From(QuantityValue value, BrakeSpecif
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static BrakeSpecificFuelConsumption Parse(string str)
+        public static BrakeSpecificFuelConsumption<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static BrakeSpecificFuelConsumption Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static BrakeSpecificFuelConsumption Parse(string str, IFormatProvider? provider)
+        public static BrakeSpecificFuelConsumption<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>(
+            return QuantityParser.Default.Parse<T, BrakeSpecificFuelConsumption<T>, BrakeSpecificFuelConsumptionUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static BrakeSpecificFuelConsumption Parse(string str, IFormatProvider? pr
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out BrakeSpecificFuelConsumption result)
+        public static bool TryParse(string? str, out BrakeSpecificFuelConsumption<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out BrakeSpecificFuelConsumption result
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out BrakeSpecificFuelConsumption result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out BrakeSpecificFuelConsumption<T> result)
         {
-            return QuantityParser.Default.TryParse<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>(
+            return QuantityParser.Default.TryParse<T, BrakeSpecificFuelConsumption<T>, BrakeSpecificFuelConsumptionUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Brake
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static BrakeSpecificFuelConsumption operator -(BrakeSpecificFuelConsumption right)
+        public static BrakeSpecificFuelConsumption<T> operator -(BrakeSpecificFuelConsumption<T> right)
         {
-            return new BrakeSpecificFuelConsumption(-right.Value, right.Unit);
+            return new BrakeSpecificFuelConsumption<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from adding two <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator +(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption{T}"/> from adding two <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static BrakeSpecificFuelConsumption<T> operator +(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
-            return new BrakeSpecificFuelConsumption(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new BrakeSpecificFuelConsumption<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from subtracting two <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator -(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption{T}"/> from subtracting two <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static BrakeSpecificFuelConsumption<T> operator -(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
-            return new BrakeSpecificFuelConsumption(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new BrakeSpecificFuelConsumption<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from multiplying value and <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator *(double left, BrakeSpecificFuelConsumption right)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption{T}"/> from multiplying value and <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static BrakeSpecificFuelConsumption<T> operator *(T left, BrakeSpecificFuelConsumption<T> right)
         {
-            return new BrakeSpecificFuelConsumption(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new BrakeSpecificFuelConsumption<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from multiplying value and <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator *(BrakeSpecificFuelConsumption left, double right)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption{T}"/> from multiplying value and <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static BrakeSpecificFuelConsumption<T> operator *(BrakeSpecificFuelConsumption<T> left, T right)
         {
-            return new BrakeSpecificFuelConsumption(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new BrakeSpecificFuelConsumption<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from dividing <see cref="BrakeSpecificFuelConsumption"/> by value.</summary>
-        public static BrakeSpecificFuelConsumption operator /(BrakeSpecificFuelConsumption left, double right)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption{T}"/> from dividing <see cref="BrakeSpecificFuelConsumption{T}"/> by value.</summary>
+        public static BrakeSpecificFuelConsumption<T> operator /(BrakeSpecificFuelConsumption<T> left, T right)
         {
-            return new BrakeSpecificFuelConsumption(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new BrakeSpecificFuelConsumption<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="BrakeSpecificFuelConsumption"/> by <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static double operator /(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        /// <summary>Get ratio value from dividing <see cref="BrakeSpecificFuelConsumption{T}"/> by <see cref="BrakeSpecificFuelConsumption{T}"/>.</summary>
+        public static T operator /(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
-            return left.KilogramsPerJoule / right.KilogramsPerJoule;
+            return CompiledLambdas.Divide(left.KilogramsPerJoule, right.KilogramsPerJoule);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Brake
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        public static bool operator <=(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        public static bool operator >=(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        public static bool operator <(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        public static bool operator >(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(BrakeSpecificFuelConsumption<T> left, BrakeSpecificFuelConsumption<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Brake
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is BrakeSpecificFuelConsumption objBrakeSpecificFuelConsumption)) throw new ArgumentException("Expected type BrakeSpecificFuelConsumption.", nameof(obj));
+            if(!(obj is BrakeSpecificFuelConsumption<T> objBrakeSpecificFuelConsumption)) throw new ArgumentException("Expected type BrakeSpecificFuelConsumption.", nameof(obj));
 
             return CompareTo(objBrakeSpecificFuelConsumption);
         }
 
         /// <inheritdoc />
-        public int CompareTo(BrakeSpecificFuelConsumption other)
+        public int CompareTo(BrakeSpecificFuelConsumption<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is BrakeSpecificFuelConsumption objBrakeSpecificFuelConsumption))
+            if(obj is null || !(obj is BrakeSpecificFuelConsumption<T> objBrakeSpecificFuelConsumption))
                 return false;
 
             return Equals(objBrakeSpecificFuelConsumption);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(BrakeSpecificFuelConsumption other)
+        /// <remarks>Consider using <see cref="Equals(BrakeSpecificFuelConsumption{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(BrakeSpecificFuelConsumption<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another BrakeSpecificFuelConsumption within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="BrakeSpecificFuelConsumption{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(BrakeSpecificFuelConsumption other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(BrakeSpecificFuelConsumption other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(BrakeSpecificFuelConsumption<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current BrakeSpecificFuelConsumption.</returns>
+        /// <returns>A hash code for the current <see cref="BrakeSpecificFuelConsumption{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(BrakeSpecificFuelConsumptionUnit unit)
+        public T As(BrakeSpecificFuelConsumptionUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is BrakeSpecificFuelConsumptionUnit unitAsBrakeSpecificFuelConsumptionUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BrakeSpecificFuelConsumptionUnit)} is supported.", nameof(unit));
 
-            return As(unitAsBrakeSpecificFuelConsumptionUnit);
+            var asValue = As(unitAsBrakeSpecificFuelConsumptionUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<BrakeSpecificFuelConsumptionUnit>.As(BrakeSpecificFuelConsumptionUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this BrakeSpecificFuelConsumption to another BrakeSpecificFuelConsumption with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="BrakeSpecificFuelConsumption{T}" /> to another <see cref="BrakeSpecificFuelConsumption{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A BrakeSpecificFuelConsumption with the specified unit.</returns>
-        public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit)
+        /// <returns>A <see cref="BrakeSpecificFuelConsumption{T}" /> with the specified unit.</returns>
+        public BrakeSpecificFuelConsumption<T> ToUnit(BrakeSpecificFuelConsumptionUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new BrakeSpecificFuelConsumption(convertedValue, unit);
+            return new BrakeSpecificFuelConsumption<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public BrakeSpecificFuelConsumption ToUnit(UnitSystem unitSystem)
+        public BrakeSpecificFuelConsumption<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public BrakeSpecificFuelConsumption ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<BrakeSpecificFuelConsumptionUnit> IQuantity<BrakeSpecificFuelConsumptionUnit>.ToUnit(BrakeSpecificFuelConsumptionUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<BrakeSpecificFuelConsumptionUnit, T> IQuantityT<BrakeSpecificFuelConsumptionUnit, T>.ToUnit(BrakeSpecificFuelConsumptionUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<BrakeSpecificFuelConsumptionUnit> IQuantity<BrakeSpecificFuelConsumptionUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<BrakeSpecificFuelConsumptionUnit, T> IQuantityT<BrakeSpecificFuelConsumptionUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: return _value/3.6e9;
-                case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: return _value;
-                case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: return _value*1.689659410672e-7;
+                case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: return Value/3.6e9;
+                case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: return Value;
+                case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: return Value*1.689659410672e-7;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal BrakeSpecificFuelConsumption ToBaseUnit()
+        internal BrakeSpecificFuelConsumption<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new BrakeSpecificFuelConsumption(baseUnitValue, BaseUnit);
+            return new BrakeSpecificFuelConsumption<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(BrakeSpecificFuelConsumptionUnit unit)
+        private T GetValueAs(BrakeSpecificFuelConsumptionUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(BrakeSpecificFuelConsumption))
+            if(conversionType == typeof(BrakeSpecificFuelConsumption<T>))
                 return this;
             else if(conversionType == typeof(BrakeSpecificFuelConsumptionUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return BrakeSpecificFuelConsumption.QuantityType;
+                return BrakeSpecificFuelConsumption<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return BrakeSpecificFuelConsumption.Info;
+                return BrakeSpecificFuelConsumption<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return BrakeSpecificFuelConsumption.BaseDimensions;
+                return BrakeSpecificFuelConsumption<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(BrakeSpecificFuelConsumption<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
index fc51d0b5d2..52b214b78f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Capacitance
     /// </remarks>
-    public partial struct Capacitance : IQuantity<CapacitanceUnit>, IEquatable<Capacitance>, IComparable, IComparable<Capacitance>, IConvertible, IFormattable
+    public partial struct Capacitance<T> : IQuantityT<CapacitanceUnit, T>, IEquatable<Capacitance<T>>, IComparable, IComparable<Capacitance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -72,12 +68,12 @@ static Capacitance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Capacitance(double value, CapacitanceUnit unit)
+        public Capacitance(T value, CapacitanceUnit unit)
         {
             if(unit == CapacitanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -89,14 +85,14 @@ public Capacitance(double value, CapacitanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Capacitance(double value, UnitSystem unitSystem)
+        public Capacitance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -111,19 +107,19 @@ public Capacitance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Capacitance, which is Farad. All conversions go via this value.
+        ///     The base unit of <see cref="Capacitance{T}" />, which is Farad. All conversions go via this value.
         /// </summary>
         public static CapacitanceUnit BaseUnit { get; } = CapacitanceUnit.Farad;
 
         /// <summary>
-        /// Represents the largest possible value of Capacitance
+        /// Represents the largest possible value of <see cref="Capacitance{T}" />
         /// </summary>
-        public static Capacitance MaxValue { get; } = new Capacitance(double.MaxValue, BaseUnit);
+        public static Capacitance<T> MaxValue { get; } = new Capacitance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Capacitance
+        /// Represents the smallest possible value of <see cref="Capacitance{T}" />
         /// </summary>
-        public static Capacitance MinValue { get; } = new Capacitance(double.MinValue, BaseUnit);
+        public static Capacitance<T> MinValue { get; } = new Capacitance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -132,14 +128,14 @@ public Capacitance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Capacitance;
 
         /// <summary>
-        ///     All units of measurement for the Capacitance quantity.
+        ///     All units of measurement for the <see cref="Capacitance{T}" /> quantity.
         /// </summary>
         public static CapacitanceUnit[] Units { get; } = Enum.GetValues(typeof(CapacitanceUnit)).Cast<CapacitanceUnit>().Except(new CapacitanceUnit[]{ CapacitanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Farad.
         /// </summary>
-        public static Capacitance Zero { get; } = new Capacitance(0, BaseUnit);
+        public static Capacitance<T> Zero { get; } = new Capacitance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -148,7 +144,9 @@ public Capacitance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -164,51 +162,51 @@ public Capacitance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Capacitance.QuantityType;
+        public QuantityType Type => Capacitance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Capacitance.BaseDimensions;
+        public BaseDimensions Dimensions => Capacitance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Capacitance in Farads.
+        ///     Get <see cref="Capacitance{T}" /> in Farads.
         /// </summary>
-        public double Farads => As(CapacitanceUnit.Farad);
+        public T Farads => As(CapacitanceUnit.Farad);
 
         /// <summary>
-        ///     Get Capacitance in Kilofarads.
+        ///     Get <see cref="Capacitance{T}" /> in Kilofarads.
         /// </summary>
-        public double Kilofarads => As(CapacitanceUnit.Kilofarad);
+        public T Kilofarads => As(CapacitanceUnit.Kilofarad);
 
         /// <summary>
-        ///     Get Capacitance in Megafarads.
+        ///     Get <see cref="Capacitance{T}" /> in Megafarads.
         /// </summary>
-        public double Megafarads => As(CapacitanceUnit.Megafarad);
+        public T Megafarads => As(CapacitanceUnit.Megafarad);
 
         /// <summary>
-        ///     Get Capacitance in Microfarads.
+        ///     Get <see cref="Capacitance{T}" /> in Microfarads.
         /// </summary>
-        public double Microfarads => As(CapacitanceUnit.Microfarad);
+        public T Microfarads => As(CapacitanceUnit.Microfarad);
 
         /// <summary>
-        ///     Get Capacitance in Millifarads.
+        ///     Get <see cref="Capacitance{T}" /> in Millifarads.
         /// </summary>
-        public double Millifarads => As(CapacitanceUnit.Millifarad);
+        public T Millifarads => As(CapacitanceUnit.Millifarad);
 
         /// <summary>
-        ///     Get Capacitance in Nanofarads.
+        ///     Get <see cref="Capacitance{T}" /> in Nanofarads.
         /// </summary>
-        public double Nanofarads => As(CapacitanceUnit.Nanofarad);
+        public T Nanofarads => As(CapacitanceUnit.Nanofarad);
 
         /// <summary>
-        ///     Get Capacitance in Picofarads.
+        ///     Get <see cref="Capacitance{T}" /> in Picofarads.
         /// </summary>
-        public double Picofarads => As(CapacitanceUnit.Picofarad);
+        public T Picofarads => As(CapacitanceUnit.Picofarad);
 
         #endregion
 
@@ -240,78 +238,71 @@ public static string GetAbbreviation(CapacitanceUnit unit, IFormatProvider? prov
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Capacitance from Farads.
+        ///     Get <see cref="Capacitance{T}" /> from Farads.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromFarads(QuantityValue farads)
+        public static Capacitance<T> FromFarads(T farads)
         {
-            double value = (double) farads;
-            return new Capacitance(value, CapacitanceUnit.Farad);
+            return new Capacitance<T>(farads, CapacitanceUnit.Farad);
         }
         /// <summary>
-        ///     Get Capacitance from Kilofarads.
+        ///     Get <see cref="Capacitance{T}" /> from Kilofarads.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromKilofarads(QuantityValue kilofarads)
+        public static Capacitance<T> FromKilofarads(T kilofarads)
         {
-            double value = (double) kilofarads;
-            return new Capacitance(value, CapacitanceUnit.Kilofarad);
+            return new Capacitance<T>(kilofarads, CapacitanceUnit.Kilofarad);
         }
         /// <summary>
-        ///     Get Capacitance from Megafarads.
+        ///     Get <see cref="Capacitance{T}" /> from Megafarads.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMegafarads(QuantityValue megafarads)
+        public static Capacitance<T> FromMegafarads(T megafarads)
         {
-            double value = (double) megafarads;
-            return new Capacitance(value, CapacitanceUnit.Megafarad);
+            return new Capacitance<T>(megafarads, CapacitanceUnit.Megafarad);
         }
         /// <summary>
-        ///     Get Capacitance from Microfarads.
+        ///     Get <see cref="Capacitance{T}" /> from Microfarads.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMicrofarads(QuantityValue microfarads)
+        public static Capacitance<T> FromMicrofarads(T microfarads)
         {
-            double value = (double) microfarads;
-            return new Capacitance(value, CapacitanceUnit.Microfarad);
+            return new Capacitance<T>(microfarads, CapacitanceUnit.Microfarad);
         }
         /// <summary>
-        ///     Get Capacitance from Millifarads.
+        ///     Get <see cref="Capacitance{T}" /> from Millifarads.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMillifarads(QuantityValue millifarads)
+        public static Capacitance<T> FromMillifarads(T millifarads)
         {
-            double value = (double) millifarads;
-            return new Capacitance(value, CapacitanceUnit.Millifarad);
+            return new Capacitance<T>(millifarads, CapacitanceUnit.Millifarad);
         }
         /// <summary>
-        ///     Get Capacitance from Nanofarads.
+        ///     Get <see cref="Capacitance{T}" /> from Nanofarads.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromNanofarads(QuantityValue nanofarads)
+        public static Capacitance<T> FromNanofarads(T nanofarads)
         {
-            double value = (double) nanofarads;
-            return new Capacitance(value, CapacitanceUnit.Nanofarad);
+            return new Capacitance<T>(nanofarads, CapacitanceUnit.Nanofarad);
         }
         /// <summary>
-        ///     Get Capacitance from Picofarads.
+        ///     Get <see cref="Capacitance{T}" /> from Picofarads.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromPicofarads(QuantityValue picofarads)
+        public static Capacitance<T> FromPicofarads(T picofarads)
         {
-            double value = (double) picofarads;
-            return new Capacitance(value, CapacitanceUnit.Picofarad);
+            return new Capacitance<T>(picofarads, CapacitanceUnit.Picofarad);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="CapacitanceUnit" /> to <see cref="Capacitance" />.
+        ///     Dynamically convert from value and unit enum <see cref="CapacitanceUnit" /> to <see cref="Capacitance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Capacitance unit value.</returns>
-        public static Capacitance From(QuantityValue value, CapacitanceUnit fromUnit)
+        /// <returns><see cref="Capacitance{T}" /> unit value.</returns>
+        public static Capacitance<T> From(T value, CapacitanceUnit fromUnit)
         {
-            return new Capacitance((double)value, fromUnit);
+            return new Capacitance<T>(value, fromUnit);
         }
 
         #endregion
@@ -340,7 +331,7 @@ public static Capacitance From(QuantityValue value, CapacitanceUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Capacitance Parse(string str)
+        public static Capacitance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -368,9 +359,9 @@ public static Capacitance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Capacitance Parse(string str, IFormatProvider? provider)
+        public static Capacitance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Capacitance, CapacitanceUnit>(
+            return QuantityParser.Default.Parse<T, Capacitance<T>, CapacitanceUnit>(
                 str,
                 provider,
                 From);
@@ -384,7 +375,7 @@ public static Capacitance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Capacitance result)
+        public static bool TryParse(string? str, out Capacitance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -399,9 +390,9 @@ public static bool TryParse(string? str, out Capacitance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Capacitance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Capacitance<T> result)
         {
-            return QuantityParser.Default.TryParse<Capacitance, CapacitanceUnit>(
+            return QuantityParser.Default.TryParse<T, Capacitance<T>, CapacitanceUnit>(
                 str,
                 provider,
                 From,
@@ -463,45 +454,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Capac
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Capacitance operator -(Capacitance right)
+        public static Capacitance<T> operator -(Capacitance<T> right)
         {
-            return new Capacitance(-right.Value, right.Unit);
+            return new Capacitance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Capacitance"/> from adding two <see cref="Capacitance"/>.</summary>
-        public static Capacitance operator +(Capacitance left, Capacitance right)
+        /// <summary>Get <see cref="Capacitance{T}"/> from adding two <see cref="Capacitance{T}"/>.</summary>
+        public static Capacitance<T> operator +(Capacitance<T> left, Capacitance<T> right)
         {
-            return new Capacitance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Capacitance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Capacitance"/> from subtracting two <see cref="Capacitance"/>.</summary>
-        public static Capacitance operator -(Capacitance left, Capacitance right)
+        /// <summary>Get <see cref="Capacitance{T}"/> from subtracting two <see cref="Capacitance{T}"/>.</summary>
+        public static Capacitance<T> operator -(Capacitance<T> left, Capacitance<T> right)
         {
-            return new Capacitance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Capacitance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Capacitance"/> from multiplying value and <see cref="Capacitance"/>.</summary>
-        public static Capacitance operator *(double left, Capacitance right)
+        /// <summary>Get <see cref="Capacitance{T}"/> from multiplying value and <see cref="Capacitance{T}"/>.</summary>
+        public static Capacitance<T> operator *(T left, Capacitance<T> right)
         {
-            return new Capacitance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Capacitance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Capacitance"/> from multiplying value and <see cref="Capacitance"/>.</summary>
-        public static Capacitance operator *(Capacitance left, double right)
+        /// <summary>Get <see cref="Capacitance{T}"/> from multiplying value and <see cref="Capacitance{T}"/>.</summary>
+        public static Capacitance<T> operator *(Capacitance<T> left, T right)
         {
-            return new Capacitance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Capacitance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Capacitance"/> from dividing <see cref="Capacitance"/> by value.</summary>
-        public static Capacitance operator /(Capacitance left, double right)
+        /// <summary>Get <see cref="Capacitance{T}"/> from dividing <see cref="Capacitance{T}"/> by value.</summary>
+        public static Capacitance<T> operator /(Capacitance<T> left, T right)
         {
-            return new Capacitance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Capacitance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Capacitance"/> by <see cref="Capacitance"/>.</summary>
-        public static double operator /(Capacitance left, Capacitance right)
+        /// <summary>Get ratio value from dividing <see cref="Capacitance{T}"/> by <see cref="Capacitance{T}"/>.</summary>
+        public static T operator /(Capacitance<T> left, Capacitance<T> right)
         {
-            return left.Farads / right.Farads;
+            return CompiledLambdas.Divide(left.Farads, right.Farads);
         }
 
         #endregion
@@ -509,39 +505,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Capac
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Capacitance left, Capacitance right)
+        public static bool operator <=(Capacitance<T> left, Capacitance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Capacitance left, Capacitance right)
+        public static bool operator >=(Capacitance<T> left, Capacitance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Capacitance left, Capacitance right)
+        public static bool operator <(Capacitance<T> left, Capacitance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Capacitance left, Capacitance right)
+        public static bool operator >(Capacitance<T> left, Capacitance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Capacitance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Capacitance left, Capacitance right)
+        /// <remarks>Consider using <see cref="Equals(Capacitance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Capacitance<T> left, Capacitance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Capacitance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Capacitance left, Capacitance right)
+        /// <remarks>Consider using <see cref="Equals(Capacitance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Capacitance<T> left, Capacitance<T> right)
         {
             return !(left == right);
         }
@@ -550,37 +546,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Capac
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Capacitance objCapacitance)) throw new ArgumentException("Expected type Capacitance.", nameof(obj));
+            if(!(obj is Capacitance<T> objCapacitance)) throw new ArgumentException("Expected type Capacitance.", nameof(obj));
 
             return CompareTo(objCapacitance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Capacitance other)
+        public int CompareTo(Capacitance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Capacitance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Capacitance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Capacitance objCapacitance))
+            if(obj is null || !(obj is Capacitance<T> objCapacitance))
                 return false;
 
             return Equals(objCapacitance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Capacitance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Capacitance other)
+        /// <remarks>Consider using <see cref="Equals(Capacitance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Capacitance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Capacitance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Capacitance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -618,21 +614,19 @@ public bool Equals(Capacitance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Capacitance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Capacitance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Capacitance.</returns>
+        /// <returns>A hash code for the current <see cref="Capacitance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -646,17 +640,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(CapacitanceUnit unit)
+        public T As(CapacitanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -676,17 +670,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is CapacitanceUnit unitAsCapacitanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CapacitanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsCapacitanceUnit);
+            var asValue = As(unitAsCapacitanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<CapacitanceUnit>.As(CapacitanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Capacitance to another Capacitance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Capacitance{T}" /> to another <see cref="Capacitance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Capacitance with the specified unit.</returns>
-        public Capacitance ToUnit(CapacitanceUnit unit)
+        /// <returns>A <see cref="Capacitance{T}" /> with the specified unit.</returns>
+        public Capacitance<T> ToUnit(CapacitanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Capacitance(convertedValue, unit);
+            return new Capacitance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -699,7 +698,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Capacitance ToUnit(UnitSystem unitSystem)
+        public Capacitance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -719,25 +718,31 @@ public Capacitance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<CapacitanceUnit> IQuantity<CapacitanceUnit>.ToUnit(CapacitanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<CapacitanceUnit, T> IQuantityT<CapacitanceUnit, T>.ToUnit(CapacitanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<CapacitanceUnit> IQuantity<CapacitanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<CapacitanceUnit, T> IQuantityT<CapacitanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case CapacitanceUnit.Farad: return _value;
-                case CapacitanceUnit.Kilofarad: return (_value) * 1e3d;
-                case CapacitanceUnit.Megafarad: return (_value) * 1e6d;
-                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;
+                case CapacitanceUnit.Farad: return Value;
+                case CapacitanceUnit.Kilofarad: return (Value) * 1e3d;
+                case CapacitanceUnit.Megafarad: return (Value) * 1e6d;
+                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.");
             }
@@ -748,16 +753,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Capacitance ToBaseUnit()
+        internal Capacitance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Capacitance(baseUnitValue, BaseUnit);
+            return new Capacitance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(CapacitanceUnit unit)
+        private T GetValueAs(CapacitanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -866,57 +871,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Capacitance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Capacitance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Capacitance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Capacitance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Capacitance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Capacitance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -926,33 +931,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Capacitance))
+            if(conversionType == typeof(Capacitance<T>))
                 return this;
             else if(conversionType == typeof(CapacitanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Capacitance.QuantityType;
+                return Capacitance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Capacitance.Info;
+                return Capacitance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Capacitance.BaseDimensions;
+                return Capacitance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Capacitance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Capacitance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
index 75be9432c4..016474759f 100644
--- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     A unit that represents a fractional change in size in response to a change in temperature.
     /// </summary>
-    public partial struct CoefficientOfThermalExpansion : IQuantity<CoefficientOfThermalExpansionUnit>, IEquatable<CoefficientOfThermalExpansion>, IComparable, IComparable<CoefficientOfThermalExpansion>, IConvertible, IFormattable
+    public partial struct CoefficientOfThermalExpansion<T> : IQuantityT<CoefficientOfThermalExpansionUnit, T>, IEquatable<CoefficientOfThermalExpansion<T>>, IComparable, IComparable<CoefficientOfThermalExpansion<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static CoefficientOfThermalExpansion()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public CoefficientOfThermalExpansion(double value, CoefficientOfThermalExpansionUnit unit)
+        public CoefficientOfThermalExpansion(T value, CoefficientOfThermalExpansionUnit unit)
         {
             if(unit == CoefficientOfThermalExpansionUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public CoefficientOfThermalExpansion(double value, CoefficientOfThermalExpansion
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
+        public CoefficientOfThermalExpansion(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of CoefficientOfThermalExpansion, which is InverseKelvin. All conversions go via this value.
+        ///     The base unit of <see cref="CoefficientOfThermalExpansion{T}" />, which is InverseKelvin. All conversions go via this value.
         /// </summary>
         public static CoefficientOfThermalExpansionUnit BaseUnit { get; } = CoefficientOfThermalExpansionUnit.InverseKelvin;
 
         /// <summary>
-        /// Represents the largest possible value of CoefficientOfThermalExpansion
+        /// Represents the largest possible value of <see cref="CoefficientOfThermalExpansion{T}" />
         /// </summary>
-        public static CoefficientOfThermalExpansion MaxValue { get; } = new CoefficientOfThermalExpansion(double.MaxValue, BaseUnit);
+        public static CoefficientOfThermalExpansion<T> MaxValue { get; } = new CoefficientOfThermalExpansion<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of CoefficientOfThermalExpansion
+        /// Represents the smallest possible value of <see cref="CoefficientOfThermalExpansion{T}" />
         /// </summary>
-        public static CoefficientOfThermalExpansion MinValue { get; } = new CoefficientOfThermalExpansion(double.MinValue, BaseUnit);
+        public static CoefficientOfThermalExpansion<T> MinValue { get; } = new CoefficientOfThermalExpansion<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.CoefficientOfThermalExpansion;
 
         /// <summary>
-        ///     All units of measurement for the CoefficientOfThermalExpansion quantity.
+        ///     All units of measurement for the <see cref="CoefficientOfThermalExpansion{T}" /> quantity.
         /// </summary>
         public static CoefficientOfThermalExpansionUnit[] Units { get; } = Enum.GetValues(typeof(CoefficientOfThermalExpansionUnit)).Cast<CoefficientOfThermalExpansionUnit>().Except(new CoefficientOfThermalExpansionUnit[]{ CoefficientOfThermalExpansionUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit InverseKelvin.
         /// </summary>
-        public static CoefficientOfThermalExpansion Zero { get; } = new CoefficientOfThermalExpansion(0, BaseUnit);
+        public static CoefficientOfThermalExpansion<T> Zero { get; } = new CoefficientOfThermalExpansion<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => CoefficientOfThermalExpansion.QuantityType;
+        public QuantityType Type => CoefficientOfThermalExpansion<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => CoefficientOfThermalExpansion.BaseDimensions;
+        public BaseDimensions Dimensions => CoefficientOfThermalExpansion<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get CoefficientOfThermalExpansion in InverseDegreeCelsius.
+        ///     Get <see cref="CoefficientOfThermalExpansion{T}" /> in InverseDegreeCelsius.
         /// </summary>
-        public double InverseDegreeCelsius => As(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
+        public T InverseDegreeCelsius => As(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
 
         /// <summary>
-        ///     Get CoefficientOfThermalExpansion in InverseDegreeFahrenheit.
+        ///     Get <see cref="CoefficientOfThermalExpansion{T}" /> in InverseDegreeFahrenheit.
         /// </summary>
-        public double InverseDegreeFahrenheit => As(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
+        public T InverseDegreeFahrenheit => As(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
 
         /// <summary>
-        ///     Get CoefficientOfThermalExpansion in InverseKelvin.
+        ///     Get <see cref="CoefficientOfThermalExpansion{T}" /> in InverseKelvin.
         /// </summary>
-        public double InverseKelvin => As(CoefficientOfThermalExpansionUnit.InverseKelvin);
+        public T InverseKelvin => As(CoefficientOfThermalExpansionUnit.InverseKelvin);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(CoefficientOfThermalExpansionUnit unit, IFo
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get CoefficientOfThermalExpansion from InverseDegreeCelsius.
+        ///     Get <see cref="CoefficientOfThermalExpansion{T}" /> from InverseDegreeCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(QuantityValue inversedegreecelsius)
+        public static CoefficientOfThermalExpansion<T> FromInverseDegreeCelsius(T inversedegreecelsius)
         {
-            double value = (double) inversedegreecelsius;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
+            return new CoefficientOfThermalExpansion<T>(inversedegreecelsius, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
         }
         /// <summary>
-        ///     Get CoefficientOfThermalExpansion from InverseDegreeFahrenheit.
+        ///     Get <see cref="CoefficientOfThermalExpansion{T}" /> from InverseDegreeFahrenheit.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(QuantityValue inversedegreefahrenheit)
+        public static CoefficientOfThermalExpansion<T> FromInverseDegreeFahrenheit(T inversedegreefahrenheit)
         {
-            double value = (double) inversedegreefahrenheit;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
+            return new CoefficientOfThermalExpansion<T>(inversedegreefahrenheit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
         }
         /// <summary>
-        ///     Get CoefficientOfThermalExpansion from InverseKelvin.
+        ///     Get <see cref="CoefficientOfThermalExpansion{T}" /> from InverseKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromInverseKelvin(QuantityValue inversekelvin)
+        public static CoefficientOfThermalExpansion<T> FromInverseKelvin(T inversekelvin)
         {
-            double value = (double) inversekelvin;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseKelvin);
+            return new CoefficientOfThermalExpansion<T>(inversekelvin, CoefficientOfThermalExpansionUnit.InverseKelvin);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="CoefficientOfThermalExpansionUnit" /> to <see cref="CoefficientOfThermalExpansion" />.
+        ///     Dynamically convert from value and unit enum <see cref="CoefficientOfThermalExpansionUnit" /> to <see cref="CoefficientOfThermalExpansion{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>CoefficientOfThermalExpansion unit value.</returns>
-        public static CoefficientOfThermalExpansion From(QuantityValue value, CoefficientOfThermalExpansionUnit fromUnit)
+        /// <returns><see cref="CoefficientOfThermalExpansion{T}" /> unit value.</returns>
+        public static CoefficientOfThermalExpansion<T> From(T value, CoefficientOfThermalExpansionUnit fromUnit)
         {
-            return new CoefficientOfThermalExpansion((double)value, fromUnit);
+            return new CoefficientOfThermalExpansion<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static CoefficientOfThermalExpansion From(QuantityValue value, Coefficien
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static CoefficientOfThermalExpansion Parse(string str)
+        public static CoefficientOfThermalExpansion<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static CoefficientOfThermalExpansion Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static CoefficientOfThermalExpansion Parse(string str, IFormatProvider? provider)
+        public static CoefficientOfThermalExpansion<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>(
+            return QuantityParser.Default.Parse<T, CoefficientOfThermalExpansion<T>, CoefficientOfThermalExpansionUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static CoefficientOfThermalExpansion Parse(string str, IFormatProvider? p
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out CoefficientOfThermalExpansion result)
+        public static bool TryParse(string? str, out CoefficientOfThermalExpansion<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out CoefficientOfThermalExpansion resul
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out CoefficientOfThermalExpansion result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out CoefficientOfThermalExpansion<T> result)
         {
-            return QuantityParser.Default.TryParse<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>(
+            return QuantityParser.Default.TryParse<T, CoefficientOfThermalExpansion<T>, CoefficientOfThermalExpansionUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Coeff
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static CoefficientOfThermalExpansion operator -(CoefficientOfThermalExpansion right)
+        public static CoefficientOfThermalExpansion<T> operator -(CoefficientOfThermalExpansion<T> right)
         {
-            return new CoefficientOfThermalExpansion(-right.Value, right.Unit);
+            return new CoefficientOfThermalExpansion<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from adding two <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static CoefficientOfThermalExpansion operator +(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        /// <summary>Get <see cref="CoefficientOfThermalExpansion{T}"/> from adding two <see cref="CoefficientOfThermalExpansion{T}"/>.</summary>
+        public static CoefficientOfThermalExpansion<T> operator +(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
-            return new CoefficientOfThermalExpansion(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new CoefficientOfThermalExpansion<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from subtracting two <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static CoefficientOfThermalExpansion operator -(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        /// <summary>Get <see cref="CoefficientOfThermalExpansion{T}"/> from subtracting two <see cref="CoefficientOfThermalExpansion{T}"/>.</summary>
+        public static CoefficientOfThermalExpansion<T> operator -(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
-            return new CoefficientOfThermalExpansion(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new CoefficientOfThermalExpansion<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from multiplying value and <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static CoefficientOfThermalExpansion operator *(double left, CoefficientOfThermalExpansion right)
+        /// <summary>Get <see cref="CoefficientOfThermalExpansion{T}"/> from multiplying value and <see cref="CoefficientOfThermalExpansion{T}"/>.</summary>
+        public static CoefficientOfThermalExpansion<T> operator *(T left, CoefficientOfThermalExpansion<T> right)
         {
-            return new CoefficientOfThermalExpansion(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new CoefficientOfThermalExpansion<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from multiplying value and <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static CoefficientOfThermalExpansion operator *(CoefficientOfThermalExpansion left, double right)
+        /// <summary>Get <see cref="CoefficientOfThermalExpansion{T}"/> from multiplying value and <see cref="CoefficientOfThermalExpansion{T}"/>.</summary>
+        public static CoefficientOfThermalExpansion<T> operator *(CoefficientOfThermalExpansion<T> left, T right)
         {
-            return new CoefficientOfThermalExpansion(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new CoefficientOfThermalExpansion<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from dividing <see cref="CoefficientOfThermalExpansion"/> by value.</summary>
-        public static CoefficientOfThermalExpansion operator /(CoefficientOfThermalExpansion left, double right)
+        /// <summary>Get <see cref="CoefficientOfThermalExpansion{T}"/> from dividing <see cref="CoefficientOfThermalExpansion{T}"/> by value.</summary>
+        public static CoefficientOfThermalExpansion<T> operator /(CoefficientOfThermalExpansion<T> left, T right)
         {
-            return new CoefficientOfThermalExpansion(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new CoefficientOfThermalExpansion<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="CoefficientOfThermalExpansion"/> by <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static double operator /(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        /// <summary>Get ratio value from dividing <see cref="CoefficientOfThermalExpansion{T}"/> by <see cref="CoefficientOfThermalExpansion{T}"/>.</summary>
+        public static T operator /(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
-            return left.InverseKelvin / right.InverseKelvin;
+            return CompiledLambdas.Divide(left.InverseKelvin, right.InverseKelvin);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Coeff
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        public static bool operator <=(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        public static bool operator >=(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        public static bool operator <(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        public static bool operator >(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(CoefficientOfThermalExpansion<T> left, CoefficientOfThermalExpansion<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Coeff
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is CoefficientOfThermalExpansion objCoefficientOfThermalExpansion)) throw new ArgumentException("Expected type CoefficientOfThermalExpansion.", nameof(obj));
+            if(!(obj is CoefficientOfThermalExpansion<T> objCoefficientOfThermalExpansion)) throw new ArgumentException("Expected type CoefficientOfThermalExpansion.", nameof(obj));
 
             return CompareTo(objCoefficientOfThermalExpansion);
         }
 
         /// <inheritdoc />
-        public int CompareTo(CoefficientOfThermalExpansion other)
+        public int CompareTo(CoefficientOfThermalExpansion<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is CoefficientOfThermalExpansion objCoefficientOfThermalExpansion))
+            if(obj is null || !(obj is CoefficientOfThermalExpansion<T> objCoefficientOfThermalExpansion))
                 return false;
 
             return Equals(objCoefficientOfThermalExpansion);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(CoefficientOfThermalExpansion other)
+        /// <remarks>Consider using <see cref="Equals(CoefficientOfThermalExpansion{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(CoefficientOfThermalExpansion<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another CoefficientOfThermalExpansion within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="CoefficientOfThermalExpansion{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(CoefficientOfThermalExpansion other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(CoefficientOfThermalExpansion other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(CoefficientOfThermalExpansion<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current CoefficientOfThermalExpansion.</returns>
+        /// <returns>A hash code for the current <see cref="CoefficientOfThermalExpansion{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(CoefficientOfThermalExpansionUnit unit)
+        public T As(CoefficientOfThermalExpansionUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is CoefficientOfThermalExpansionUnit unitAsCoefficientOfThermalExpansionUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CoefficientOfThermalExpansionUnit)} is supported.", nameof(unit));
 
-            return As(unitAsCoefficientOfThermalExpansionUnit);
+            var asValue = As(unitAsCoefficientOfThermalExpansionUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<CoefficientOfThermalExpansionUnit>.As(CoefficientOfThermalExpansionUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this CoefficientOfThermalExpansion to another CoefficientOfThermalExpansion with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="CoefficientOfThermalExpansion{T}" /> to another <see cref="CoefficientOfThermalExpansion{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A CoefficientOfThermalExpansion with the specified unit.</returns>
-        public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit unit)
+        /// <returns>A <see cref="CoefficientOfThermalExpansion{T}" /> with the specified unit.</returns>
+        public CoefficientOfThermalExpansion<T> ToUnit(CoefficientOfThermalExpansionUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new CoefficientOfThermalExpansion(convertedValue, unit);
+            return new CoefficientOfThermalExpansion<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public CoefficientOfThermalExpansion ToUnit(UnitSystem unitSystem)
+        public CoefficientOfThermalExpansion<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public CoefficientOfThermalExpansion ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<CoefficientOfThermalExpansionUnit> IQuantity<CoefficientOfThermalExpansionUnit>.ToUnit(CoefficientOfThermalExpansionUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<CoefficientOfThermalExpansionUnit, T> IQuantityT<CoefficientOfThermalExpansionUnit, T>.ToUnit(CoefficientOfThermalExpansionUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<CoefficientOfThermalExpansionUnit> IQuantity<CoefficientOfThermalExpansionUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<CoefficientOfThermalExpansionUnit, T> IQuantityT<CoefficientOfThermalExpansionUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: return _value;
-                case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: return _value*9/5;
-                case CoefficientOfThermalExpansionUnit.InverseKelvin: return _value;
+                case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: return Value;
+                case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: return Value*9/5;
+                case CoefficientOfThermalExpansionUnit.InverseKelvin: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal CoefficientOfThermalExpansion ToBaseUnit()
+        internal CoefficientOfThermalExpansion<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new CoefficientOfThermalExpansion(baseUnitValue, BaseUnit);
+            return new CoefficientOfThermalExpansion<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(CoefficientOfThermalExpansionUnit unit)
+        private T GetValueAs(CoefficientOfThermalExpansionUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(CoefficientOfThermalExpansion))
+            if(conversionType == typeof(CoefficientOfThermalExpansion<T>))
                 return this;
             else if(conversionType == typeof(CoefficientOfThermalExpansionUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return CoefficientOfThermalExpansion.QuantityType;
+                return CoefficientOfThermalExpansion<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return CoefficientOfThermalExpansion.Info;
+                return CoefficientOfThermalExpansion<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return CoefficientOfThermalExpansion.BaseDimensions;
+                return CoefficientOfThermalExpansion<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(CoefficientOfThermalExpansion<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
index 084fec6488..ef723beb13 100644
--- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     http://en.wikipedia.org/wiki/Density
     /// </remarks>
-    public partial struct Density : IQuantity<DensityUnit>, IEquatable<Density>, IComparable, IComparable<Density>, IConvertible, IFormattable
+    public partial struct Density<T> : IQuantityT<DensityUnit, T>, IEquatable<Density<T>>, IComparable, IComparable<Density<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -105,12 +101,12 @@ static Density()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Density(double value, DensityUnit unit)
+        public Density(T value, DensityUnit unit)
         {
             if(unit == DensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -122,14 +118,14 @@ public Density(double value, DensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Density(double value, UnitSystem unitSystem)
+        public Density(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -144,19 +140,19 @@ public Density(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Density, which is KilogramPerCubicMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Density{T}" />, which is KilogramPerCubicMeter. All conversions go via this value.
         /// </summary>
         public static DensityUnit BaseUnit { get; } = DensityUnit.KilogramPerCubicMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Density
+        /// Represents the largest possible value of <see cref="Density{T}" />
         /// </summary>
-        public static Density MaxValue { get; } = new Density(double.MaxValue, BaseUnit);
+        public static Density<T> MaxValue { get; } = new Density<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Density
+        /// Represents the smallest possible value of <see cref="Density{T}" />
         /// </summary>
-        public static Density MinValue { get; } = new Density(double.MinValue, BaseUnit);
+        public static Density<T> MinValue { get; } = new Density<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -165,14 +161,14 @@ public Density(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Density;
 
         /// <summary>
-        ///     All units of measurement for the Density quantity.
+        ///     All units of measurement for the <see cref="Density{T}" /> quantity.
         /// </summary>
         public static DensityUnit[] Units { get; } = Enum.GetValues(typeof(DensityUnit)).Cast<DensityUnit>().Except(new DensityUnit[]{ DensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramPerCubicMeter.
         /// </summary>
-        public static Density Zero { get; } = new Density(0, BaseUnit);
+        public static Density<T> Zero { get; } = new Density<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -181,7 +177,9 @@ public Density(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -197,216 +195,216 @@ public Density(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Density.QuantityType;
+        public QuantityType Type => Density<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Density.BaseDimensions;
+        public BaseDimensions Dimensions => Density<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Density in CentigramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> in CentigramsPerDeciLiter.
         /// </summary>
-        public double CentigramsPerDeciLiter => As(DensityUnit.CentigramPerDeciliter);
+        public T CentigramsPerDeciLiter => As(DensityUnit.CentigramPerDeciliter);
 
         /// <summary>
-        ///     Get Density in CentigramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in CentigramsPerLiter.
         /// </summary>
-        public double CentigramsPerLiter => As(DensityUnit.CentigramPerLiter);
+        public T CentigramsPerLiter => As(DensityUnit.CentigramPerLiter);
 
         /// <summary>
-        ///     Get Density in CentigramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> in CentigramsPerMilliliter.
         /// </summary>
-        public double CentigramsPerMilliliter => As(DensityUnit.CentigramPerMilliliter);
+        public T CentigramsPerMilliliter => As(DensityUnit.CentigramPerMilliliter);
 
         /// <summary>
-        ///     Get Density in DecigramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> in DecigramsPerDeciLiter.
         /// </summary>
-        public double DecigramsPerDeciLiter => As(DensityUnit.DecigramPerDeciliter);
+        public T DecigramsPerDeciLiter => As(DensityUnit.DecigramPerDeciliter);
 
         /// <summary>
-        ///     Get Density in DecigramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in DecigramsPerLiter.
         /// </summary>
-        public double DecigramsPerLiter => As(DensityUnit.DecigramPerLiter);
+        public T DecigramsPerLiter => As(DensityUnit.DecigramPerLiter);
 
         /// <summary>
-        ///     Get Density in DecigramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> in DecigramsPerMilliliter.
         /// </summary>
-        public double DecigramsPerMilliliter => As(DensityUnit.DecigramPerMilliliter);
+        public T DecigramsPerMilliliter => As(DensityUnit.DecigramPerMilliliter);
 
         /// <summary>
-        ///     Get Density in GramsPerCubicCentimeter.
+        ///     Get <see cref="Density{T}" /> in GramsPerCubicCentimeter.
         /// </summary>
-        public double GramsPerCubicCentimeter => As(DensityUnit.GramPerCubicCentimeter);
+        public T GramsPerCubicCentimeter => As(DensityUnit.GramPerCubicCentimeter);
 
         /// <summary>
-        ///     Get Density in GramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> in GramsPerCubicMeter.
         /// </summary>
-        public double GramsPerCubicMeter => As(DensityUnit.GramPerCubicMeter);
+        public T GramsPerCubicMeter => As(DensityUnit.GramPerCubicMeter);
 
         /// <summary>
-        ///     Get Density in GramsPerCubicMillimeter.
+        ///     Get <see cref="Density{T}" /> in GramsPerCubicMillimeter.
         /// </summary>
-        public double GramsPerCubicMillimeter => As(DensityUnit.GramPerCubicMillimeter);
+        public T GramsPerCubicMillimeter => As(DensityUnit.GramPerCubicMillimeter);
 
         /// <summary>
-        ///     Get Density in GramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> in GramsPerDeciLiter.
         /// </summary>
-        public double GramsPerDeciLiter => As(DensityUnit.GramPerDeciliter);
+        public T GramsPerDeciLiter => As(DensityUnit.GramPerDeciliter);
 
         /// <summary>
-        ///     Get Density in GramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in GramsPerLiter.
         /// </summary>
-        public double GramsPerLiter => As(DensityUnit.GramPerLiter);
+        public T GramsPerLiter => As(DensityUnit.GramPerLiter);
 
         /// <summary>
-        ///     Get Density in GramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> in GramsPerMilliliter.
         /// </summary>
-        public double GramsPerMilliliter => As(DensityUnit.GramPerMilliliter);
+        public T GramsPerMilliliter => As(DensityUnit.GramPerMilliliter);
 
         /// <summary>
-        ///     Get Density in KilogramsPerCubicCentimeter.
+        ///     Get <see cref="Density{T}" /> in KilogramsPerCubicCentimeter.
         /// </summary>
-        public double KilogramsPerCubicCentimeter => As(DensityUnit.KilogramPerCubicCentimeter);
+        public T KilogramsPerCubicCentimeter => As(DensityUnit.KilogramPerCubicCentimeter);
 
         /// <summary>
-        ///     Get Density in KilogramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> in KilogramsPerCubicMeter.
         /// </summary>
-        public double KilogramsPerCubicMeter => As(DensityUnit.KilogramPerCubicMeter);
+        public T KilogramsPerCubicMeter => As(DensityUnit.KilogramPerCubicMeter);
 
         /// <summary>
-        ///     Get Density in KilogramsPerCubicMillimeter.
+        ///     Get <see cref="Density{T}" /> in KilogramsPerCubicMillimeter.
         /// </summary>
-        public double KilogramsPerCubicMillimeter => As(DensityUnit.KilogramPerCubicMillimeter);
+        public T KilogramsPerCubicMillimeter => As(DensityUnit.KilogramPerCubicMillimeter);
 
         /// <summary>
-        ///     Get Density in KilogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in KilogramsPerLiter.
         /// </summary>
-        public double KilogramsPerLiter => As(DensityUnit.KilogramPerLiter);
+        public T KilogramsPerLiter => As(DensityUnit.KilogramPerLiter);
 
         /// <summary>
-        ///     Get Density in KilopoundsPerCubicFoot.
+        ///     Get <see cref="Density{T}" /> in KilopoundsPerCubicFoot.
         /// </summary>
-        public double KilopoundsPerCubicFoot => As(DensityUnit.KilopoundPerCubicFoot);
+        public T KilopoundsPerCubicFoot => As(DensityUnit.KilopoundPerCubicFoot);
 
         /// <summary>
-        ///     Get Density in KilopoundsPerCubicInch.
+        ///     Get <see cref="Density{T}" /> in KilopoundsPerCubicInch.
         /// </summary>
-        public double KilopoundsPerCubicInch => As(DensityUnit.KilopoundPerCubicInch);
+        public T KilopoundsPerCubicInch => As(DensityUnit.KilopoundPerCubicInch);
 
         /// <summary>
-        ///     Get Density in MicrogramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> in MicrogramsPerCubicMeter.
         /// </summary>
-        public double MicrogramsPerCubicMeter => As(DensityUnit.MicrogramPerCubicMeter);
+        public T MicrogramsPerCubicMeter => As(DensityUnit.MicrogramPerCubicMeter);
 
         /// <summary>
-        ///     Get Density in MicrogramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> in MicrogramsPerDeciLiter.
         /// </summary>
-        public double MicrogramsPerDeciLiter => As(DensityUnit.MicrogramPerDeciliter);
+        public T MicrogramsPerDeciLiter => As(DensityUnit.MicrogramPerDeciliter);
 
         /// <summary>
-        ///     Get Density in MicrogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in MicrogramsPerLiter.
         /// </summary>
-        public double MicrogramsPerLiter => As(DensityUnit.MicrogramPerLiter);
+        public T MicrogramsPerLiter => As(DensityUnit.MicrogramPerLiter);
 
         /// <summary>
-        ///     Get Density in MicrogramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> in MicrogramsPerMilliliter.
         /// </summary>
-        public double MicrogramsPerMilliliter => As(DensityUnit.MicrogramPerMilliliter);
+        public T MicrogramsPerMilliliter => As(DensityUnit.MicrogramPerMilliliter);
 
         /// <summary>
-        ///     Get Density in MilligramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> in MilligramsPerCubicMeter.
         /// </summary>
-        public double MilligramsPerCubicMeter => As(DensityUnit.MilligramPerCubicMeter);
+        public T MilligramsPerCubicMeter => As(DensityUnit.MilligramPerCubicMeter);
 
         /// <summary>
-        ///     Get Density in MilligramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> in MilligramsPerDeciLiter.
         /// </summary>
-        public double MilligramsPerDeciLiter => As(DensityUnit.MilligramPerDeciliter);
+        public T MilligramsPerDeciLiter => As(DensityUnit.MilligramPerDeciliter);
 
         /// <summary>
-        ///     Get Density in MilligramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in MilligramsPerLiter.
         /// </summary>
-        public double MilligramsPerLiter => As(DensityUnit.MilligramPerLiter);
+        public T MilligramsPerLiter => As(DensityUnit.MilligramPerLiter);
 
         /// <summary>
-        ///     Get Density in MilligramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> in MilligramsPerMilliliter.
         /// </summary>
-        public double MilligramsPerMilliliter => As(DensityUnit.MilligramPerMilliliter);
+        public T MilligramsPerMilliliter => As(DensityUnit.MilligramPerMilliliter);
 
         /// <summary>
-        ///     Get Density in NanogramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> in NanogramsPerDeciLiter.
         /// </summary>
-        public double NanogramsPerDeciLiter => As(DensityUnit.NanogramPerDeciliter);
+        public T NanogramsPerDeciLiter => As(DensityUnit.NanogramPerDeciliter);
 
         /// <summary>
-        ///     Get Density in NanogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in NanogramsPerLiter.
         /// </summary>
-        public double NanogramsPerLiter => As(DensityUnit.NanogramPerLiter);
+        public T NanogramsPerLiter => As(DensityUnit.NanogramPerLiter);
 
         /// <summary>
-        ///     Get Density in NanogramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> in NanogramsPerMilliliter.
         /// </summary>
-        public double NanogramsPerMilliliter => As(DensityUnit.NanogramPerMilliliter);
+        public T NanogramsPerMilliliter => As(DensityUnit.NanogramPerMilliliter);
 
         /// <summary>
-        ///     Get Density in PicogramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> in PicogramsPerDeciLiter.
         /// </summary>
-        public double PicogramsPerDeciLiter => As(DensityUnit.PicogramPerDeciliter);
+        public T PicogramsPerDeciLiter => As(DensityUnit.PicogramPerDeciliter);
 
         /// <summary>
-        ///     Get Density in PicogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> in PicogramsPerLiter.
         /// </summary>
-        public double PicogramsPerLiter => As(DensityUnit.PicogramPerLiter);
+        public T PicogramsPerLiter => As(DensityUnit.PicogramPerLiter);
 
         /// <summary>
-        ///     Get Density in PicogramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> in PicogramsPerMilliliter.
         /// </summary>
-        public double PicogramsPerMilliliter => As(DensityUnit.PicogramPerMilliliter);
+        public T PicogramsPerMilliliter => As(DensityUnit.PicogramPerMilliliter);
 
         /// <summary>
-        ///     Get Density in PoundsPerCubicFoot.
+        ///     Get <see cref="Density{T}" /> in PoundsPerCubicFoot.
         /// </summary>
-        public double PoundsPerCubicFoot => As(DensityUnit.PoundPerCubicFoot);
+        public T PoundsPerCubicFoot => As(DensityUnit.PoundPerCubicFoot);
 
         /// <summary>
-        ///     Get Density in PoundsPerCubicInch.
+        ///     Get <see cref="Density{T}" /> in PoundsPerCubicInch.
         /// </summary>
-        public double PoundsPerCubicInch => As(DensityUnit.PoundPerCubicInch);
+        public T PoundsPerCubicInch => As(DensityUnit.PoundPerCubicInch);
 
         /// <summary>
-        ///     Get Density in PoundsPerImperialGallon.
+        ///     Get <see cref="Density{T}" /> in PoundsPerImperialGallon.
         /// </summary>
-        public double PoundsPerImperialGallon => As(DensityUnit.PoundPerImperialGallon);
+        public T PoundsPerImperialGallon => As(DensityUnit.PoundPerImperialGallon);
 
         /// <summary>
-        ///     Get Density in PoundsPerUSGallon.
+        ///     Get <see cref="Density{T}" /> in PoundsPerUSGallon.
         /// </summary>
-        public double PoundsPerUSGallon => As(DensityUnit.PoundPerUSGallon);
+        public T PoundsPerUSGallon => As(DensityUnit.PoundPerUSGallon);
 
         /// <summary>
-        ///     Get Density in SlugsPerCubicFoot.
+        ///     Get <see cref="Density{T}" /> in SlugsPerCubicFoot.
         /// </summary>
-        public double SlugsPerCubicFoot => As(DensityUnit.SlugPerCubicFoot);
+        public T SlugsPerCubicFoot => As(DensityUnit.SlugPerCubicFoot);
 
         /// <summary>
-        ///     Get Density in TonnesPerCubicCentimeter.
+        ///     Get <see cref="Density{T}" /> in TonnesPerCubicCentimeter.
         /// </summary>
-        public double TonnesPerCubicCentimeter => As(DensityUnit.TonnePerCubicCentimeter);
+        public T TonnesPerCubicCentimeter => As(DensityUnit.TonnePerCubicCentimeter);
 
         /// <summary>
-        ///     Get Density in TonnesPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> in TonnesPerCubicMeter.
         /// </summary>
-        public double TonnesPerCubicMeter => As(DensityUnit.TonnePerCubicMeter);
+        public T TonnesPerCubicMeter => As(DensityUnit.TonnePerCubicMeter);
 
         /// <summary>
-        ///     Get Density in TonnesPerCubicMillimeter.
+        ///     Get <see cref="Density{T}" /> in TonnesPerCubicMillimeter.
         /// </summary>
-        public double TonnesPerCubicMillimeter => As(DensityUnit.TonnePerCubicMillimeter);
+        public T TonnesPerCubicMillimeter => As(DensityUnit.TonnePerCubicMillimeter);
 
         #endregion
 
@@ -438,375 +436,335 @@ public static string GetAbbreviation(DensityUnit unit, IFormatProvider? provider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Density from CentigramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> from CentigramsPerDeciLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerDeciLiter(QuantityValue centigramsperdeciliter)
+        public static Density<T> FromCentigramsPerDeciLiter(T centigramsperdeciliter)
         {
-            double value = (double) centigramsperdeciliter;
-            return new Density(value, DensityUnit.CentigramPerDeciliter);
+            return new Density<T>(centigramsperdeciliter, DensityUnit.CentigramPerDeciliter);
         }
         /// <summary>
-        ///     Get Density from CentigramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from CentigramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerLiter(QuantityValue centigramsperliter)
+        public static Density<T> FromCentigramsPerLiter(T centigramsperliter)
         {
-            double value = (double) centigramsperliter;
-            return new Density(value, DensityUnit.CentigramPerLiter);
+            return new Density<T>(centigramsperliter, DensityUnit.CentigramPerLiter);
         }
         /// <summary>
-        ///     Get Density from CentigramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> from CentigramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerMilliliter(QuantityValue centigramspermilliliter)
+        public static Density<T> FromCentigramsPerMilliliter(T centigramspermilliliter)
         {
-            double value = (double) centigramspermilliliter;
-            return new Density(value, DensityUnit.CentigramPerMilliliter);
+            return new Density<T>(centigramspermilliliter, DensityUnit.CentigramPerMilliliter);
         }
         /// <summary>
-        ///     Get Density from DecigramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> from DecigramsPerDeciLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerDeciLiter(QuantityValue decigramsperdeciliter)
+        public static Density<T> FromDecigramsPerDeciLiter(T decigramsperdeciliter)
         {
-            double value = (double) decigramsperdeciliter;
-            return new Density(value, DensityUnit.DecigramPerDeciliter);
+            return new Density<T>(decigramsperdeciliter, DensityUnit.DecigramPerDeciliter);
         }
         /// <summary>
-        ///     Get Density from DecigramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from DecigramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerLiter(QuantityValue decigramsperliter)
+        public static Density<T> FromDecigramsPerLiter(T decigramsperliter)
         {
-            double value = (double) decigramsperliter;
-            return new Density(value, DensityUnit.DecigramPerLiter);
+            return new Density<T>(decigramsperliter, DensityUnit.DecigramPerLiter);
         }
         /// <summary>
-        ///     Get Density from DecigramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> from DecigramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerMilliliter(QuantityValue decigramspermilliliter)
+        public static Density<T> FromDecigramsPerMilliliter(T decigramspermilliliter)
         {
-            double value = (double) decigramspermilliliter;
-            return new Density(value, DensityUnit.DecigramPerMilliliter);
+            return new Density<T>(decigramspermilliliter, DensityUnit.DecigramPerMilliliter);
         }
         /// <summary>
-        ///     Get Density from GramsPerCubicCentimeter.
+        ///     Get <see cref="Density{T}" /> from GramsPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicCentimeter(QuantityValue gramspercubiccentimeter)
+        public static Density<T> FromGramsPerCubicCentimeter(T gramspercubiccentimeter)
         {
-            double value = (double) gramspercubiccentimeter;
-            return new Density(value, DensityUnit.GramPerCubicCentimeter);
+            return new Density<T>(gramspercubiccentimeter, DensityUnit.GramPerCubicCentimeter);
         }
         /// <summary>
-        ///     Get Density from GramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> from GramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicMeter(QuantityValue gramspercubicmeter)
+        public static Density<T> FromGramsPerCubicMeter(T gramspercubicmeter)
         {
-            double value = (double) gramspercubicmeter;
-            return new Density(value, DensityUnit.GramPerCubicMeter);
+            return new Density<T>(gramspercubicmeter, DensityUnit.GramPerCubicMeter);
         }
         /// <summary>
-        ///     Get Density from GramsPerCubicMillimeter.
+        ///     Get <see cref="Density{T}" /> from GramsPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicMillimeter(QuantityValue gramspercubicmillimeter)
+        public static Density<T> FromGramsPerCubicMillimeter(T gramspercubicmillimeter)
         {
-            double value = (double) gramspercubicmillimeter;
-            return new Density(value, DensityUnit.GramPerCubicMillimeter);
+            return new Density<T>(gramspercubicmillimeter, DensityUnit.GramPerCubicMillimeter);
         }
         /// <summary>
-        ///     Get Density from GramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> from GramsPerDeciLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerDeciLiter(QuantityValue gramsperdeciliter)
+        public static Density<T> FromGramsPerDeciLiter(T gramsperdeciliter)
         {
-            double value = (double) gramsperdeciliter;
-            return new Density(value, DensityUnit.GramPerDeciliter);
+            return new Density<T>(gramsperdeciliter, DensityUnit.GramPerDeciliter);
         }
         /// <summary>
-        ///     Get Density from GramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from GramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerLiter(QuantityValue gramsperliter)
+        public static Density<T> FromGramsPerLiter(T gramsperliter)
         {
-            double value = (double) gramsperliter;
-            return new Density(value, DensityUnit.GramPerLiter);
+            return new Density<T>(gramsperliter, DensityUnit.GramPerLiter);
         }
         /// <summary>
-        ///     Get Density from GramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> from GramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerMilliliter(QuantityValue gramspermilliliter)
+        public static Density<T> FromGramsPerMilliliter(T gramspermilliliter)
         {
-            double value = (double) gramspermilliliter;
-            return new Density(value, DensityUnit.GramPerMilliliter);
+            return new Density<T>(gramspermilliliter, DensityUnit.GramPerMilliliter);
         }
         /// <summary>
-        ///     Get Density from KilogramsPerCubicCentimeter.
+        ///     Get <see cref="Density{T}" /> from KilogramsPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicCentimeter(QuantityValue kilogramspercubiccentimeter)
+        public static Density<T> FromKilogramsPerCubicCentimeter(T kilogramspercubiccentimeter)
         {
-            double value = (double) kilogramspercubiccentimeter;
-            return new Density(value, DensityUnit.KilogramPerCubicCentimeter);
+            return new Density<T>(kilogramspercubiccentimeter, DensityUnit.KilogramPerCubicCentimeter);
         }
         /// <summary>
-        ///     Get Density from KilogramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> from KilogramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicMeter(QuantityValue kilogramspercubicmeter)
+        public static Density<T> FromKilogramsPerCubicMeter(T kilogramspercubicmeter)
         {
-            double value = (double) kilogramspercubicmeter;
-            return new Density(value, DensityUnit.KilogramPerCubicMeter);
+            return new Density<T>(kilogramspercubicmeter, DensityUnit.KilogramPerCubicMeter);
         }
         /// <summary>
-        ///     Get Density from KilogramsPerCubicMillimeter.
+        ///     Get <see cref="Density{T}" /> from KilogramsPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicMillimeter(QuantityValue kilogramspercubicmillimeter)
+        public static Density<T> FromKilogramsPerCubicMillimeter(T kilogramspercubicmillimeter)
         {
-            double value = (double) kilogramspercubicmillimeter;
-            return new Density(value, DensityUnit.KilogramPerCubicMillimeter);
+            return new Density<T>(kilogramspercubicmillimeter, DensityUnit.KilogramPerCubicMillimeter);
         }
         /// <summary>
-        ///     Get Density from KilogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from KilogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerLiter(QuantityValue kilogramsperliter)
+        public static Density<T> FromKilogramsPerLiter(T kilogramsperliter)
         {
-            double value = (double) kilogramsperliter;
-            return new Density(value, DensityUnit.KilogramPerLiter);
+            return new Density<T>(kilogramsperliter, DensityUnit.KilogramPerLiter);
         }
         /// <summary>
-        ///     Get Density from KilopoundsPerCubicFoot.
+        ///     Get <see cref="Density{T}" /> from KilopoundsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicFoot(QuantityValue kilopoundspercubicfoot)
+        public static Density<T> FromKilopoundsPerCubicFoot(T kilopoundspercubicfoot)
         {
-            double value = (double) kilopoundspercubicfoot;
-            return new Density(value, DensityUnit.KilopoundPerCubicFoot);
+            return new Density<T>(kilopoundspercubicfoot, DensityUnit.KilopoundPerCubicFoot);
         }
         /// <summary>
-        ///     Get Density from KilopoundsPerCubicInch.
+        ///     Get <see cref="Density{T}" /> from KilopoundsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicInch(QuantityValue kilopoundspercubicinch)
+        public static Density<T> FromKilopoundsPerCubicInch(T kilopoundspercubicinch)
         {
-            double value = (double) kilopoundspercubicinch;
-            return new Density(value, DensityUnit.KilopoundPerCubicInch);
+            return new Density<T>(kilopoundspercubicinch, DensityUnit.KilopoundPerCubicInch);
         }
         /// <summary>
-        ///     Get Density from MicrogramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> from MicrogramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerCubicMeter(QuantityValue microgramspercubicmeter)
+        public static Density<T> FromMicrogramsPerCubicMeter(T microgramspercubicmeter)
         {
-            double value = (double) microgramspercubicmeter;
-            return new Density(value, DensityUnit.MicrogramPerCubicMeter);
+            return new Density<T>(microgramspercubicmeter, DensityUnit.MicrogramPerCubicMeter);
         }
         /// <summary>
-        ///     Get Density from MicrogramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> from MicrogramsPerDeciLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerDeciLiter(QuantityValue microgramsperdeciliter)
+        public static Density<T> FromMicrogramsPerDeciLiter(T microgramsperdeciliter)
         {
-            double value = (double) microgramsperdeciliter;
-            return new Density(value, DensityUnit.MicrogramPerDeciliter);
+            return new Density<T>(microgramsperdeciliter, DensityUnit.MicrogramPerDeciliter);
         }
         /// <summary>
-        ///     Get Density from MicrogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from MicrogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerLiter(QuantityValue microgramsperliter)
+        public static Density<T> FromMicrogramsPerLiter(T microgramsperliter)
         {
-            double value = (double) microgramsperliter;
-            return new Density(value, DensityUnit.MicrogramPerLiter);
+            return new Density<T>(microgramsperliter, DensityUnit.MicrogramPerLiter);
         }
         /// <summary>
-        ///     Get Density from MicrogramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> from MicrogramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerMilliliter(QuantityValue microgramspermilliliter)
+        public static Density<T> FromMicrogramsPerMilliliter(T microgramspermilliliter)
         {
-            double value = (double) microgramspermilliliter;
-            return new Density(value, DensityUnit.MicrogramPerMilliliter);
+            return new Density<T>(microgramspermilliliter, DensityUnit.MicrogramPerMilliliter);
         }
         /// <summary>
-        ///     Get Density from MilligramsPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> from MilligramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerCubicMeter(QuantityValue milligramspercubicmeter)
+        public static Density<T> FromMilligramsPerCubicMeter(T milligramspercubicmeter)
         {
-            double value = (double) milligramspercubicmeter;
-            return new Density(value, DensityUnit.MilligramPerCubicMeter);
+            return new Density<T>(milligramspercubicmeter, DensityUnit.MilligramPerCubicMeter);
         }
         /// <summary>
-        ///     Get Density from MilligramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> from MilligramsPerDeciLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerDeciLiter(QuantityValue milligramsperdeciliter)
+        public static Density<T> FromMilligramsPerDeciLiter(T milligramsperdeciliter)
         {
-            double value = (double) milligramsperdeciliter;
-            return new Density(value, DensityUnit.MilligramPerDeciliter);
+            return new Density<T>(milligramsperdeciliter, DensityUnit.MilligramPerDeciliter);
         }
         /// <summary>
-        ///     Get Density from MilligramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from MilligramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerLiter(QuantityValue milligramsperliter)
+        public static Density<T> FromMilligramsPerLiter(T milligramsperliter)
         {
-            double value = (double) milligramsperliter;
-            return new Density(value, DensityUnit.MilligramPerLiter);
+            return new Density<T>(milligramsperliter, DensityUnit.MilligramPerLiter);
         }
         /// <summary>
-        ///     Get Density from MilligramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> from MilligramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerMilliliter(QuantityValue milligramspermilliliter)
+        public static Density<T> FromMilligramsPerMilliliter(T milligramspermilliliter)
         {
-            double value = (double) milligramspermilliliter;
-            return new Density(value, DensityUnit.MilligramPerMilliliter);
+            return new Density<T>(milligramspermilliliter, DensityUnit.MilligramPerMilliliter);
         }
         /// <summary>
-        ///     Get Density from NanogramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> from NanogramsPerDeciLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerDeciLiter(QuantityValue nanogramsperdeciliter)
+        public static Density<T> FromNanogramsPerDeciLiter(T nanogramsperdeciliter)
         {
-            double value = (double) nanogramsperdeciliter;
-            return new Density(value, DensityUnit.NanogramPerDeciliter);
+            return new Density<T>(nanogramsperdeciliter, DensityUnit.NanogramPerDeciliter);
         }
         /// <summary>
-        ///     Get Density from NanogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from NanogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerLiter(QuantityValue nanogramsperliter)
+        public static Density<T> FromNanogramsPerLiter(T nanogramsperliter)
         {
-            double value = (double) nanogramsperliter;
-            return new Density(value, DensityUnit.NanogramPerLiter);
+            return new Density<T>(nanogramsperliter, DensityUnit.NanogramPerLiter);
         }
         /// <summary>
-        ///     Get Density from NanogramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> from NanogramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerMilliliter(QuantityValue nanogramspermilliliter)
+        public static Density<T> FromNanogramsPerMilliliter(T nanogramspermilliliter)
         {
-            double value = (double) nanogramspermilliliter;
-            return new Density(value, DensityUnit.NanogramPerMilliliter);
+            return new Density<T>(nanogramspermilliliter, DensityUnit.NanogramPerMilliliter);
         }
         /// <summary>
-        ///     Get Density from PicogramsPerDeciLiter.
+        ///     Get <see cref="Density{T}" /> from PicogramsPerDeciLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerDeciLiter(QuantityValue picogramsperdeciliter)
+        public static Density<T> FromPicogramsPerDeciLiter(T picogramsperdeciliter)
         {
-            double value = (double) picogramsperdeciliter;
-            return new Density(value, DensityUnit.PicogramPerDeciliter);
+            return new Density<T>(picogramsperdeciliter, DensityUnit.PicogramPerDeciliter);
         }
         /// <summary>
-        ///     Get Density from PicogramsPerLiter.
+        ///     Get <see cref="Density{T}" /> from PicogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerLiter(QuantityValue picogramsperliter)
+        public static Density<T> FromPicogramsPerLiter(T picogramsperliter)
         {
-            double value = (double) picogramsperliter;
-            return new Density(value, DensityUnit.PicogramPerLiter);
+            return new Density<T>(picogramsperliter, DensityUnit.PicogramPerLiter);
         }
         /// <summary>
-        ///     Get Density from PicogramsPerMilliliter.
+        ///     Get <see cref="Density{T}" /> from PicogramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerMilliliter(QuantityValue picogramspermilliliter)
+        public static Density<T> FromPicogramsPerMilliliter(T picogramspermilliliter)
         {
-            double value = (double) picogramspermilliliter;
-            return new Density(value, DensityUnit.PicogramPerMilliliter);
+            return new Density<T>(picogramspermilliliter, DensityUnit.PicogramPerMilliliter);
         }
         /// <summary>
-        ///     Get Density from PoundsPerCubicFoot.
+        ///     Get <see cref="Density{T}" /> from PoundsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicFoot(QuantityValue poundspercubicfoot)
+        public static Density<T> FromPoundsPerCubicFoot(T poundspercubicfoot)
         {
-            double value = (double) poundspercubicfoot;
-            return new Density(value, DensityUnit.PoundPerCubicFoot);
+            return new Density<T>(poundspercubicfoot, DensityUnit.PoundPerCubicFoot);
         }
         /// <summary>
-        ///     Get Density from PoundsPerCubicInch.
+        ///     Get <see cref="Density{T}" /> from PoundsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicInch(QuantityValue poundspercubicinch)
+        public static Density<T> FromPoundsPerCubicInch(T poundspercubicinch)
         {
-            double value = (double) poundspercubicinch;
-            return new Density(value, DensityUnit.PoundPerCubicInch);
+            return new Density<T>(poundspercubicinch, DensityUnit.PoundPerCubicInch);
         }
         /// <summary>
-        ///     Get Density from PoundsPerImperialGallon.
+        ///     Get <see cref="Density{T}" /> from PoundsPerImperialGallon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerImperialGallon(QuantityValue poundsperimperialgallon)
+        public static Density<T> FromPoundsPerImperialGallon(T poundsperimperialgallon)
         {
-            double value = (double) poundsperimperialgallon;
-            return new Density(value, DensityUnit.PoundPerImperialGallon);
+            return new Density<T>(poundsperimperialgallon, DensityUnit.PoundPerImperialGallon);
         }
         /// <summary>
-        ///     Get Density from PoundsPerUSGallon.
+        ///     Get <see cref="Density{T}" /> from PoundsPerUSGallon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerUSGallon(QuantityValue poundsperusgallon)
+        public static Density<T> FromPoundsPerUSGallon(T poundsperusgallon)
         {
-            double value = (double) poundsperusgallon;
-            return new Density(value, DensityUnit.PoundPerUSGallon);
+            return new Density<T>(poundsperusgallon, DensityUnit.PoundPerUSGallon);
         }
         /// <summary>
-        ///     Get Density from SlugsPerCubicFoot.
+        ///     Get <see cref="Density{T}" /> from SlugsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicFoot(QuantityValue slugspercubicfoot)
+        public static Density<T> FromSlugsPerCubicFoot(T slugspercubicfoot)
         {
-            double value = (double) slugspercubicfoot;
-            return new Density(value, DensityUnit.SlugPerCubicFoot);
+            return new Density<T>(slugspercubicfoot, DensityUnit.SlugPerCubicFoot);
         }
         /// <summary>
-        ///     Get Density from TonnesPerCubicCentimeter.
+        ///     Get <see cref="Density{T}" /> from TonnesPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicCentimeter(QuantityValue tonnespercubiccentimeter)
+        public static Density<T> FromTonnesPerCubicCentimeter(T tonnespercubiccentimeter)
         {
-            double value = (double) tonnespercubiccentimeter;
-            return new Density(value, DensityUnit.TonnePerCubicCentimeter);
+            return new Density<T>(tonnespercubiccentimeter, DensityUnit.TonnePerCubicCentimeter);
         }
         /// <summary>
-        ///     Get Density from TonnesPerCubicMeter.
+        ///     Get <see cref="Density{T}" /> from TonnesPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicMeter(QuantityValue tonnespercubicmeter)
+        public static Density<T> FromTonnesPerCubicMeter(T tonnespercubicmeter)
         {
-            double value = (double) tonnespercubicmeter;
-            return new Density(value, DensityUnit.TonnePerCubicMeter);
+            return new Density<T>(tonnespercubicmeter, DensityUnit.TonnePerCubicMeter);
         }
         /// <summary>
-        ///     Get Density from TonnesPerCubicMillimeter.
+        ///     Get <see cref="Density{T}" /> from TonnesPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicMillimeter(QuantityValue tonnespercubicmillimeter)
+        public static Density<T> FromTonnesPerCubicMillimeter(T tonnespercubicmillimeter)
         {
-            double value = (double) tonnespercubicmillimeter;
-            return new Density(value, DensityUnit.TonnePerCubicMillimeter);
+            return new Density<T>(tonnespercubicmillimeter, DensityUnit.TonnePerCubicMillimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="DensityUnit" /> to <see cref="Density" />.
+        ///     Dynamically convert from value and unit enum <see cref="DensityUnit" /> to <see cref="Density{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Density unit value.</returns>
-        public static Density From(QuantityValue value, DensityUnit fromUnit)
+        /// <returns><see cref="Density{T}" /> unit value.</returns>
+        public static Density<T> From(T value, DensityUnit fromUnit)
         {
-            return new Density((double)value, fromUnit);
+            return new Density<T>(value, fromUnit);
         }
 
         #endregion
@@ -835,7 +793,7 @@ public static Density From(QuantityValue value, DensityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Density Parse(string str)
+        public static Density<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -863,9 +821,9 @@ public static Density Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Density Parse(string str, IFormatProvider? provider)
+        public static Density<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Density, DensityUnit>(
+            return QuantityParser.Default.Parse<T, Density<T>, DensityUnit>(
                 str,
                 provider,
                 From);
@@ -879,7 +837,7 @@ public static Density Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Density result)
+        public static bool TryParse(string? str, out Density<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -894,9 +852,9 @@ public static bool TryParse(string? str, out Density result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Density result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Density<T> result)
         {
-            return QuantityParser.Default.TryParse<Density, DensityUnit>(
+            return QuantityParser.Default.TryParse<T, Density<T>, DensityUnit>(
                 str,
                 provider,
                 From,
@@ -958,45 +916,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Densi
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Density operator -(Density right)
+        public static Density<T> operator -(Density<T> right)
         {
-            return new Density(-right.Value, right.Unit);
+            return new Density<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Density"/> from adding two <see cref="Density"/>.</summary>
-        public static Density operator +(Density left, Density right)
+        /// <summary>Get <see cref="Density{T}"/> from adding two <see cref="Density{T}"/>.</summary>
+        public static Density<T> operator +(Density<T> left, Density<T> right)
         {
-            return new Density(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Density<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Density"/> from subtracting two <see cref="Density"/>.</summary>
-        public static Density operator -(Density left, Density right)
+        /// <summary>Get <see cref="Density{T}"/> from subtracting two <see cref="Density{T}"/>.</summary>
+        public static Density<T> operator -(Density<T> left, Density<T> right)
         {
-            return new Density(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Density<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Density"/> from multiplying value and <see cref="Density"/>.</summary>
-        public static Density operator *(double left, Density right)
+        /// <summary>Get <see cref="Density{T}"/> from multiplying value and <see cref="Density{T}"/>.</summary>
+        public static Density<T> operator *(T left, Density<T> right)
         {
-            return new Density(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Density<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Density"/> from multiplying value and <see cref="Density"/>.</summary>
-        public static Density operator *(Density left, double right)
+        /// <summary>Get <see cref="Density{T}"/> from multiplying value and <see cref="Density{T}"/>.</summary>
+        public static Density<T> operator *(Density<T> left, T right)
         {
-            return new Density(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Density<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Density"/> from dividing <see cref="Density"/> by value.</summary>
-        public static Density operator /(Density left, double right)
+        /// <summary>Get <see cref="Density{T}"/> from dividing <see cref="Density{T}"/> by value.</summary>
+        public static Density<T> operator /(Density<T> left, T right)
         {
-            return new Density(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Density<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Density"/> by <see cref="Density"/>.</summary>
-        public static double operator /(Density left, Density right)
+        /// <summary>Get ratio value from dividing <see cref="Density{T}"/> by <see cref="Density{T}"/>.</summary>
+        public static T operator /(Density<T> left, Density<T> right)
         {
-            return left.KilogramsPerCubicMeter / right.KilogramsPerCubicMeter;
+            return CompiledLambdas.Divide(left.KilogramsPerCubicMeter, right.KilogramsPerCubicMeter);
         }
 
         #endregion
@@ -1004,39 +967,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Densi
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Density left, Density right)
+        public static bool operator <=(Density<T> left, Density<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Density left, Density right)
+        public static bool operator >=(Density<T> left, Density<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Density left, Density right)
+        public static bool operator <(Density<T> left, Density<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Density left, Density right)
+        public static bool operator >(Density<T> left, Density<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Density, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Density left, Density right)
+        /// <remarks>Consider using <see cref="Equals(Density{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Density<T> left, Density<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Density, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Density left, Density right)
+        /// <remarks>Consider using <see cref="Equals(Density{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Density<T> left, Density<T> right)
         {
             return !(left == right);
         }
@@ -1045,37 +1008,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Densi
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Density objDensity)) throw new ArgumentException("Expected type Density.", nameof(obj));
+            if(!(obj is Density<T> objDensity)) throw new ArgumentException("Expected type Density.", nameof(obj));
 
             return CompareTo(objDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Density other)
+        public int CompareTo(Density<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Density, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Density{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Density objDensity))
+            if(obj is null || !(obj is Density<T> objDensity))
                 return false;
 
             return Equals(objDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Density, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Density other)
+        /// <remarks>Consider using <see cref="Equals(Density{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Density<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Density within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Density{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1113,21 +1076,19 @@ public bool Equals(Density other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Density other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Density<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Density.</returns>
+        /// <returns>A hash code for the current <see cref="Density{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1141,17 +1102,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(DensityUnit unit)
+        public T As(DensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1171,17 +1132,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is DensityUnit unitAsDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsDensityUnit);
+            var asValue = As(unitAsDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<DensityUnit>.As(DensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Density to another Density with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Density{T}" /> to another <see cref="Density{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Density with the specified unit.</returns>
-        public Density ToUnit(DensityUnit unit)
+        /// <returns>A <see cref="Density{T}" /> with the specified unit.</returns>
+        public Density<T> ToUnit(DensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Density(convertedValue, unit);
+            return new Density<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1194,7 +1160,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Density ToUnit(UnitSystem unitSystem)
+        public Density<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1214,58 +1180,64 @@ public Density ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<DensityUnit> IQuantity<DensityUnit>.ToUnit(DensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<DensityUnit, T> IQuantityT<DensityUnit, T>.ToUnit(DensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<DensityUnit> IQuantity<DensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<DensityUnit, T> IQuantityT<DensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case DensityUnit.CentigramPerDeciliter: return (_value/1e-1) * 1e-2d;
-                case DensityUnit.CentigramPerLiter: return (_value/1) * 1e-2d;
-                case DensityUnit.CentigramPerMilliliter: return (_value/1e-3) * 1e-2d;
-                case DensityUnit.DecigramPerDeciliter: return (_value/1e-1) * 1e-1d;
-                case DensityUnit.DecigramPerLiter: return (_value/1) * 1e-1d;
-                case DensityUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d;
-                case DensityUnit.GramPerCubicCentimeter: return _value/1e-3;
-                case DensityUnit.GramPerCubicMeter: return _value/1e3;
-                case DensityUnit.GramPerCubicMillimeter: return _value/1e-6;
-                case DensityUnit.GramPerDeciliter: return _value/1e-1;
-                case DensityUnit.GramPerLiter: return _value/1;
-                case DensityUnit.GramPerMilliliter: return _value/1e-3;
-                case DensityUnit.KilogramPerCubicCentimeter: return (_value/1e-3) * 1e3d;
-                case DensityUnit.KilogramPerCubicMeter: return (_value/1e3) * 1e3d;
-                case DensityUnit.KilogramPerCubicMillimeter: return (_value/1e-6) * 1e3d;
-                case DensityUnit.KilogramPerLiter: return _value*1e3;
-                case DensityUnit.KilopoundPerCubicFoot: return (_value/0.062427961) * 1e3d;
-                case DensityUnit.KilopoundPerCubicInch: return (_value/3.6127298147753e-5) * 1e3d;
-                case DensityUnit.MicrogramPerCubicMeter: return (_value/1e3) * 1e-6d;
-                case DensityUnit.MicrogramPerDeciliter: return (_value/1e-1) * 1e-6d;
-                case DensityUnit.MicrogramPerLiter: return (_value/1) * 1e-6d;
-                case DensityUnit.MicrogramPerMilliliter: return (_value/1e-3) * 1e-6d;
-                case DensityUnit.MilligramPerCubicMeter: return (_value/1e3) * 1e-3d;
-                case DensityUnit.MilligramPerDeciliter: return (_value/1e-1) * 1e-3d;
-                case DensityUnit.MilligramPerLiter: return (_value/1) * 1e-3d;
-                case DensityUnit.MilligramPerMilliliter: return (_value/1e-3) * 1e-3d;
-                case DensityUnit.NanogramPerDeciliter: return (_value/1e-1) * 1e-9d;
-                case DensityUnit.NanogramPerLiter: return (_value/1) * 1e-9d;
-                case DensityUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d;
-                case DensityUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d;
-                case DensityUnit.PicogramPerLiter: return (_value/1) * 1e-12d;
-                case DensityUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d;
-                case DensityUnit.PoundPerCubicFoot: return _value/0.062427961;
-                case DensityUnit.PoundPerCubicInch: return _value/3.6127298147753e-5;
-                case DensityUnit.PoundPerImperialGallon: return _value*9.9776398e1;
-                case DensityUnit.PoundPerUSGallon: return _value*1.19826427e2;
-                case DensityUnit.SlugPerCubicFoot: return _value*515.378818;
-                case DensityUnit.TonnePerCubicCentimeter: return _value/1e-9;
-                case DensityUnit.TonnePerCubicMeter: return _value/0.001;
-                case DensityUnit.TonnePerCubicMillimeter: return _value/1e-12;
+                case DensityUnit.CentigramPerDeciliter: return (Value/1e-1) * 1e-2d;
+                case DensityUnit.CentigramPerLiter: return (Value/1) * 1e-2d;
+                case DensityUnit.CentigramPerMilliliter: return (Value/1e-3) * 1e-2d;
+                case DensityUnit.DecigramPerDeciliter: return (Value/1e-1) * 1e-1d;
+                case DensityUnit.DecigramPerLiter: return (Value/1) * 1e-1d;
+                case DensityUnit.DecigramPerMilliliter: return (Value/1e-3) * 1e-1d;
+                case DensityUnit.GramPerCubicCentimeter: return Value/1e-3;
+                case DensityUnit.GramPerCubicMeter: return Value/1e3;
+                case DensityUnit.GramPerCubicMillimeter: return Value/1e-6;
+                case DensityUnit.GramPerDeciliter: return Value/1e-1;
+                case DensityUnit.GramPerLiter: return Value/1;
+                case DensityUnit.GramPerMilliliter: return Value/1e-3;
+                case DensityUnit.KilogramPerCubicCentimeter: return (Value/1e-3) * 1e3d;
+                case DensityUnit.KilogramPerCubicMeter: return (Value/1e3) * 1e3d;
+                case DensityUnit.KilogramPerCubicMillimeter: return (Value/1e-6) * 1e3d;
+                case DensityUnit.KilogramPerLiter: return Value*1e3;
+                case DensityUnit.KilopoundPerCubicFoot: return (Value/0.062427961) * 1e3d;
+                case DensityUnit.KilopoundPerCubicInch: return (Value/3.6127298147753e-5) * 1e3d;
+                case DensityUnit.MicrogramPerCubicMeter: return (Value/1e3) * 1e-6d;
+                case DensityUnit.MicrogramPerDeciliter: return (Value/1e-1) * 1e-6d;
+                case DensityUnit.MicrogramPerLiter: return (Value/1) * 1e-6d;
+                case DensityUnit.MicrogramPerMilliliter: return (Value/1e-3) * 1e-6d;
+                case DensityUnit.MilligramPerCubicMeter: return (Value/1e3) * 1e-3d;
+                case DensityUnit.MilligramPerDeciliter: return (Value/1e-1) * 1e-3d;
+                case DensityUnit.MilligramPerLiter: return (Value/1) * 1e-3d;
+                case DensityUnit.MilligramPerMilliliter: return (Value/1e-3) * 1e-3d;
+                case DensityUnit.NanogramPerDeciliter: return (Value/1e-1) * 1e-9d;
+                case DensityUnit.NanogramPerLiter: return (Value/1) * 1e-9d;
+                case DensityUnit.NanogramPerMilliliter: return (Value/1e-3) * 1e-9d;
+                case DensityUnit.PicogramPerDeciliter: return (Value/1e-1) * 1e-12d;
+                case DensityUnit.PicogramPerLiter: return (Value/1) * 1e-12d;
+                case DensityUnit.PicogramPerMilliliter: return (Value/1e-3) * 1e-12d;
+                case DensityUnit.PoundPerCubicFoot: return Value/0.062427961;
+                case DensityUnit.PoundPerCubicInch: return Value/3.6127298147753e-5;
+                case DensityUnit.PoundPerImperialGallon: return Value*9.9776398e1;
+                case DensityUnit.PoundPerUSGallon: return Value*1.19826427e2;
+                case DensityUnit.SlugPerCubicFoot: return Value*515.378818;
+                case DensityUnit.TonnePerCubicCentimeter: return Value/1e-9;
+                case DensityUnit.TonnePerCubicMeter: return Value/0.001;
+                case DensityUnit.TonnePerCubicMillimeter: return Value/1e-12;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1276,16 +1248,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Density ToBaseUnit()
+        internal Density<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Density(baseUnitValue, BaseUnit);
+            return new Density<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(DensityUnit unit)
+        private T GetValueAs(DensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1427,57 +1399,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Density)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Density<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Density)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Density<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Density)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Density<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1487,33 +1459,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Density))
+            if(conversionType == typeof(Density<T>))
                 return this;
             else if(conversionType == typeof(DensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Density.QuantityType;
+                return Density<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Density.Info;
+                return Density<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Density.BaseDimensions;
+                return Density<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Density)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Density<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
index 29c660ed75..30752f8f82 100644
--- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Time is a dimension in which events can be ordered from the past through the present into the future, and also the measure of durations of events and the intervals between them.
     /// </summary>
-    public partial struct Duration : IQuantity<DurationUnit>, IEquatable<Duration>, IComparable, IComparable<Duration>, IConvertible, IFormattable
+    public partial struct Duration<T> : IQuantityT<DurationUnit, T>, IEquatable<Duration<T>>, IComparable, IComparable<Duration<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -72,12 +68,12 @@ static Duration()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Duration(double value, DurationUnit unit)
+        public Duration(T value, DurationUnit unit)
         {
             if(unit == DurationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -89,14 +85,14 @@ public Duration(double value, DurationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Duration(double value, UnitSystem unitSystem)
+        public Duration(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -111,19 +107,19 @@ public Duration(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Duration, which is Second. All conversions go via this value.
+        ///     The base unit of <see cref="Duration{T}" />, which is Second. All conversions go via this value.
         /// </summary>
         public static DurationUnit BaseUnit { get; } = DurationUnit.Second;
 
         /// <summary>
-        /// Represents the largest possible value of Duration
+        /// Represents the largest possible value of <see cref="Duration{T}" />
         /// </summary>
-        public static Duration MaxValue { get; } = new Duration(double.MaxValue, BaseUnit);
+        public static Duration<T> MaxValue { get; } = new Duration<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Duration
+        /// Represents the smallest possible value of <see cref="Duration{T}" />
         /// </summary>
-        public static Duration MinValue { get; } = new Duration(double.MinValue, BaseUnit);
+        public static Duration<T> MinValue { get; } = new Duration<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -132,14 +128,14 @@ public Duration(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Duration;
 
         /// <summary>
-        ///     All units of measurement for the Duration quantity.
+        ///     All units of measurement for the <see cref="Duration{T}" /> quantity.
         /// </summary>
         public static DurationUnit[] Units { get; } = Enum.GetValues(typeof(DurationUnit)).Cast<DurationUnit>().Except(new DurationUnit[]{ DurationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
         /// </summary>
-        public static Duration Zero { get; } = new Duration(0, BaseUnit);
+        public static Duration<T> Zero { get; } = new Duration<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -148,7 +144,9 @@ public Duration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -164,66 +162,66 @@ public Duration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Duration.QuantityType;
+        public QuantityType Type => Duration<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Duration.BaseDimensions;
+        public BaseDimensions Dimensions => Duration<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Duration in Days.
+        ///     Get <see cref="Duration{T}" /> in Days.
         /// </summary>
-        public double Days => As(DurationUnit.Day);
+        public T Days => As(DurationUnit.Day);
 
         /// <summary>
-        ///     Get Duration in Hours.
+        ///     Get <see cref="Duration{T}" /> in Hours.
         /// </summary>
-        public double Hours => As(DurationUnit.Hour);
+        public T Hours => As(DurationUnit.Hour);
 
         /// <summary>
-        ///     Get Duration in Microseconds.
+        ///     Get <see cref="Duration{T}" /> in Microseconds.
         /// </summary>
-        public double Microseconds => As(DurationUnit.Microsecond);
+        public T Microseconds => As(DurationUnit.Microsecond);
 
         /// <summary>
-        ///     Get Duration in Milliseconds.
+        ///     Get <see cref="Duration{T}" /> in Milliseconds.
         /// </summary>
-        public double Milliseconds => As(DurationUnit.Millisecond);
+        public T Milliseconds => As(DurationUnit.Millisecond);
 
         /// <summary>
-        ///     Get Duration in Minutes.
+        ///     Get <see cref="Duration{T}" /> in Minutes.
         /// </summary>
-        public double Minutes => As(DurationUnit.Minute);
+        public T Minutes => As(DurationUnit.Minute);
 
         /// <summary>
-        ///     Get Duration in Months30.
+        ///     Get <see cref="Duration{T}" /> in Months30.
         /// </summary>
-        public double Months30 => As(DurationUnit.Month30);
+        public T Months30 => As(DurationUnit.Month30);
 
         /// <summary>
-        ///     Get Duration in Nanoseconds.
+        ///     Get <see cref="Duration{T}" /> in Nanoseconds.
         /// </summary>
-        public double Nanoseconds => As(DurationUnit.Nanosecond);
+        public T Nanoseconds => As(DurationUnit.Nanosecond);
 
         /// <summary>
-        ///     Get Duration in Seconds.
+        ///     Get <see cref="Duration{T}" /> in Seconds.
         /// </summary>
-        public double Seconds => As(DurationUnit.Second);
+        public T Seconds => As(DurationUnit.Second);
 
         /// <summary>
-        ///     Get Duration in Weeks.
+        ///     Get <see cref="Duration{T}" /> in Weeks.
         /// </summary>
-        public double Weeks => As(DurationUnit.Week);
+        public T Weeks => As(DurationUnit.Week);
 
         /// <summary>
-        ///     Get Duration in Years365.
+        ///     Get <see cref="Duration{T}" /> in Years365.
         /// </summary>
-        public double Years365 => As(DurationUnit.Year365);
+        public T Years365 => As(DurationUnit.Year365);
 
         #endregion
 
@@ -255,105 +253,95 @@ public static string GetAbbreviation(DurationUnit unit, IFormatProvider? provide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Duration from Days.
+        ///     Get <see cref="Duration{T}" /> from Days.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromDays(QuantityValue days)
+        public static Duration<T> FromDays(T days)
         {
-            double value = (double) days;
-            return new Duration(value, DurationUnit.Day);
+            return new Duration<T>(days, DurationUnit.Day);
         }
         /// <summary>
-        ///     Get Duration from Hours.
+        ///     Get <see cref="Duration{T}" /> from Hours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromHours(QuantityValue hours)
+        public static Duration<T> FromHours(T hours)
         {
-            double value = (double) hours;
-            return new Duration(value, DurationUnit.Hour);
+            return new Duration<T>(hours, DurationUnit.Hour);
         }
         /// <summary>
-        ///     Get Duration from Microseconds.
+        ///     Get <see cref="Duration{T}" /> from Microseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMicroseconds(QuantityValue microseconds)
+        public static Duration<T> FromMicroseconds(T microseconds)
         {
-            double value = (double) microseconds;
-            return new Duration(value, DurationUnit.Microsecond);
+            return new Duration<T>(microseconds, DurationUnit.Microsecond);
         }
         /// <summary>
-        ///     Get Duration from Milliseconds.
+        ///     Get <see cref="Duration{T}" /> from Milliseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMilliseconds(QuantityValue milliseconds)
+        public static Duration<T> FromMilliseconds(T milliseconds)
         {
-            double value = (double) milliseconds;
-            return new Duration(value, DurationUnit.Millisecond);
+            return new Duration<T>(milliseconds, DurationUnit.Millisecond);
         }
         /// <summary>
-        ///     Get Duration from Minutes.
+        ///     Get <see cref="Duration{T}" /> from Minutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMinutes(QuantityValue minutes)
+        public static Duration<T> FromMinutes(T minutes)
         {
-            double value = (double) minutes;
-            return new Duration(value, DurationUnit.Minute);
+            return new Duration<T>(minutes, DurationUnit.Minute);
         }
         /// <summary>
-        ///     Get Duration from Months30.
+        ///     Get <see cref="Duration{T}" /> from Months30.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMonths30(QuantityValue months30)
+        public static Duration<T> FromMonths30(T months30)
         {
-            double value = (double) months30;
-            return new Duration(value, DurationUnit.Month30);
+            return new Duration<T>(months30, DurationUnit.Month30);
         }
         /// <summary>
-        ///     Get Duration from Nanoseconds.
+        ///     Get <see cref="Duration{T}" /> from Nanoseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromNanoseconds(QuantityValue nanoseconds)
+        public static Duration<T> FromNanoseconds(T nanoseconds)
         {
-            double value = (double) nanoseconds;
-            return new Duration(value, DurationUnit.Nanosecond);
+            return new Duration<T>(nanoseconds, DurationUnit.Nanosecond);
         }
         /// <summary>
-        ///     Get Duration from Seconds.
+        ///     Get <see cref="Duration{T}" /> from Seconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromSeconds(QuantityValue seconds)
+        public static Duration<T> FromSeconds(T seconds)
         {
-            double value = (double) seconds;
-            return new Duration(value, DurationUnit.Second);
+            return new Duration<T>(seconds, DurationUnit.Second);
         }
         /// <summary>
-        ///     Get Duration from Weeks.
+        ///     Get <see cref="Duration{T}" /> from Weeks.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromWeeks(QuantityValue weeks)
+        public static Duration<T> FromWeeks(T weeks)
         {
-            double value = (double) weeks;
-            return new Duration(value, DurationUnit.Week);
+            return new Duration<T>(weeks, DurationUnit.Week);
         }
         /// <summary>
-        ///     Get Duration from Years365.
+        ///     Get <see cref="Duration{T}" /> from Years365.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromYears365(QuantityValue years365)
+        public static Duration<T> FromYears365(T years365)
         {
-            double value = (double) years365;
-            return new Duration(value, DurationUnit.Year365);
+            return new Duration<T>(years365, DurationUnit.Year365);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="DurationUnit" /> to <see cref="Duration" />.
+        ///     Dynamically convert from value and unit enum <see cref="DurationUnit" /> to <see cref="Duration{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Duration unit value.</returns>
-        public static Duration From(QuantityValue value, DurationUnit fromUnit)
+        /// <returns><see cref="Duration{T}" /> unit value.</returns>
+        public static Duration<T> From(T value, DurationUnit fromUnit)
         {
-            return new Duration((double)value, fromUnit);
+            return new Duration<T>(value, fromUnit);
         }
 
         #endregion
@@ -382,7 +370,7 @@ public static Duration From(QuantityValue value, DurationUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Duration Parse(string str)
+        public static Duration<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -410,9 +398,9 @@ public static Duration Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Duration Parse(string str, IFormatProvider? provider)
+        public static Duration<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Duration, DurationUnit>(
+            return QuantityParser.Default.Parse<T, Duration<T>, DurationUnit>(
                 str,
                 provider,
                 From);
@@ -426,7 +414,7 @@ public static Duration Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Duration result)
+        public static bool TryParse(string? str, out Duration<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -441,9 +429,9 @@ public static bool TryParse(string? str, out Duration result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Duration result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Duration<T> result)
         {
-            return QuantityParser.Default.TryParse<Duration, DurationUnit>(
+            return QuantityParser.Default.TryParse<T, Duration<T>, DurationUnit>(
                 str,
                 provider,
                 From,
@@ -505,45 +493,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Durat
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Duration operator -(Duration right)
+        public static Duration<T> operator -(Duration<T> right)
         {
-            return new Duration(-right.Value, right.Unit);
+            return new Duration<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Duration"/> from adding two <see cref="Duration"/>.</summary>
-        public static Duration operator +(Duration left, Duration right)
+        /// <summary>Get <see cref="Duration{T}"/> from adding two <see cref="Duration{T}"/>.</summary>
+        public static Duration<T> operator +(Duration<T> left, Duration<T> right)
         {
-            return new Duration(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Duration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Duration"/> from subtracting two <see cref="Duration"/>.</summary>
-        public static Duration operator -(Duration left, Duration right)
+        /// <summary>Get <see cref="Duration{T}"/> from subtracting two <see cref="Duration{T}"/>.</summary>
+        public static Duration<T> operator -(Duration<T> left, Duration<T> right)
         {
-            return new Duration(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Duration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Duration"/> from multiplying value and <see cref="Duration"/>.</summary>
-        public static Duration operator *(double left, Duration right)
+        /// <summary>Get <see cref="Duration{T}"/> from multiplying value and <see cref="Duration{T}"/>.</summary>
+        public static Duration<T> operator *(T left, Duration<T> right)
         {
-            return new Duration(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Duration<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Duration"/> from multiplying value and <see cref="Duration"/>.</summary>
-        public static Duration operator *(Duration left, double right)
+        /// <summary>Get <see cref="Duration{T}"/> from multiplying value and <see cref="Duration{T}"/>.</summary>
+        public static Duration<T> operator *(Duration<T> left, T right)
         {
-            return new Duration(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Duration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Duration"/> from dividing <see cref="Duration"/> by value.</summary>
-        public static Duration operator /(Duration left, double right)
+        /// <summary>Get <see cref="Duration{T}"/> from dividing <see cref="Duration{T}"/> by value.</summary>
+        public static Duration<T> operator /(Duration<T> left, T right)
         {
-            return new Duration(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Duration<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Duration"/> by <see cref="Duration"/>.</summary>
-        public static double operator /(Duration left, Duration right)
+        /// <summary>Get ratio value from dividing <see cref="Duration{T}"/> by <see cref="Duration{T}"/>.</summary>
+        public static T operator /(Duration<T> left, Duration<T> right)
         {
-            return left.Seconds / right.Seconds;
+            return CompiledLambdas.Divide(left.Seconds, right.Seconds);
         }
 
         #endregion
@@ -551,39 +544,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Durat
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Duration left, Duration right)
+        public static bool operator <=(Duration<T> left, Duration<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Duration left, Duration right)
+        public static bool operator >=(Duration<T> left, Duration<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Duration left, Duration right)
+        public static bool operator <(Duration<T> left, Duration<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Duration left, Duration right)
+        public static bool operator >(Duration<T> left, Duration<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Duration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Duration left, Duration right)
+        /// <remarks>Consider using <see cref="Equals(Duration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Duration<T> left, Duration<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Duration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Duration left, Duration right)
+        /// <remarks>Consider using <see cref="Equals(Duration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Duration<T> left, Duration<T> right)
         {
             return !(left == right);
         }
@@ -592,37 +585,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Durat
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Duration objDuration)) throw new ArgumentException("Expected type Duration.", nameof(obj));
+            if(!(obj is Duration<T> objDuration)) throw new ArgumentException("Expected type Duration.", nameof(obj));
 
             return CompareTo(objDuration);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Duration other)
+        public int CompareTo(Duration<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Duration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Duration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Duration objDuration))
+            if(obj is null || !(obj is Duration<T> objDuration))
                 return false;
 
             return Equals(objDuration);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Duration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Duration other)
+        /// <remarks>Consider using <see cref="Equals(Duration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Duration<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Duration within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Duration{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -660,21 +653,19 @@ public bool Equals(Duration other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Duration other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Duration<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Duration.</returns>
+        /// <returns>A hash code for the current <see cref="Duration{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -688,17 +679,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(DurationUnit unit)
+        public T As(DurationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -718,17 +709,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is DurationUnit unitAsDurationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DurationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsDurationUnit);
+            var asValue = As(unitAsDurationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<DurationUnit>.As(DurationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Duration to another Duration with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Duration{T}" /> to another <see cref="Duration{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Duration with the specified unit.</returns>
-        public Duration ToUnit(DurationUnit unit)
+        /// <returns>A <see cref="Duration{T}" /> with the specified unit.</returns>
+        public Duration<T> ToUnit(DurationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Duration(convertedValue, unit);
+            return new Duration<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -741,7 +737,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Duration ToUnit(UnitSystem unitSystem)
+        public Duration<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -761,28 +757,34 @@ public Duration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<DurationUnit> IQuantity<DurationUnit>.ToUnit(DurationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<DurationUnit, T> IQuantityT<DurationUnit, T>.ToUnit(DurationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<DurationUnit> IQuantity<DurationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<DurationUnit, T> IQuantityT<DurationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case DurationUnit.Day: return _value*24*3600;
-                case DurationUnit.Hour: return _value*3600;
-                case DurationUnit.Microsecond: return (_value) * 1e-6d;
-                case DurationUnit.Millisecond: return (_value) * 1e-3d;
-                case DurationUnit.Minute: return _value*60;
-                case DurationUnit.Month30: return _value*30*24*3600;
-                case DurationUnit.Nanosecond: return (_value) * 1e-9d;
-                case DurationUnit.Second: return _value;
-                case DurationUnit.Week: return _value*7*24*3600;
-                case DurationUnit.Year365: return _value*365*24*3600;
+                case DurationUnit.Day: return Value*24*3600;
+                case DurationUnit.Hour: return Value*3600;
+                case DurationUnit.Microsecond: return (Value) * 1e-6d;
+                case DurationUnit.Millisecond: return (Value) * 1e-3d;
+                case DurationUnit.Minute: return Value*60;
+                case DurationUnit.Month30: return Value*30*24*3600;
+                case DurationUnit.Nanosecond: return (Value) * 1e-9d;
+                case DurationUnit.Second: return Value;
+                case DurationUnit.Week: return Value*7*24*3600;
+                case DurationUnit.Year365: return Value*365*24*3600;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -793,16 +795,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Duration ToBaseUnit()
+        internal Duration<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Duration(baseUnitValue, BaseUnit);
+            return new Duration<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(DurationUnit unit)
+        private T GetValueAs(DurationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -914,57 +916,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Duration)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Duration<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Duration)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Duration<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Duration)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Duration<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -974,33 +976,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Duration))
+            if(conversionType == typeof(Duration<T>))
                 return this;
             else if(conversionType == typeof(DurationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Duration.QuantityType;
+                return Duration<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Duration.Info;
+                return Duration<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Duration.BaseDimensions;
+                return Duration<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Duration)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Duration<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
index e453ddcee5..a63fd49579 100644
--- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Viscosity#Dynamic_.28shear.29_viscosity
     /// </remarks>
-    public partial struct DynamicViscosity : IQuantity<DynamicViscosityUnit>, IEquatable<DynamicViscosity>, IComparable, IComparable<DynamicViscosity>, IConvertible, IFormattable
+    public partial struct DynamicViscosity<T> : IQuantityT<DynamicViscosityUnit, T>, IEquatable<DynamicViscosity<T>>, IComparable, IComparable<DynamicViscosity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -75,12 +71,12 @@ static DynamicViscosity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public DynamicViscosity(double value, DynamicViscosityUnit unit)
+        public DynamicViscosity(T value, DynamicViscosityUnit unit)
         {
             if(unit == DynamicViscosityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -92,14 +88,14 @@ public DynamicViscosity(double value, DynamicViscosityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public DynamicViscosity(double value, UnitSystem unitSystem)
+        public DynamicViscosity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -114,19 +110,19 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of DynamicViscosity, which is NewtonSecondPerMeterSquared. All conversions go via this value.
+        ///     The base unit of <see cref="DynamicViscosity{T}" />, which is NewtonSecondPerMeterSquared. All conversions go via this value.
         /// </summary>
         public static DynamicViscosityUnit BaseUnit { get; } = DynamicViscosityUnit.NewtonSecondPerMeterSquared;
 
         /// <summary>
-        /// Represents the largest possible value of DynamicViscosity
+        /// Represents the largest possible value of <see cref="DynamicViscosity{T}" />
         /// </summary>
-        public static DynamicViscosity MaxValue { get; } = new DynamicViscosity(double.MaxValue, BaseUnit);
+        public static DynamicViscosity<T> MaxValue { get; } = new DynamicViscosity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of DynamicViscosity
+        /// Represents the smallest possible value of <see cref="DynamicViscosity{T}" />
         /// </summary>
-        public static DynamicViscosity MinValue { get; } = new DynamicViscosity(double.MinValue, BaseUnit);
+        public static DynamicViscosity<T> MinValue { get; } = new DynamicViscosity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -135,14 +131,14 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.DynamicViscosity;
 
         /// <summary>
-        ///     All units of measurement for the DynamicViscosity quantity.
+        ///     All units of measurement for the <see cref="DynamicViscosity{T}" /> quantity.
         /// </summary>
         public static DynamicViscosityUnit[] Units { get; } = Enum.GetValues(typeof(DynamicViscosityUnit)).Cast<DynamicViscosityUnit>().Except(new DynamicViscosityUnit[]{ DynamicViscosityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonSecondPerMeterSquared.
         /// </summary>
-        public static DynamicViscosity Zero { get; } = new DynamicViscosity(0, BaseUnit);
+        public static DynamicViscosity<T> Zero { get; } = new DynamicViscosity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -151,7 +147,9 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -167,66 +165,66 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => DynamicViscosity.QuantityType;
+        public QuantityType Type => DynamicViscosity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => DynamicViscosity.BaseDimensions;
+        public BaseDimensions Dimensions => DynamicViscosity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get DynamicViscosity in Centipoise.
+        ///     Get <see cref="DynamicViscosity{T}" /> in Centipoise.
         /// </summary>
-        public double Centipoise => As(DynamicViscosityUnit.Centipoise);
+        public T Centipoise => As(DynamicViscosityUnit.Centipoise);
 
         /// <summary>
-        ///     Get DynamicViscosity in MicropascalSeconds.
+        ///     Get <see cref="DynamicViscosity{T}" /> in MicropascalSeconds.
         /// </summary>
-        public double MicropascalSeconds => As(DynamicViscosityUnit.MicropascalSecond);
+        public T MicropascalSeconds => As(DynamicViscosityUnit.MicropascalSecond);
 
         /// <summary>
-        ///     Get DynamicViscosity in MillipascalSeconds.
+        ///     Get <see cref="DynamicViscosity{T}" /> in MillipascalSeconds.
         /// </summary>
-        public double MillipascalSeconds => As(DynamicViscosityUnit.MillipascalSecond);
+        public T MillipascalSeconds => As(DynamicViscosityUnit.MillipascalSecond);
 
         /// <summary>
-        ///     Get DynamicViscosity in NewtonSecondsPerMeterSquared.
+        ///     Get <see cref="DynamicViscosity{T}" /> in NewtonSecondsPerMeterSquared.
         /// </summary>
-        public double NewtonSecondsPerMeterSquared => As(DynamicViscosityUnit.NewtonSecondPerMeterSquared);
+        public T NewtonSecondsPerMeterSquared => As(DynamicViscosityUnit.NewtonSecondPerMeterSquared);
 
         /// <summary>
-        ///     Get DynamicViscosity in PascalSeconds.
+        ///     Get <see cref="DynamicViscosity{T}" /> in PascalSeconds.
         /// </summary>
-        public double PascalSeconds => As(DynamicViscosityUnit.PascalSecond);
+        public T PascalSeconds => As(DynamicViscosityUnit.PascalSecond);
 
         /// <summary>
-        ///     Get DynamicViscosity in Poise.
+        ///     Get <see cref="DynamicViscosity{T}" /> in Poise.
         /// </summary>
-        public double Poise => As(DynamicViscosityUnit.Poise);
+        public T Poise => As(DynamicViscosityUnit.Poise);
 
         /// <summary>
-        ///     Get DynamicViscosity in PoundsForceSecondPerSquareFoot.
+        ///     Get <see cref="DynamicViscosity{T}" /> in PoundsForceSecondPerSquareFoot.
         /// </summary>
-        public double PoundsForceSecondPerSquareFoot => As(DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
+        public T PoundsForceSecondPerSquareFoot => As(DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
 
         /// <summary>
-        ///     Get DynamicViscosity in PoundsForceSecondPerSquareInch.
+        ///     Get <see cref="DynamicViscosity{T}" /> in PoundsForceSecondPerSquareInch.
         /// </summary>
-        public double PoundsForceSecondPerSquareInch => As(DynamicViscosityUnit.PoundForceSecondPerSquareInch);
+        public T PoundsForceSecondPerSquareInch => As(DynamicViscosityUnit.PoundForceSecondPerSquareInch);
 
         /// <summary>
-        ///     Get DynamicViscosity in PoundsPerFootSecond.
+        ///     Get <see cref="DynamicViscosity{T}" /> in PoundsPerFootSecond.
         /// </summary>
-        public double PoundsPerFootSecond => As(DynamicViscosityUnit.PoundPerFootSecond);
+        public T PoundsPerFootSecond => As(DynamicViscosityUnit.PoundPerFootSecond);
 
         /// <summary>
-        ///     Get DynamicViscosity in Reyns.
+        ///     Get <see cref="DynamicViscosity{T}" /> in Reyns.
         /// </summary>
-        public double Reyns => As(DynamicViscosityUnit.Reyn);
+        public T Reyns => As(DynamicViscosityUnit.Reyn);
 
         #endregion
 
@@ -258,105 +256,95 @@ public static string GetAbbreviation(DynamicViscosityUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get DynamicViscosity from Centipoise.
+        ///     Get <see cref="DynamicViscosity{T}" /> from Centipoise.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromCentipoise(QuantityValue centipoise)
+        public static DynamicViscosity<T> FromCentipoise(T centipoise)
         {
-            double value = (double) centipoise;
-            return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise);
+            return new DynamicViscosity<T>(centipoise, DynamicViscosityUnit.Centipoise);
         }
         /// <summary>
-        ///     Get DynamicViscosity from MicropascalSeconds.
+        ///     Get <see cref="DynamicViscosity{T}" /> from MicropascalSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromMicropascalSeconds(QuantityValue micropascalseconds)
+        public static DynamicViscosity<T> FromMicropascalSeconds(T micropascalseconds)
         {
-            double value = (double) micropascalseconds;
-            return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond);
+            return new DynamicViscosity<T>(micropascalseconds, DynamicViscosityUnit.MicropascalSecond);
         }
         /// <summary>
-        ///     Get DynamicViscosity from MillipascalSeconds.
+        ///     Get <see cref="DynamicViscosity{T}" /> from MillipascalSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromMillipascalSeconds(QuantityValue millipascalseconds)
+        public static DynamicViscosity<T> FromMillipascalSeconds(T millipascalseconds)
         {
-            double value = (double) millipascalseconds;
-            return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond);
+            return new DynamicViscosity<T>(millipascalseconds, DynamicViscosityUnit.MillipascalSecond);
         }
         /// <summary>
-        ///     Get DynamicViscosity from NewtonSecondsPerMeterSquared.
+        ///     Get <see cref="DynamicViscosity{T}" /> from NewtonSecondsPerMeterSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(QuantityValue newtonsecondspermetersquared)
+        public static DynamicViscosity<T> FromNewtonSecondsPerMeterSquared(T newtonsecondspermetersquared)
         {
-            double value = (double) newtonsecondspermetersquared;
-            return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
+            return new DynamicViscosity<T>(newtonsecondspermetersquared, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
         }
         /// <summary>
-        ///     Get DynamicViscosity from PascalSeconds.
+        ///     Get <see cref="DynamicViscosity{T}" /> from PascalSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPascalSeconds(QuantityValue pascalseconds)
+        public static DynamicViscosity<T> FromPascalSeconds(T pascalseconds)
         {
-            double value = (double) pascalseconds;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond);
+            return new DynamicViscosity<T>(pascalseconds, DynamicViscosityUnit.PascalSecond);
         }
         /// <summary>
-        ///     Get DynamicViscosity from Poise.
+        ///     Get <see cref="DynamicViscosity{T}" /> from Poise.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoise(QuantityValue poise)
+        public static DynamicViscosity<T> FromPoise(T poise)
         {
-            double value = (double) poise;
-            return new DynamicViscosity(value, DynamicViscosityUnit.Poise);
+            return new DynamicViscosity<T>(poise, DynamicViscosityUnit.Poise);
         }
         /// <summary>
-        ///     Get DynamicViscosity from PoundsForceSecondPerSquareFoot.
+        ///     Get <see cref="DynamicViscosity{T}" /> from PoundsForceSecondPerSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(QuantityValue poundsforcesecondpersquarefoot)
+        public static DynamicViscosity<T> FromPoundsForceSecondPerSquareFoot(T poundsforcesecondpersquarefoot)
         {
-            double value = (double) poundsforcesecondpersquarefoot;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
+            return new DynamicViscosity<T>(poundsforcesecondpersquarefoot, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
         }
         /// <summary>
-        ///     Get DynamicViscosity from PoundsForceSecondPerSquareInch.
+        ///     Get <see cref="DynamicViscosity{T}" /> from PoundsForceSecondPerSquareInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(QuantityValue poundsforcesecondpersquareinch)
+        public static DynamicViscosity<T> FromPoundsForceSecondPerSquareInch(T poundsforcesecondpersquareinch)
         {
-            double value = (double) poundsforcesecondpersquareinch;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
+            return new DynamicViscosity<T>(poundsforcesecondpersquareinch, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
         }
         /// <summary>
-        ///     Get DynamicViscosity from PoundsPerFootSecond.
+        ///     Get <see cref="DynamicViscosity{T}" /> from PoundsPerFootSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsPerFootSecond(QuantityValue poundsperfootsecond)
+        public static DynamicViscosity<T> FromPoundsPerFootSecond(T poundsperfootsecond)
         {
-            double value = (double) poundsperfootsecond;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond);
+            return new DynamicViscosity<T>(poundsperfootsecond, DynamicViscosityUnit.PoundPerFootSecond);
         }
         /// <summary>
-        ///     Get DynamicViscosity from Reyns.
+        ///     Get <see cref="DynamicViscosity{T}" /> from Reyns.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromReyns(QuantityValue reyns)
+        public static DynamicViscosity<T> FromReyns(T reyns)
         {
-            double value = (double) reyns;
-            return new DynamicViscosity(value, DynamicViscosityUnit.Reyn);
+            return new DynamicViscosity<T>(reyns, DynamicViscosityUnit.Reyn);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="DynamicViscosityUnit" /> to <see cref="DynamicViscosity" />.
+        ///     Dynamically convert from value and unit enum <see cref="DynamicViscosityUnit" /> to <see cref="DynamicViscosity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>DynamicViscosity unit value.</returns>
-        public static DynamicViscosity From(QuantityValue value, DynamicViscosityUnit fromUnit)
+        /// <returns><see cref="DynamicViscosity{T}" /> unit value.</returns>
+        public static DynamicViscosity<T> From(T value, DynamicViscosityUnit fromUnit)
         {
-            return new DynamicViscosity((double)value, fromUnit);
+            return new DynamicViscosity<T>(value, fromUnit);
         }
 
         #endregion
@@ -385,7 +373,7 @@ public static DynamicViscosity From(QuantityValue value, DynamicViscosityUnit fr
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static DynamicViscosity Parse(string str)
+        public static DynamicViscosity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -413,9 +401,9 @@ public static DynamicViscosity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static DynamicViscosity Parse(string str, IFormatProvider? provider)
+        public static DynamicViscosity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<DynamicViscosity, DynamicViscosityUnit>(
+            return QuantityParser.Default.Parse<T, DynamicViscosity<T>, DynamicViscosityUnit>(
                 str,
                 provider,
                 From);
@@ -429,7 +417,7 @@ public static DynamicViscosity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out DynamicViscosity result)
+        public static bool TryParse(string? str, out DynamicViscosity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -444,9 +432,9 @@ public static bool TryParse(string? str, out DynamicViscosity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out DynamicViscosity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out DynamicViscosity<T> result)
         {
-            return QuantityParser.Default.TryParse<DynamicViscosity, DynamicViscosityUnit>(
+            return QuantityParser.Default.TryParse<T, DynamicViscosity<T>, DynamicViscosityUnit>(
                 str,
                 provider,
                 From,
@@ -508,45 +496,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Dynam
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static DynamicViscosity operator -(DynamicViscosity right)
+        public static DynamicViscosity<T> operator -(DynamicViscosity<T> right)
         {
-            return new DynamicViscosity(-right.Value, right.Unit);
+            return new DynamicViscosity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="DynamicViscosity"/> from adding two <see cref="DynamicViscosity"/>.</summary>
-        public static DynamicViscosity operator +(DynamicViscosity left, DynamicViscosity right)
+        /// <summary>Get <see cref="DynamicViscosity{T}"/> from adding two <see cref="DynamicViscosity{T}"/>.</summary>
+        public static DynamicViscosity<T> operator +(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
-            return new DynamicViscosity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new DynamicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="DynamicViscosity"/> from subtracting two <see cref="DynamicViscosity"/>.</summary>
-        public static DynamicViscosity operator -(DynamicViscosity left, DynamicViscosity right)
+        /// <summary>Get <see cref="DynamicViscosity{T}"/> from subtracting two <see cref="DynamicViscosity{T}"/>.</summary>
+        public static DynamicViscosity<T> operator -(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
-            return new DynamicViscosity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new DynamicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="DynamicViscosity"/> from multiplying value and <see cref="DynamicViscosity"/>.</summary>
-        public static DynamicViscosity operator *(double left, DynamicViscosity right)
+        /// <summary>Get <see cref="DynamicViscosity{T}"/> from multiplying value and <see cref="DynamicViscosity{T}"/>.</summary>
+        public static DynamicViscosity<T> operator *(T left, DynamicViscosity<T> right)
         {
-            return new DynamicViscosity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new DynamicViscosity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="DynamicViscosity"/> from multiplying value and <see cref="DynamicViscosity"/>.</summary>
-        public static DynamicViscosity operator *(DynamicViscosity left, double right)
+        /// <summary>Get <see cref="DynamicViscosity{T}"/> from multiplying value and <see cref="DynamicViscosity{T}"/>.</summary>
+        public static DynamicViscosity<T> operator *(DynamicViscosity<T> left, T right)
         {
-            return new DynamicViscosity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new DynamicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="DynamicViscosity"/> from dividing <see cref="DynamicViscosity"/> by value.</summary>
-        public static DynamicViscosity operator /(DynamicViscosity left, double right)
+        /// <summary>Get <see cref="DynamicViscosity{T}"/> from dividing <see cref="DynamicViscosity{T}"/> by value.</summary>
+        public static DynamicViscosity<T> operator /(DynamicViscosity<T> left, T right)
         {
-            return new DynamicViscosity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new DynamicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="DynamicViscosity"/> by <see cref="DynamicViscosity"/>.</summary>
-        public static double operator /(DynamicViscosity left, DynamicViscosity right)
+        /// <summary>Get ratio value from dividing <see cref="DynamicViscosity{T}"/> by <see cref="DynamicViscosity{T}"/>.</summary>
+        public static T operator /(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
-            return left.NewtonSecondsPerMeterSquared / right.NewtonSecondsPerMeterSquared;
+            return CompiledLambdas.Divide(left.NewtonSecondsPerMeterSquared, right.NewtonSecondsPerMeterSquared);
         }
 
         #endregion
@@ -554,39 +547,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Dynam
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(DynamicViscosity left, DynamicViscosity right)
+        public static bool operator <=(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(DynamicViscosity left, DynamicViscosity right)
+        public static bool operator >=(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(DynamicViscosity left, DynamicViscosity right)
+        public static bool operator <(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(DynamicViscosity left, DynamicViscosity right)
+        public static bool operator >(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(DynamicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(DynamicViscosity left, DynamicViscosity right)
+        /// <remarks>Consider using <see cref="Equals(DynamicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(DynamicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(DynamicViscosity left, DynamicViscosity right)
+        /// <remarks>Consider using <see cref="Equals(DynamicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(DynamicViscosity<T> left, DynamicViscosity<T> right)
         {
             return !(left == right);
         }
@@ -595,37 +588,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Dynam
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is DynamicViscosity objDynamicViscosity)) throw new ArgumentException("Expected type DynamicViscosity.", nameof(obj));
+            if(!(obj is DynamicViscosity<T> objDynamicViscosity)) throw new ArgumentException("Expected type DynamicViscosity.", nameof(obj));
 
             return CompareTo(objDynamicViscosity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(DynamicViscosity other)
+        public int CompareTo(DynamicViscosity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(DynamicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(DynamicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is DynamicViscosity objDynamicViscosity))
+            if(obj is null || !(obj is DynamicViscosity<T> objDynamicViscosity))
                 return false;
 
             return Equals(objDynamicViscosity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(DynamicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(DynamicViscosity other)
+        /// <remarks>Consider using <see cref="Equals(DynamicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(DynamicViscosity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another DynamicViscosity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="DynamicViscosity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -663,21 +656,19 @@ public bool Equals(DynamicViscosity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(DynamicViscosity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(DynamicViscosity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current DynamicViscosity.</returns>
+        /// <returns>A hash code for the current <see cref="DynamicViscosity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -691,17 +682,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(DynamicViscosityUnit unit)
+        public T As(DynamicViscosityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -721,17 +712,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is DynamicViscosityUnit unitAsDynamicViscosityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DynamicViscosityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsDynamicViscosityUnit);
+            var asValue = As(unitAsDynamicViscosityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<DynamicViscosityUnit>.As(DynamicViscosityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this DynamicViscosity to another DynamicViscosity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="DynamicViscosity{T}" /> to another <see cref="DynamicViscosity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A DynamicViscosity with the specified unit.</returns>
-        public DynamicViscosity ToUnit(DynamicViscosityUnit unit)
+        /// <returns>A <see cref="DynamicViscosity{T}" /> with the specified unit.</returns>
+        public DynamicViscosity<T> ToUnit(DynamicViscosityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new DynamicViscosity(convertedValue, unit);
+            return new DynamicViscosity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -744,7 +740,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public DynamicViscosity ToUnit(UnitSystem unitSystem)
+        public DynamicViscosity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -764,28 +760,34 @@ public DynamicViscosity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<DynamicViscosityUnit> IQuantity<DynamicViscosityUnit>.ToUnit(DynamicViscosityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<DynamicViscosityUnit, T> IQuantityT<DynamicViscosityUnit, T>.ToUnit(DynamicViscosityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<DynamicViscosityUnit> IQuantity<DynamicViscosityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<DynamicViscosityUnit, T> IQuantityT<DynamicViscosityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case DynamicViscosityUnit.Centipoise: return (_value/10) * 1e-2d;
-                case DynamicViscosityUnit.MicropascalSecond: return (_value) * 1e-6d;
-                case DynamicViscosityUnit.MillipascalSecond: return (_value) * 1e-3d;
-                case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return _value;
-                case DynamicViscosityUnit.PascalSecond: return _value;
-                case DynamicViscosityUnit.Poise: return _value/10;
-                case DynamicViscosityUnit.PoundForceSecondPerSquareFoot: return _value * 4.7880258980335843e1;
-                case DynamicViscosityUnit.PoundForceSecondPerSquareInch: return _value * 6.8947572931683613e3;
-                case DynamicViscosityUnit.PoundPerFootSecond: return _value * 1.4881639;
-                case DynamicViscosityUnit.Reyn: return _value * 6.8947572931683613e3;
+                case DynamicViscosityUnit.Centipoise: return (Value/10) * 1e-2d;
+                case DynamicViscosityUnit.MicropascalSecond: return (Value) * 1e-6d;
+                case DynamicViscosityUnit.MillipascalSecond: return (Value) * 1e-3d;
+                case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return Value;
+                case DynamicViscosityUnit.PascalSecond: return Value;
+                case DynamicViscosityUnit.Poise: return Value/10;
+                case DynamicViscosityUnit.PoundForceSecondPerSquareFoot: return Value * 4.7880258980335843e1;
+                case DynamicViscosityUnit.PoundForceSecondPerSquareInch: return Value * 6.8947572931683613e3;
+                case DynamicViscosityUnit.PoundPerFootSecond: return Value * 1.4881639;
+                case DynamicViscosityUnit.Reyn: return Value * 6.8947572931683613e3;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -796,16 +798,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal DynamicViscosity ToBaseUnit()
+        internal DynamicViscosity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new DynamicViscosity(baseUnitValue, BaseUnit);
+            return new DynamicViscosity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(DynamicViscosityUnit unit)
+        private T GetValueAs(DynamicViscosityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -917,57 +919,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(DynamicViscosity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(DynamicViscosity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(DynamicViscosity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(DynamicViscosity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(DynamicViscosity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(DynamicViscosity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -977,33 +979,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(DynamicViscosity))
+            if(conversionType == typeof(DynamicViscosity<T>))
                 return this;
             else if(conversionType == typeof(DynamicViscosityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return DynamicViscosity.QuantityType;
+                return DynamicViscosity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return DynamicViscosity.Info;
+                return DynamicViscosity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return DynamicViscosity.BaseDimensions;
+                return DynamicViscosity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(DynamicViscosity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(DynamicViscosity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
index 7b6bfb3e45..0f18799f8f 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Electric admittance is a measure of how easily a circuit or device will allow a current to flow. It is defined as the inverse of impedance. The SI unit of admittance is the siemens (symbol S).
     /// </summary>
-    public partial struct ElectricAdmittance : IQuantity<ElectricAdmittanceUnit>, IEquatable<ElectricAdmittance>, IComparable, IComparable<ElectricAdmittance>, IConvertible, IFormattable
+    public partial struct ElectricAdmittance<T> : IQuantityT<ElectricAdmittanceUnit, T>, IEquatable<ElectricAdmittance<T>>, IComparable, IComparable<ElectricAdmittance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static ElectricAdmittance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricAdmittance(double value, ElectricAdmittanceUnit unit)
+        public ElectricAdmittance(T value, ElectricAdmittanceUnit unit)
         {
             if(unit == ElectricAdmittanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public ElectricAdmittance(double value, ElectricAdmittanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricAdmittance(double value, UnitSystem unitSystem)
+        public ElectricAdmittance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricAdmittance, which is Siemens. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricAdmittance{T}" />, which is Siemens. All conversions go via this value.
         /// </summary>
         public static ElectricAdmittanceUnit BaseUnit { get; } = ElectricAdmittanceUnit.Siemens;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricAdmittance
+        /// Represents the largest possible value of <see cref="ElectricAdmittance{T}" />
         /// </summary>
-        public static ElectricAdmittance MaxValue { get; } = new ElectricAdmittance(double.MaxValue, BaseUnit);
+        public static ElectricAdmittance<T> MaxValue { get; } = new ElectricAdmittance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricAdmittance
+        /// Represents the smallest possible value of <see cref="ElectricAdmittance{T}" />
         /// </summary>
-        public static ElectricAdmittance MinValue { get; } = new ElectricAdmittance(double.MinValue, BaseUnit);
+        public static ElectricAdmittance<T> MinValue { get; } = new ElectricAdmittance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricAdmittance;
 
         /// <summary>
-        ///     All units of measurement for the ElectricAdmittance quantity.
+        ///     All units of measurement for the <see cref="ElectricAdmittance{T}" /> quantity.
         /// </summary>
         public static ElectricAdmittanceUnit[] Units { get; } = Enum.GetValues(typeof(ElectricAdmittanceUnit)).Cast<ElectricAdmittanceUnit>().Except(new ElectricAdmittanceUnit[]{ ElectricAdmittanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Siemens.
         /// </summary>
-        public static ElectricAdmittance Zero { get; } = new ElectricAdmittance(0, BaseUnit);
+        public static ElectricAdmittance<T> Zero { get; } = new ElectricAdmittance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,36 +156,36 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricAdmittance.QuantityType;
+        public QuantityType Type => ElectricAdmittance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricAdmittance.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricAdmittance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricAdmittance in Microsiemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> in Microsiemens.
         /// </summary>
-        public double Microsiemens => As(ElectricAdmittanceUnit.Microsiemens);
+        public T Microsiemens => As(ElectricAdmittanceUnit.Microsiemens);
 
         /// <summary>
-        ///     Get ElectricAdmittance in Millisiemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> in Millisiemens.
         /// </summary>
-        public double Millisiemens => As(ElectricAdmittanceUnit.Millisiemens);
+        public T Millisiemens => As(ElectricAdmittanceUnit.Millisiemens);
 
         /// <summary>
-        ///     Get ElectricAdmittance in Nanosiemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> in Nanosiemens.
         /// </summary>
-        public double Nanosiemens => As(ElectricAdmittanceUnit.Nanosiemens);
+        public T Nanosiemens => As(ElectricAdmittanceUnit.Nanosiemens);
 
         /// <summary>
-        ///     Get ElectricAdmittance in Siemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> in Siemens.
         /// </summary>
-        public double Siemens => As(ElectricAdmittanceUnit.Siemens);
+        public T Siemens => As(ElectricAdmittanceUnit.Siemens);
 
         #endregion
 
@@ -219,51 +217,47 @@ public static string GetAbbreviation(ElectricAdmittanceUnit unit, IFormatProvide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricAdmittance from Microsiemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> from Microsiemens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromMicrosiemens(QuantityValue microsiemens)
+        public static ElectricAdmittance<T> FromMicrosiemens(T microsiemens)
         {
-            double value = (double) microsiemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens);
+            return new ElectricAdmittance<T>(microsiemens, ElectricAdmittanceUnit.Microsiemens);
         }
         /// <summary>
-        ///     Get ElectricAdmittance from Millisiemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> from Millisiemens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromMillisiemens(QuantityValue millisiemens)
+        public static ElectricAdmittance<T> FromMillisiemens(T millisiemens)
         {
-            double value = (double) millisiemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens);
+            return new ElectricAdmittance<T>(millisiemens, ElectricAdmittanceUnit.Millisiemens);
         }
         /// <summary>
-        ///     Get ElectricAdmittance from Nanosiemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> from Nanosiemens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromNanosiemens(QuantityValue nanosiemens)
+        public static ElectricAdmittance<T> FromNanosiemens(T nanosiemens)
         {
-            double value = (double) nanosiemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens);
+            return new ElectricAdmittance<T>(nanosiemens, ElectricAdmittanceUnit.Nanosiemens);
         }
         /// <summary>
-        ///     Get ElectricAdmittance from Siemens.
+        ///     Get <see cref="ElectricAdmittance{T}" /> from Siemens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromSiemens(QuantityValue siemens)
+        public static ElectricAdmittance<T> FromSiemens(T siemens)
         {
-            double value = (double) siemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens);
+            return new ElectricAdmittance<T>(siemens, ElectricAdmittanceUnit.Siemens);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricAdmittanceUnit" /> to <see cref="ElectricAdmittance" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricAdmittanceUnit" /> to <see cref="ElectricAdmittance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricAdmittance unit value.</returns>
-        public static ElectricAdmittance From(QuantityValue value, ElectricAdmittanceUnit fromUnit)
+        /// <returns><see cref="ElectricAdmittance{T}" /> unit value.</returns>
+        public static ElectricAdmittance<T> From(T value, ElectricAdmittanceUnit fromUnit)
         {
-            return new ElectricAdmittance((double)value, fromUnit);
+            return new ElectricAdmittance<T>(value, fromUnit);
         }
 
         #endregion
@@ -292,7 +286,7 @@ public static ElectricAdmittance From(QuantityValue value, ElectricAdmittanceUni
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricAdmittance Parse(string str)
+        public static ElectricAdmittance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -320,9 +314,9 @@ public static ElectricAdmittance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricAdmittance Parse(string str, IFormatProvider? provider)
+        public static ElectricAdmittance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricAdmittance, ElectricAdmittanceUnit>(
+            return QuantityParser.Default.Parse<T, ElectricAdmittance<T>, ElectricAdmittanceUnit>(
                 str,
                 provider,
                 From);
@@ -336,7 +330,7 @@ public static ElectricAdmittance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricAdmittance result)
+        public static bool TryParse(string? str, out ElectricAdmittance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -351,9 +345,9 @@ public static bool TryParse(string? str, out ElectricAdmittance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricAdmittance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricAdmittance<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricAdmittance, ElectricAdmittanceUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricAdmittance<T>, ElectricAdmittanceUnit>(
                 str,
                 provider,
                 From,
@@ -415,45 +409,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricAdmittance operator -(ElectricAdmittance right)
+        public static ElectricAdmittance<T> operator -(ElectricAdmittance<T> right)
         {
-            return new ElectricAdmittance(-right.Value, right.Unit);
+            return new ElectricAdmittance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricAdmittance"/> from adding two <see cref="ElectricAdmittance"/>.</summary>
-        public static ElectricAdmittance operator +(ElectricAdmittance left, ElectricAdmittance right)
+        /// <summary>Get <see cref="ElectricAdmittance{T}"/> from adding two <see cref="ElectricAdmittance{T}"/>.</summary>
+        public static ElectricAdmittance<T> operator +(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
-            return new ElectricAdmittance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricAdmittance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricAdmittance"/> from subtracting two <see cref="ElectricAdmittance"/>.</summary>
-        public static ElectricAdmittance operator -(ElectricAdmittance left, ElectricAdmittance right)
+        /// <summary>Get <see cref="ElectricAdmittance{T}"/> from subtracting two <see cref="ElectricAdmittance{T}"/>.</summary>
+        public static ElectricAdmittance<T> operator -(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
-            return new ElectricAdmittance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricAdmittance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricAdmittance"/> from multiplying value and <see cref="ElectricAdmittance"/>.</summary>
-        public static ElectricAdmittance operator *(double left, ElectricAdmittance right)
+        /// <summary>Get <see cref="ElectricAdmittance{T}"/> from multiplying value and <see cref="ElectricAdmittance{T}"/>.</summary>
+        public static ElectricAdmittance<T> operator *(T left, ElectricAdmittance<T> right)
         {
-            return new ElectricAdmittance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricAdmittance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricAdmittance"/> from multiplying value and <see cref="ElectricAdmittance"/>.</summary>
-        public static ElectricAdmittance operator *(ElectricAdmittance left, double right)
+        /// <summary>Get <see cref="ElectricAdmittance{T}"/> from multiplying value and <see cref="ElectricAdmittance{T}"/>.</summary>
+        public static ElectricAdmittance<T> operator *(ElectricAdmittance<T> left, T right)
         {
-            return new ElectricAdmittance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricAdmittance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricAdmittance"/> from dividing <see cref="ElectricAdmittance"/> by value.</summary>
-        public static ElectricAdmittance operator /(ElectricAdmittance left, double right)
+        /// <summary>Get <see cref="ElectricAdmittance{T}"/> from dividing <see cref="ElectricAdmittance{T}"/> by value.</summary>
+        public static ElectricAdmittance<T> operator /(ElectricAdmittance<T> left, T right)
         {
-            return new ElectricAdmittance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricAdmittance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricAdmittance"/> by <see cref="ElectricAdmittance"/>.</summary>
-        public static double operator /(ElectricAdmittance left, ElectricAdmittance right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricAdmittance{T}"/> by <see cref="ElectricAdmittance{T}"/>.</summary>
+        public static T operator /(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
-            return left.Siemens / right.Siemens;
+            return CompiledLambdas.Divide(left.Siemens, right.Siemens);
         }
 
         #endregion
@@ -461,39 +460,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricAdmittance left, ElectricAdmittance right)
+        public static bool operator <=(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricAdmittance left, ElectricAdmittance right)
+        public static bool operator >=(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricAdmittance left, ElectricAdmittance right)
+        public static bool operator <(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricAdmittance left, ElectricAdmittance right)
+        public static bool operator >(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricAdmittance left, ElectricAdmittance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricAdmittance left, ElectricAdmittance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricAdmittance<T> left, ElectricAdmittance<T> right)
         {
             return !(left == right);
         }
@@ -502,37 +501,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricAdmittance objElectricAdmittance)) throw new ArgumentException("Expected type ElectricAdmittance.", nameof(obj));
+            if(!(obj is ElectricAdmittance<T> objElectricAdmittance)) throw new ArgumentException("Expected type ElectricAdmittance.", nameof(obj));
 
             return CompareTo(objElectricAdmittance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricAdmittance other)
+        public int CompareTo(ElectricAdmittance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricAdmittance objElectricAdmittance))
+            if(obj is null || !(obj is ElectricAdmittance<T> objElectricAdmittance))
                 return false;
 
             return Equals(objElectricAdmittance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricAdmittance other)
+        /// <remarks>Consider using <see cref="Equals(ElectricAdmittance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricAdmittance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricAdmittance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricAdmittance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -570,21 +569,19 @@ public bool Equals(ElectricAdmittance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricAdmittance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricAdmittance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricAdmittance.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricAdmittance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -598,17 +595,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricAdmittanceUnit unit)
+        public T As(ElectricAdmittanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -628,17 +625,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricAdmittanceUnit unitAsElectricAdmittanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricAdmittanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricAdmittanceUnit);
+            var asValue = As(unitAsElectricAdmittanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricAdmittanceUnit>.As(ElectricAdmittanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricAdmittance to another ElectricAdmittance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricAdmittance{T}" /> to another <see cref="ElectricAdmittance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricAdmittance with the specified unit.</returns>
-        public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit)
+        /// <returns>A <see cref="ElectricAdmittance{T}" /> with the specified unit.</returns>
+        public ElectricAdmittance<T> ToUnit(ElectricAdmittanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricAdmittance(convertedValue, unit);
+            return new ElectricAdmittance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -651,7 +653,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricAdmittance ToUnit(UnitSystem unitSystem)
+        public ElectricAdmittance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -671,22 +673,28 @@ public ElectricAdmittance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricAdmittanceUnit> IQuantity<ElectricAdmittanceUnit>.ToUnit(ElectricAdmittanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricAdmittanceUnit, T> IQuantityT<ElectricAdmittanceUnit, T>.ToUnit(ElectricAdmittanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricAdmittanceUnit> IQuantity<ElectricAdmittanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricAdmittanceUnit, T> IQuantityT<ElectricAdmittanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricAdmittanceUnit.Microsiemens: return (_value) * 1e-6d;
-                case ElectricAdmittanceUnit.Millisiemens: return (_value) * 1e-3d;
-                case ElectricAdmittanceUnit.Nanosiemens: return (_value) * 1e-9d;
-                case ElectricAdmittanceUnit.Siemens: return _value;
+                case ElectricAdmittanceUnit.Microsiemens: return (Value) * 1e-6d;
+                case ElectricAdmittanceUnit.Millisiemens: return (Value) * 1e-3d;
+                case ElectricAdmittanceUnit.Nanosiemens: return (Value) * 1e-9d;
+                case ElectricAdmittanceUnit.Siemens: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -697,16 +705,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricAdmittance ToBaseUnit()
+        internal ElectricAdmittance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricAdmittance(baseUnitValue, BaseUnit);
+            return new ElectricAdmittance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricAdmittanceUnit unit)
+        private T GetValueAs(ElectricAdmittanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -812,57 +820,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricAdmittance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricAdmittance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricAdmittance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricAdmittance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricAdmittance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricAdmittance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -872,33 +880,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricAdmittance))
+            if(conversionType == typeof(ElectricAdmittance<T>))
                 return this;
             else if(conversionType == typeof(ElectricAdmittanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricAdmittance.QuantityType;
+                return ElectricAdmittance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricAdmittance.Info;
+                return ElectricAdmittance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricAdmittance.BaseDimensions;
+                return ElectricAdmittance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricAdmittance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricAdmittance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
index 2110cc871a..e98e593185 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Electric_charge
     /// </remarks>
-    public partial struct ElectricCharge : IQuantity<ElectricChargeUnit>, IEquatable<ElectricCharge>, IComparable, IComparable<ElectricCharge>, IConvertible, IFormattable
+    public partial struct ElectricCharge<T> : IQuantityT<ElectricChargeUnit, T>, IEquatable<ElectricCharge<T>>, IComparable, IComparable<ElectricCharge<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -70,12 +66,12 @@ static ElectricCharge()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricCharge(double value, ElectricChargeUnit unit)
+        public ElectricCharge(T value, ElectricChargeUnit unit)
         {
             if(unit == ElectricChargeUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -87,14 +83,14 @@ public ElectricCharge(double value, ElectricChargeUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCharge(double value, UnitSystem unitSystem)
+        public ElectricCharge(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -109,19 +105,19 @@ public ElectricCharge(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricCharge, which is Coulomb. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricCharge{T}" />, which is Coulomb. All conversions go via this value.
         /// </summary>
         public static ElectricChargeUnit BaseUnit { get; } = ElectricChargeUnit.Coulomb;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricCharge
+        /// Represents the largest possible value of <see cref="ElectricCharge{T}" />
         /// </summary>
-        public static ElectricCharge MaxValue { get; } = new ElectricCharge(double.MaxValue, BaseUnit);
+        public static ElectricCharge<T> MaxValue { get; } = new ElectricCharge<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricCharge
+        /// Represents the smallest possible value of <see cref="ElectricCharge{T}" />
         /// </summary>
-        public static ElectricCharge MinValue { get; } = new ElectricCharge(double.MinValue, BaseUnit);
+        public static ElectricCharge<T> MinValue { get; } = new ElectricCharge<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -130,14 +126,14 @@ public ElectricCharge(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricCharge;
 
         /// <summary>
-        ///     All units of measurement for the ElectricCharge quantity.
+        ///     All units of measurement for the <see cref="ElectricCharge{T}" /> quantity.
         /// </summary>
         public static ElectricChargeUnit[] Units { get; } = Enum.GetValues(typeof(ElectricChargeUnit)).Cast<ElectricChargeUnit>().Except(new ElectricChargeUnit[]{ ElectricChargeUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Coulomb.
         /// </summary>
-        public static ElectricCharge Zero { get; } = new ElectricCharge(0, BaseUnit);
+        public static ElectricCharge<T> Zero { get; } = new ElectricCharge<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -146,7 +142,9 @@ public ElectricCharge(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -162,41 +160,41 @@ public ElectricCharge(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricCharge.QuantityType;
+        public QuantityType Type => ElectricCharge<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricCharge.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricCharge<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricCharge in AmpereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> in AmpereHours.
         /// </summary>
-        public double AmpereHours => As(ElectricChargeUnit.AmpereHour);
+        public T AmpereHours => As(ElectricChargeUnit.AmpereHour);
 
         /// <summary>
-        ///     Get ElectricCharge in Coulombs.
+        ///     Get <see cref="ElectricCharge{T}" /> in Coulombs.
         /// </summary>
-        public double Coulombs => As(ElectricChargeUnit.Coulomb);
+        public T Coulombs => As(ElectricChargeUnit.Coulomb);
 
         /// <summary>
-        ///     Get ElectricCharge in KiloampereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> in KiloampereHours.
         /// </summary>
-        public double KiloampereHours => As(ElectricChargeUnit.KiloampereHour);
+        public T KiloampereHours => As(ElectricChargeUnit.KiloampereHour);
 
         /// <summary>
-        ///     Get ElectricCharge in MegaampereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> in MegaampereHours.
         /// </summary>
-        public double MegaampereHours => As(ElectricChargeUnit.MegaampereHour);
+        public T MegaampereHours => As(ElectricChargeUnit.MegaampereHour);
 
         /// <summary>
-        ///     Get ElectricCharge in MilliampereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> in MilliampereHours.
         /// </summary>
-        public double MilliampereHours => As(ElectricChargeUnit.MilliampereHour);
+        public T MilliampereHours => As(ElectricChargeUnit.MilliampereHour);
 
         #endregion
 
@@ -228,60 +226,55 @@ public static string GetAbbreviation(ElectricChargeUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricCharge from AmpereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> from AmpereHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromAmpereHours(QuantityValue amperehours)
+        public static ElectricCharge<T> FromAmpereHours(T amperehours)
         {
-            double value = (double) amperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.AmpereHour);
+            return new ElectricCharge<T>(amperehours, ElectricChargeUnit.AmpereHour);
         }
         /// <summary>
-        ///     Get ElectricCharge from Coulombs.
+        ///     Get <see cref="ElectricCharge{T}" /> from Coulombs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromCoulombs(QuantityValue coulombs)
+        public static ElectricCharge<T> FromCoulombs(T coulombs)
         {
-            double value = (double) coulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Coulomb);
+            return new ElectricCharge<T>(coulombs, ElectricChargeUnit.Coulomb);
         }
         /// <summary>
-        ///     Get ElectricCharge from KiloampereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> from KiloampereHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromKiloampereHours(QuantityValue kiloamperehours)
+        public static ElectricCharge<T> FromKiloampereHours(T kiloamperehours)
         {
-            double value = (double) kiloamperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour);
+            return new ElectricCharge<T>(kiloamperehours, ElectricChargeUnit.KiloampereHour);
         }
         /// <summary>
-        ///     Get ElectricCharge from MegaampereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> from MegaampereHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMegaampereHours(QuantityValue megaamperehours)
+        public static ElectricCharge<T> FromMegaampereHours(T megaamperehours)
         {
-            double value = (double) megaamperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour);
+            return new ElectricCharge<T>(megaamperehours, ElectricChargeUnit.MegaampereHour);
         }
         /// <summary>
-        ///     Get ElectricCharge from MilliampereHours.
+        ///     Get <see cref="ElectricCharge{T}" /> from MilliampereHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMilliampereHours(QuantityValue milliamperehours)
+        public static ElectricCharge<T> FromMilliampereHours(T milliamperehours)
         {
-            double value = (double) milliamperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour);
+            return new ElectricCharge<T>(milliamperehours, ElectricChargeUnit.MilliampereHour);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricChargeUnit" /> to <see cref="ElectricCharge" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricChargeUnit" /> to <see cref="ElectricCharge{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCharge unit value.</returns>
-        public static ElectricCharge From(QuantityValue value, ElectricChargeUnit fromUnit)
+        /// <returns><see cref="ElectricCharge{T}" /> unit value.</returns>
+        public static ElectricCharge<T> From(T value, ElectricChargeUnit fromUnit)
         {
-            return new ElectricCharge((double)value, fromUnit);
+            return new ElectricCharge<T>(value, fromUnit);
         }
 
         #endregion
@@ -310,7 +303,7 @@ public static ElectricCharge From(QuantityValue value, ElectricChargeUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricCharge Parse(string str)
+        public static ElectricCharge<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -338,9 +331,9 @@ public static ElectricCharge Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricCharge Parse(string str, IFormatProvider? provider)
+        public static ElectricCharge<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricCharge, ElectricChargeUnit>(
+            return QuantityParser.Default.Parse<T, ElectricCharge<T>, ElectricChargeUnit>(
                 str,
                 provider,
                 From);
@@ -354,7 +347,7 @@ public static ElectricCharge Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricCharge result)
+        public static bool TryParse(string? str, out ElectricCharge<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -369,9 +362,9 @@ public static bool TryParse(string? str, out ElectricCharge result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCharge result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCharge<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricCharge, ElectricChargeUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricCharge<T>, ElectricChargeUnit>(
                 str,
                 provider,
                 From,
@@ -433,45 +426,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricCharge operator -(ElectricCharge right)
+        public static ElectricCharge<T> operator -(ElectricCharge<T> right)
         {
-            return new ElectricCharge(-right.Value, right.Unit);
+            return new ElectricCharge<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCharge"/> from adding two <see cref="ElectricCharge"/>.</summary>
-        public static ElectricCharge operator +(ElectricCharge left, ElectricCharge right)
+        /// <summary>Get <see cref="ElectricCharge{T}"/> from adding two <see cref="ElectricCharge{T}"/>.</summary>
+        public static ElectricCharge<T> operator +(ElectricCharge<T> left, ElectricCharge<T> right)
         {
-            return new ElectricCharge(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCharge<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCharge"/> from subtracting two <see cref="ElectricCharge"/>.</summary>
-        public static ElectricCharge operator -(ElectricCharge left, ElectricCharge right)
+        /// <summary>Get <see cref="ElectricCharge{T}"/> from subtracting two <see cref="ElectricCharge{T}"/>.</summary>
+        public static ElectricCharge<T> operator -(ElectricCharge<T> left, ElectricCharge<T> right)
         {
-            return new ElectricCharge(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCharge<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCharge"/> from multiplying value and <see cref="ElectricCharge"/>.</summary>
-        public static ElectricCharge operator *(double left, ElectricCharge right)
+        /// <summary>Get <see cref="ElectricCharge{T}"/> from multiplying value and <see cref="ElectricCharge{T}"/>.</summary>
+        public static ElectricCharge<T> operator *(T left, ElectricCharge<T> right)
         {
-            return new ElectricCharge(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricCharge<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCharge"/> from multiplying value and <see cref="ElectricCharge"/>.</summary>
-        public static ElectricCharge operator *(ElectricCharge left, double right)
+        /// <summary>Get <see cref="ElectricCharge{T}"/> from multiplying value and <see cref="ElectricCharge{T}"/>.</summary>
+        public static ElectricCharge<T> operator *(ElectricCharge<T> left, T right)
         {
-            return new ElectricCharge(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricCharge<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCharge"/> from dividing <see cref="ElectricCharge"/> by value.</summary>
-        public static ElectricCharge operator /(ElectricCharge left, double right)
+        /// <summary>Get <see cref="ElectricCharge{T}"/> from dividing <see cref="ElectricCharge{T}"/> by value.</summary>
+        public static ElectricCharge<T> operator /(ElectricCharge<T> left, T right)
         {
-            return new ElectricCharge(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricCharge<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricCharge"/> by <see cref="ElectricCharge"/>.</summary>
-        public static double operator /(ElectricCharge left, ElectricCharge right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricCharge{T}"/> by <see cref="ElectricCharge{T}"/>.</summary>
+        public static T operator /(ElectricCharge<T> left, ElectricCharge<T> right)
         {
-            return left.Coulombs / right.Coulombs;
+            return CompiledLambdas.Divide(left.Coulombs, right.Coulombs);
         }
 
         #endregion
@@ -479,39 +477,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricCharge left, ElectricCharge right)
+        public static bool operator <=(ElectricCharge<T> left, ElectricCharge<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricCharge left, ElectricCharge right)
+        public static bool operator >=(ElectricCharge<T> left, ElectricCharge<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricCharge left, ElectricCharge right)
+        public static bool operator <(ElectricCharge<T> left, ElectricCharge<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricCharge left, ElectricCharge right)
+        public static bool operator >(ElectricCharge<T> left, ElectricCharge<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCharge, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricCharge left, ElectricCharge right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCharge{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricCharge<T> left, ElectricCharge<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCharge, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricCharge left, ElectricCharge right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCharge{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricCharge<T> left, ElectricCharge<T> right)
         {
             return !(left == right);
         }
@@ -520,37 +518,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricCharge objElectricCharge)) throw new ArgumentException("Expected type ElectricCharge.", nameof(obj));
+            if(!(obj is ElectricCharge<T> objElectricCharge)) throw new ArgumentException("Expected type ElectricCharge.", nameof(obj));
 
             return CompareTo(objElectricCharge);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricCharge other)
+        public int CompareTo(ElectricCharge<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCharge, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricCharge{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricCharge objElectricCharge))
+            if(obj is null || !(obj is ElectricCharge<T> objElectricCharge))
                 return false;
 
             return Equals(objElectricCharge);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCharge, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricCharge other)
+        /// <remarks>Consider using <see cref="Equals(ElectricCharge{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricCharge<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricCharge within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricCharge{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -588,21 +586,19 @@ public bool Equals(ElectricCharge other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricCharge other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricCharge<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricCharge.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricCharge{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -616,17 +612,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricChargeUnit unit)
+        public T As(ElectricChargeUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -646,17 +642,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricChargeUnit unitAsElectricChargeUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricChargeUnit);
+            var asValue = As(unitAsElectricChargeUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricChargeUnit>.As(ElectricChargeUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricCharge to another ElectricCharge with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricCharge{T}" /> to another <see cref="ElectricCharge{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricCharge with the specified unit.</returns>
-        public ElectricCharge ToUnit(ElectricChargeUnit unit)
+        /// <returns>A <see cref="ElectricCharge{T}" /> with the specified unit.</returns>
+        public ElectricCharge<T> ToUnit(ElectricChargeUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricCharge(convertedValue, unit);
+            return new ElectricCharge<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -669,7 +670,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricCharge ToUnit(UnitSystem unitSystem)
+        public ElectricCharge<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -689,23 +690,29 @@ public ElectricCharge ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricChargeUnit> IQuantity<ElectricChargeUnit>.ToUnit(ElectricChargeUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricChargeUnit, T> IQuantityT<ElectricChargeUnit, T>.ToUnit(ElectricChargeUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricChargeUnit> IQuantity<ElectricChargeUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricChargeUnit, T> IQuantityT<ElectricChargeUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricChargeUnit.AmpereHour: return _value/2.77777777777e-4;
-                case ElectricChargeUnit.Coulomb: return _value;
-                case ElectricChargeUnit.KiloampereHour: return (_value/2.77777777777e-4) * 1e3d;
-                case ElectricChargeUnit.MegaampereHour: return (_value/2.77777777777e-4) * 1e6d;
-                case ElectricChargeUnit.MilliampereHour: return (_value/2.77777777777e-4) * 1e-3d;
+                case ElectricChargeUnit.AmpereHour: return Value/2.77777777777e-4;
+                case ElectricChargeUnit.Coulomb: return Value;
+                case ElectricChargeUnit.KiloampereHour: return (Value/2.77777777777e-4) * 1e3d;
+                case ElectricChargeUnit.MegaampereHour: return (Value/2.77777777777e-4) * 1e6d;
+                case ElectricChargeUnit.MilliampereHour: return (Value/2.77777777777e-4) * 1e-3d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -716,16 +723,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricCharge ToBaseUnit()
+        internal ElectricCharge<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricCharge(baseUnitValue, BaseUnit);
+            return new ElectricCharge<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricChargeUnit unit)
+        private T GetValueAs(ElectricChargeUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -832,57 +839,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCharge)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCharge<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCharge)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCharge<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCharge)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCharge<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -892,33 +899,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricCharge))
+            if(conversionType == typeof(ElectricCharge<T>))
                 return this;
             else if(conversionType == typeof(ElectricChargeUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricCharge.QuantityType;
+                return ElectricCharge<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricCharge.Info;
+                return ElectricCharge<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricCharge.BaseDimensions;
+                return ElectricCharge<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricCharge)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricCharge<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
index b8b5a8262c..2156cf3536 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Charge_density
     /// </remarks>
-    public partial struct ElectricChargeDensity : IQuantity<ElectricChargeDensityUnit>, IEquatable<ElectricChargeDensity>, IComparable, IComparable<ElectricChargeDensity>, IConvertible, IFormattable
+    public partial struct ElectricChargeDensity<T> : IQuantityT<ElectricChargeDensityUnit, T>, IEquatable<ElectricChargeDensity<T>>, IComparable, IComparable<ElectricChargeDensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static ElectricChargeDensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricChargeDensity(double value, ElectricChargeDensityUnit unit)
+        public ElectricChargeDensity(T value, ElectricChargeDensityUnit unit)
         {
             if(unit == ElectricChargeDensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public ElectricChargeDensity(double value, ElectricChargeDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricChargeDensity(double value, UnitSystem unitSystem)
+        public ElectricChargeDensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricChargeDensity, which is CoulombPerCubicMeter. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricChargeDensity{T}" />, which is CoulombPerCubicMeter. All conversions go via this value.
         /// </summary>
         public static ElectricChargeDensityUnit BaseUnit { get; } = ElectricChargeDensityUnit.CoulombPerCubicMeter;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricChargeDensity
+        /// Represents the largest possible value of <see cref="ElectricChargeDensity{T}" />
         /// </summary>
-        public static ElectricChargeDensity MaxValue { get; } = new ElectricChargeDensity(double.MaxValue, BaseUnit);
+        public static ElectricChargeDensity<T> MaxValue { get; } = new ElectricChargeDensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricChargeDensity
+        /// Represents the smallest possible value of <see cref="ElectricChargeDensity{T}" />
         /// </summary>
-        public static ElectricChargeDensity MinValue { get; } = new ElectricChargeDensity(double.MinValue, BaseUnit);
+        public static ElectricChargeDensity<T> MinValue { get; } = new ElectricChargeDensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricChargeDensity;
 
         /// <summary>
-        ///     All units of measurement for the ElectricChargeDensity quantity.
+        ///     All units of measurement for the <see cref="ElectricChargeDensity{T}" /> quantity.
         /// </summary>
         public static ElectricChargeDensityUnit[] Units { get; } = Enum.GetValues(typeof(ElectricChargeDensityUnit)).Cast<ElectricChargeDensityUnit>().Except(new ElectricChargeDensityUnit[]{ ElectricChargeDensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit CoulombPerCubicMeter.
         /// </summary>
-        public static ElectricChargeDensity Zero { get; } = new ElectricChargeDensity(0, BaseUnit);
+        public static ElectricChargeDensity<T> Zero { get; } = new ElectricChargeDensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricChargeDensity.QuantityType;
+        public QuantityType Type => ElectricChargeDensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricChargeDensity.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricChargeDensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricChargeDensity in CoulombsPerCubicMeter.
+        ///     Get <see cref="ElectricChargeDensity{T}" /> in CoulombsPerCubicMeter.
         /// </summary>
-        public double CoulombsPerCubicMeter => As(ElectricChargeDensityUnit.CoulombPerCubicMeter);
+        public T CoulombsPerCubicMeter => As(ElectricChargeDensityUnit.CoulombPerCubicMeter);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(ElectricChargeDensityUnit unit, IFormatProv
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricChargeDensity from CoulombsPerCubicMeter.
+        ///     Get <see cref="ElectricChargeDensity{T}" /> from CoulombsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricChargeDensity FromCoulombsPerCubicMeter(QuantityValue coulombspercubicmeter)
+        public static ElectricChargeDensity<T> FromCoulombsPerCubicMeter(T coulombspercubicmeter)
         {
-            double value = (double) coulombspercubicmeter;
-            return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter);
+            return new ElectricChargeDensity<T>(coulombspercubicmeter, ElectricChargeDensityUnit.CoulombPerCubicMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricChargeDensityUnit" /> to <see cref="ElectricChargeDensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricChargeDensityUnit" /> to <see cref="ElectricChargeDensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricChargeDensity unit value.</returns>
-        public static ElectricChargeDensity From(QuantityValue value, ElectricChargeDensityUnit fromUnit)
+        /// <returns><see cref="ElectricChargeDensity{T}" /> unit value.</returns>
+        public static ElectricChargeDensity<T> From(T value, ElectricChargeDensityUnit fromUnit)
         {
-            return new ElectricChargeDensity((double)value, fromUnit);
+            return new ElectricChargeDensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static ElectricChargeDensity From(QuantityValue value, ElectricChargeDens
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricChargeDensity Parse(string str)
+        public static ElectricChargeDensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static ElectricChargeDensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricChargeDensity Parse(string str, IFormatProvider? provider)
+        public static ElectricChargeDensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricChargeDensity, ElectricChargeDensityUnit>(
+            return QuantityParser.Default.Parse<T, ElectricChargeDensity<T>, ElectricChargeDensityUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static ElectricChargeDensity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricChargeDensity result)
+        public static bool TryParse(string? str, out ElectricChargeDensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out ElectricChargeDensity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricChargeDensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricChargeDensity<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricChargeDensity, ElectricChargeDensityUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricChargeDensity<T>, ElectricChargeDensityUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricChargeDensity operator -(ElectricChargeDensity right)
+        public static ElectricChargeDensity<T> operator -(ElectricChargeDensity<T> right)
         {
-            return new ElectricChargeDensity(-right.Value, right.Unit);
+            return new ElectricChargeDensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricChargeDensity"/> from adding two <see cref="ElectricChargeDensity"/>.</summary>
-        public static ElectricChargeDensity operator +(ElectricChargeDensity left, ElectricChargeDensity right)
+        /// <summary>Get <see cref="ElectricChargeDensity{T}"/> from adding two <see cref="ElectricChargeDensity{T}"/>.</summary>
+        public static ElectricChargeDensity<T> operator +(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
-            return new ElectricChargeDensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricChargeDensity"/> from subtracting two <see cref="ElectricChargeDensity"/>.</summary>
-        public static ElectricChargeDensity operator -(ElectricChargeDensity left, ElectricChargeDensity right)
+        /// <summary>Get <see cref="ElectricChargeDensity{T}"/> from subtracting two <see cref="ElectricChargeDensity{T}"/>.</summary>
+        public static ElectricChargeDensity<T> operator -(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
-            return new ElectricChargeDensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricChargeDensity"/> from multiplying value and <see cref="ElectricChargeDensity"/>.</summary>
-        public static ElectricChargeDensity operator *(double left, ElectricChargeDensity right)
+        /// <summary>Get <see cref="ElectricChargeDensity{T}"/> from multiplying value and <see cref="ElectricChargeDensity{T}"/>.</summary>
+        public static ElectricChargeDensity<T> operator *(T left, ElectricChargeDensity<T> right)
         {
-            return new ElectricChargeDensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricChargeDensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricChargeDensity"/> from multiplying value and <see cref="ElectricChargeDensity"/>.</summary>
-        public static ElectricChargeDensity operator *(ElectricChargeDensity left, double right)
+        /// <summary>Get <see cref="ElectricChargeDensity{T}"/> from multiplying value and <see cref="ElectricChargeDensity{T}"/>.</summary>
+        public static ElectricChargeDensity<T> operator *(ElectricChargeDensity<T> left, T right)
         {
-            return new ElectricChargeDensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricChargeDensity"/> from dividing <see cref="ElectricChargeDensity"/> by value.</summary>
-        public static ElectricChargeDensity operator /(ElectricChargeDensity left, double right)
+        /// <summary>Get <see cref="ElectricChargeDensity{T}"/> from dividing <see cref="ElectricChargeDensity{T}"/> by value.</summary>
+        public static ElectricChargeDensity<T> operator /(ElectricChargeDensity<T> left, T right)
         {
-            return new ElectricChargeDensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricChargeDensity"/> by <see cref="ElectricChargeDensity"/>.</summary>
-        public static double operator /(ElectricChargeDensity left, ElectricChargeDensity right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricChargeDensity{T}"/> by <see cref="ElectricChargeDensity{T}"/>.</summary>
+        public static T operator /(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
-            return left.CoulombsPerCubicMeter / right.CoulombsPerCubicMeter;
+            return CompiledLambdas.Divide(left.CoulombsPerCubicMeter, right.CoulombsPerCubicMeter);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricChargeDensity left, ElectricChargeDensity right)
+        public static bool operator <=(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricChargeDensity left, ElectricChargeDensity right)
+        public static bool operator >=(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricChargeDensity left, ElectricChargeDensity right)
+        public static bool operator <(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricChargeDensity left, ElectricChargeDensity right)
+        public static bool operator >(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricChargeDensity left, ElectricChargeDensity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricChargeDensity left, ElectricChargeDensity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricChargeDensity<T> left, ElectricChargeDensity<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricChargeDensity objElectricChargeDensity)) throw new ArgumentException("Expected type ElectricChargeDensity.", nameof(obj));
+            if(!(obj is ElectricChargeDensity<T> objElectricChargeDensity)) throw new ArgumentException("Expected type ElectricChargeDensity.", nameof(obj));
 
             return CompareTo(objElectricChargeDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricChargeDensity other)
+        public int CompareTo(ElectricChargeDensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricChargeDensity objElectricChargeDensity))
+            if(obj is null || !(obj is ElectricChargeDensity<T> objElectricChargeDensity))
                 return false;
 
             return Equals(objElectricChargeDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricChargeDensity other)
+        /// <remarks>Consider using <see cref="Equals(ElectricChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricChargeDensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricChargeDensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricChargeDensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(ElectricChargeDensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricChargeDensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricChargeDensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricChargeDensity.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricChargeDensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricChargeDensityUnit unit)
+        public T As(ElectricChargeDensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricChargeDensityUnit unitAsElectricChargeDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeDensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricChargeDensityUnit);
+            var asValue = As(unitAsElectricChargeDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricChargeDensityUnit>.As(ElectricChargeDensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricChargeDensity to another ElectricChargeDensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricChargeDensity{T}" /> to another <see cref="ElectricChargeDensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricChargeDensity with the specified unit.</returns>
-        public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit)
+        /// <returns>A <see cref="ElectricChargeDensity{T}" /> with the specified unit.</returns>
+        public ElectricChargeDensity<T> ToUnit(ElectricChargeDensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricChargeDensity(convertedValue, unit);
+            return new ElectricChargeDensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricChargeDensity ToUnit(UnitSystem unitSystem)
+        public ElectricChargeDensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public ElectricChargeDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricChargeDensityUnit> IQuantity<ElectricChargeDensityUnit>.ToUnit(ElectricChargeDensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricChargeDensityUnit, T> IQuantityT<ElectricChargeDensityUnit, T>.ToUnit(ElectricChargeDensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricChargeDensityUnit> IQuantity<ElectricChargeDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricChargeDensityUnit, T> IQuantityT<ElectricChargeDensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricChargeDensityUnit.CoulombPerCubicMeter: return _value;
+                case ElectricChargeDensityUnit.CoulombPerCubicMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricChargeDensity ToBaseUnit()
+        internal ElectricChargeDensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricChargeDensity(baseUnitValue, BaseUnit);
+            return new ElectricChargeDensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricChargeDensityUnit unit)
+        private T GetValueAs(ElectricChargeDensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricChargeDensity))
+            if(conversionType == typeof(ElectricChargeDensity<T>))
                 return this;
             else if(conversionType == typeof(ElectricChargeDensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricChargeDensity.QuantityType;
+                return ElectricChargeDensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricChargeDensity.Info;
+                return ElectricChargeDensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricChargeDensity.BaseDimensions;
+                return ElectricChargeDensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricChargeDensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
index d194b12478..0fff3b78c7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Electrical_resistance_and_conductance
     /// </remarks>
-    public partial struct ElectricConductance : IQuantity<ElectricConductanceUnit>, IEquatable<ElectricConductance>, IComparable, IComparable<ElectricConductance>, IConvertible, IFormattable
+    public partial struct ElectricConductance<T> : IQuantityT<ElectricConductanceUnit, T>, IEquatable<ElectricConductance<T>>, IComparable, IComparable<ElectricConductance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static ElectricConductance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricConductance(double value, ElectricConductanceUnit unit)
+        public ElectricConductance(T value, ElectricConductanceUnit unit)
         {
             if(unit == ElectricConductanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public ElectricConductance(double value, ElectricConductanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricConductance(double value, UnitSystem unitSystem)
+        public ElectricConductance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public ElectricConductance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricConductance, which is Siemens. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricConductance{T}" />, which is Siemens. All conversions go via this value.
         /// </summary>
         public static ElectricConductanceUnit BaseUnit { get; } = ElectricConductanceUnit.Siemens;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricConductance
+        /// Represents the largest possible value of <see cref="ElectricConductance{T}" />
         /// </summary>
-        public static ElectricConductance MaxValue { get; } = new ElectricConductance(double.MaxValue, BaseUnit);
+        public static ElectricConductance<T> MaxValue { get; } = new ElectricConductance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricConductance
+        /// Represents the smallest possible value of <see cref="ElectricConductance{T}" />
         /// </summary>
-        public static ElectricConductance MinValue { get; } = new ElectricConductance(double.MinValue, BaseUnit);
+        public static ElectricConductance<T> MinValue { get; } = new ElectricConductance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public ElectricConductance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricConductance;
 
         /// <summary>
-        ///     All units of measurement for the ElectricConductance quantity.
+        ///     All units of measurement for the <see cref="ElectricConductance{T}" /> quantity.
         /// </summary>
         public static ElectricConductanceUnit[] Units { get; } = Enum.GetValues(typeof(ElectricConductanceUnit)).Cast<ElectricConductanceUnit>().Except(new ElectricConductanceUnit[]{ ElectricConductanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Siemens.
         /// </summary>
-        public static ElectricConductance Zero { get; } = new ElectricConductance(0, BaseUnit);
+        public static ElectricConductance<T> Zero { get; } = new ElectricConductance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public ElectricConductance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,31 +158,31 @@ public ElectricConductance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricConductance.QuantityType;
+        public QuantityType Type => ElectricConductance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricConductance.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricConductance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricConductance in Microsiemens.
+        ///     Get <see cref="ElectricConductance{T}" /> in Microsiemens.
         /// </summary>
-        public double Microsiemens => As(ElectricConductanceUnit.Microsiemens);
+        public T Microsiemens => As(ElectricConductanceUnit.Microsiemens);
 
         /// <summary>
-        ///     Get ElectricConductance in Millisiemens.
+        ///     Get <see cref="ElectricConductance{T}" /> in Millisiemens.
         /// </summary>
-        public double Millisiemens => As(ElectricConductanceUnit.Millisiemens);
+        public T Millisiemens => As(ElectricConductanceUnit.Millisiemens);
 
         /// <summary>
-        ///     Get ElectricConductance in Siemens.
+        ///     Get <see cref="ElectricConductance{T}" /> in Siemens.
         /// </summary>
-        public double Siemens => As(ElectricConductanceUnit.Siemens);
+        public T Siemens => As(ElectricConductanceUnit.Siemens);
 
         #endregion
 
@@ -216,42 +214,39 @@ public static string GetAbbreviation(ElectricConductanceUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricConductance from Microsiemens.
+        ///     Get <see cref="ElectricConductance{T}" /> from Microsiemens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromMicrosiemens(QuantityValue microsiemens)
+        public static ElectricConductance<T> FromMicrosiemens(T microsiemens)
         {
-            double value = (double) microsiemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens);
+            return new ElectricConductance<T>(microsiemens, ElectricConductanceUnit.Microsiemens);
         }
         /// <summary>
-        ///     Get ElectricConductance from Millisiemens.
+        ///     Get <see cref="ElectricConductance{T}" /> from Millisiemens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromMillisiemens(QuantityValue millisiemens)
+        public static ElectricConductance<T> FromMillisiemens(T millisiemens)
         {
-            double value = (double) millisiemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens);
+            return new ElectricConductance<T>(millisiemens, ElectricConductanceUnit.Millisiemens);
         }
         /// <summary>
-        ///     Get ElectricConductance from Siemens.
+        ///     Get <see cref="ElectricConductance{T}" /> from Siemens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromSiemens(QuantityValue siemens)
+        public static ElectricConductance<T> FromSiemens(T siemens)
         {
-            double value = (double) siemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Siemens);
+            return new ElectricConductance<T>(siemens, ElectricConductanceUnit.Siemens);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricConductanceUnit" /> to <see cref="ElectricConductance" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricConductanceUnit" /> to <see cref="ElectricConductance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricConductance unit value.</returns>
-        public static ElectricConductance From(QuantityValue value, ElectricConductanceUnit fromUnit)
+        /// <returns><see cref="ElectricConductance{T}" /> unit value.</returns>
+        public static ElectricConductance<T> From(T value, ElectricConductanceUnit fromUnit)
         {
-            return new ElectricConductance((double)value, fromUnit);
+            return new ElectricConductance<T>(value, fromUnit);
         }
 
         #endregion
@@ -280,7 +275,7 @@ public static ElectricConductance From(QuantityValue value, ElectricConductanceU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricConductance Parse(string str)
+        public static ElectricConductance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -308,9 +303,9 @@ public static ElectricConductance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricConductance Parse(string str, IFormatProvider? provider)
+        public static ElectricConductance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricConductance, ElectricConductanceUnit>(
+            return QuantityParser.Default.Parse<T, ElectricConductance<T>, ElectricConductanceUnit>(
                 str,
                 provider,
                 From);
@@ -324,7 +319,7 @@ public static ElectricConductance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricConductance result)
+        public static bool TryParse(string? str, out ElectricConductance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -339,9 +334,9 @@ public static bool TryParse(string? str, out ElectricConductance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricConductance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricConductance<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricConductance, ElectricConductanceUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricConductance<T>, ElectricConductanceUnit>(
                 str,
                 provider,
                 From,
@@ -403,45 +398,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricConductance operator -(ElectricConductance right)
+        public static ElectricConductance<T> operator -(ElectricConductance<T> right)
         {
-            return new ElectricConductance(-right.Value, right.Unit);
+            return new ElectricConductance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductance"/> from adding two <see cref="ElectricConductance"/>.</summary>
-        public static ElectricConductance operator +(ElectricConductance left, ElectricConductance right)
+        /// <summary>Get <see cref="ElectricConductance{T}"/> from adding two <see cref="ElectricConductance{T}"/>.</summary>
+        public static ElectricConductance<T> operator +(ElectricConductance<T> left, ElectricConductance<T> right)
         {
-            return new ElectricConductance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricConductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductance"/> from subtracting two <see cref="ElectricConductance"/>.</summary>
-        public static ElectricConductance operator -(ElectricConductance left, ElectricConductance right)
+        /// <summary>Get <see cref="ElectricConductance{T}"/> from subtracting two <see cref="ElectricConductance{T}"/>.</summary>
+        public static ElectricConductance<T> operator -(ElectricConductance<T> left, ElectricConductance<T> right)
         {
-            return new ElectricConductance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricConductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductance"/> from multiplying value and <see cref="ElectricConductance"/>.</summary>
-        public static ElectricConductance operator *(double left, ElectricConductance right)
+        /// <summary>Get <see cref="ElectricConductance{T}"/> from multiplying value and <see cref="ElectricConductance{T}"/>.</summary>
+        public static ElectricConductance<T> operator *(T left, ElectricConductance<T> right)
         {
-            return new ElectricConductance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricConductance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductance"/> from multiplying value and <see cref="ElectricConductance"/>.</summary>
-        public static ElectricConductance operator *(ElectricConductance left, double right)
+        /// <summary>Get <see cref="ElectricConductance{T}"/> from multiplying value and <see cref="ElectricConductance{T}"/>.</summary>
+        public static ElectricConductance<T> operator *(ElectricConductance<T> left, T right)
         {
-            return new ElectricConductance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricConductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductance"/> from dividing <see cref="ElectricConductance"/> by value.</summary>
-        public static ElectricConductance operator /(ElectricConductance left, double right)
+        /// <summary>Get <see cref="ElectricConductance{T}"/> from dividing <see cref="ElectricConductance{T}"/> by value.</summary>
+        public static ElectricConductance<T> operator /(ElectricConductance<T> left, T right)
         {
-            return new ElectricConductance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricConductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricConductance"/> by <see cref="ElectricConductance"/>.</summary>
-        public static double operator /(ElectricConductance left, ElectricConductance right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricConductance{T}"/> by <see cref="ElectricConductance{T}"/>.</summary>
+        public static T operator /(ElectricConductance<T> left, ElectricConductance<T> right)
         {
-            return left.Siemens / right.Siemens;
+            return CompiledLambdas.Divide(left.Siemens, right.Siemens);
         }
 
         #endregion
@@ -449,39 +449,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricConductance left, ElectricConductance right)
+        public static bool operator <=(ElectricConductance<T> left, ElectricConductance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricConductance left, ElectricConductance right)
+        public static bool operator >=(ElectricConductance<T> left, ElectricConductance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricConductance left, ElectricConductance right)
+        public static bool operator <(ElectricConductance<T> left, ElectricConductance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricConductance left, ElectricConductance right)
+        public static bool operator >(ElectricConductance<T> left, ElectricConductance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricConductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricConductance left, ElectricConductance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricConductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricConductance<T> left, ElectricConductance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricConductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricConductance left, ElectricConductance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricConductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricConductance<T> left, ElectricConductance<T> right)
         {
             return !(left == right);
         }
@@ -490,37 +490,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricConductance objElectricConductance)) throw new ArgumentException("Expected type ElectricConductance.", nameof(obj));
+            if(!(obj is ElectricConductance<T> objElectricConductance)) throw new ArgumentException("Expected type ElectricConductance.", nameof(obj));
 
             return CompareTo(objElectricConductance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricConductance other)
+        public int CompareTo(ElectricConductance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricConductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricConductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricConductance objElectricConductance))
+            if(obj is null || !(obj is ElectricConductance<T> objElectricConductance))
                 return false;
 
             return Equals(objElectricConductance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricConductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricConductance other)
+        /// <remarks>Consider using <see cref="Equals(ElectricConductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricConductance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricConductance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricConductance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -558,21 +558,19 @@ public bool Equals(ElectricConductance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricConductance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricConductance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricConductance.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricConductance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -586,17 +584,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricConductanceUnit unit)
+        public T As(ElectricConductanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -616,17 +614,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricConductanceUnit unitAsElectricConductanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricConductanceUnit);
+            var asValue = As(unitAsElectricConductanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricConductanceUnit>.As(ElectricConductanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricConductance to another ElectricConductance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricConductance{T}" /> to another <see cref="ElectricConductance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricConductance with the specified unit.</returns>
-        public ElectricConductance ToUnit(ElectricConductanceUnit unit)
+        /// <returns>A <see cref="ElectricConductance{T}" /> with the specified unit.</returns>
+        public ElectricConductance<T> ToUnit(ElectricConductanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricConductance(convertedValue, unit);
+            return new ElectricConductance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -639,7 +642,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricConductance ToUnit(UnitSystem unitSystem)
+        public ElectricConductance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -659,21 +662,27 @@ public ElectricConductance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricConductanceUnit> IQuantity<ElectricConductanceUnit>.ToUnit(ElectricConductanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricConductanceUnit, T> IQuantityT<ElectricConductanceUnit, T>.ToUnit(ElectricConductanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricConductanceUnit> IQuantity<ElectricConductanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricConductanceUnit, T> IQuantityT<ElectricConductanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricConductanceUnit.Microsiemens: return (_value) * 1e-6d;
-                case ElectricConductanceUnit.Millisiemens: return (_value) * 1e-3d;
-                case ElectricConductanceUnit.Siemens: return _value;
+                case ElectricConductanceUnit.Microsiemens: return (Value) * 1e-6d;
+                case ElectricConductanceUnit.Millisiemens: return (Value) * 1e-3d;
+                case ElectricConductanceUnit.Siemens: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -684,16 +693,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricConductance ToBaseUnit()
+        internal ElectricConductance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricConductance(baseUnitValue, BaseUnit);
+            return new ElectricConductance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricConductanceUnit unit)
+        private T GetValueAs(ElectricConductanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -798,57 +807,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricConductance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricConductance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricConductance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricConductance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricConductance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricConductance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -858,33 +867,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricConductance))
+            if(conversionType == typeof(ElectricConductance<T>))
                 return this;
             else if(conversionType == typeof(ElectricConductanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricConductance.QuantityType;
+                return ElectricConductance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricConductance.Info;
+                return ElectricConductance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricConductance.BaseDimensions;
+                return ElectricConductance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricConductance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricConductance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
index b2c2a9c1c6..62091d5f0b 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Electrical_resistivity_and_conductivity
     /// </remarks>
-    public partial struct ElectricConductivity : IQuantity<ElectricConductivityUnit>, IEquatable<ElectricConductivity>, IComparable, IComparable<ElectricConductivity>, IConvertible, IFormattable
+    public partial struct ElectricConductivity<T> : IQuantityT<ElectricConductivityUnit, T>, IEquatable<ElectricConductivity<T>>, IComparable, IComparable<ElectricConductivity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static ElectricConductivity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricConductivity(double value, ElectricConductivityUnit unit)
+        public ElectricConductivity(T value, ElectricConductivityUnit unit)
         {
             if(unit == ElectricConductivityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public ElectricConductivity(double value, ElectricConductivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricConductivity(double value, UnitSystem unitSystem)
+        public ElectricConductivity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricConductivity, which is SiemensPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricConductivity{T}" />, which is SiemensPerMeter. All conversions go via this value.
         /// </summary>
         public static ElectricConductivityUnit BaseUnit { get; } = ElectricConductivityUnit.SiemensPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricConductivity
+        /// Represents the largest possible value of <see cref="ElectricConductivity{T}" />
         /// </summary>
-        public static ElectricConductivity MaxValue { get; } = new ElectricConductivity(double.MaxValue, BaseUnit);
+        public static ElectricConductivity<T> MaxValue { get; } = new ElectricConductivity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricConductivity
+        /// Represents the smallest possible value of <see cref="ElectricConductivity{T}" />
         /// </summary>
-        public static ElectricConductivity MinValue { get; } = new ElectricConductivity(double.MinValue, BaseUnit);
+        public static ElectricConductivity<T> MinValue { get; } = new ElectricConductivity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricConductivity;
 
         /// <summary>
-        ///     All units of measurement for the ElectricConductivity quantity.
+        ///     All units of measurement for the <see cref="ElectricConductivity{T}" /> quantity.
         /// </summary>
         public static ElectricConductivityUnit[] Units { get; } = Enum.GetValues(typeof(ElectricConductivityUnit)).Cast<ElectricConductivityUnit>().Except(new ElectricConductivityUnit[]{ ElectricConductivityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit SiemensPerMeter.
         /// </summary>
-        public static ElectricConductivity Zero { get; } = new ElectricConductivity(0, BaseUnit);
+        public static ElectricConductivity<T> Zero { get; } = new ElectricConductivity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,31 +158,31 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricConductivity.QuantityType;
+        public QuantityType Type => ElectricConductivity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricConductivity.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricConductivity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricConductivity in SiemensPerFoot.
+        ///     Get <see cref="ElectricConductivity{T}" /> in SiemensPerFoot.
         /// </summary>
-        public double SiemensPerFoot => As(ElectricConductivityUnit.SiemensPerFoot);
+        public T SiemensPerFoot => As(ElectricConductivityUnit.SiemensPerFoot);
 
         /// <summary>
-        ///     Get ElectricConductivity in SiemensPerInch.
+        ///     Get <see cref="ElectricConductivity{T}" /> in SiemensPerInch.
         /// </summary>
-        public double SiemensPerInch => As(ElectricConductivityUnit.SiemensPerInch);
+        public T SiemensPerInch => As(ElectricConductivityUnit.SiemensPerInch);
 
         /// <summary>
-        ///     Get ElectricConductivity in SiemensPerMeter.
+        ///     Get <see cref="ElectricConductivity{T}" /> in SiemensPerMeter.
         /// </summary>
-        public double SiemensPerMeter => As(ElectricConductivityUnit.SiemensPerMeter);
+        public T SiemensPerMeter => As(ElectricConductivityUnit.SiemensPerMeter);
 
         #endregion
 
@@ -216,42 +214,39 @@ public static string GetAbbreviation(ElectricConductivityUnit unit, IFormatProvi
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricConductivity from SiemensPerFoot.
+        ///     Get <see cref="ElectricConductivity{T}" /> from SiemensPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerFoot(QuantityValue siemensperfoot)
+        public static ElectricConductivity<T> FromSiemensPerFoot(T siemensperfoot)
         {
-            double value = (double) siemensperfoot;
-            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot);
+            return new ElectricConductivity<T>(siemensperfoot, ElectricConductivityUnit.SiemensPerFoot);
         }
         /// <summary>
-        ///     Get ElectricConductivity from SiemensPerInch.
+        ///     Get <see cref="ElectricConductivity{T}" /> from SiemensPerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerInch(QuantityValue siemensperinch)
+        public static ElectricConductivity<T> FromSiemensPerInch(T siemensperinch)
         {
-            double value = (double) siemensperinch;
-            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch);
+            return new ElectricConductivity<T>(siemensperinch, ElectricConductivityUnit.SiemensPerInch);
         }
         /// <summary>
-        ///     Get ElectricConductivity from SiemensPerMeter.
+        ///     Get <see cref="ElectricConductivity{T}" /> from SiemensPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerMeter(QuantityValue siemenspermeter)
+        public static ElectricConductivity<T> FromSiemensPerMeter(T siemenspermeter)
         {
-            double value = (double) siemenspermeter;
-            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter);
+            return new ElectricConductivity<T>(siemenspermeter, ElectricConductivityUnit.SiemensPerMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricConductivityUnit" /> to <see cref="ElectricConductivity" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricConductivityUnit" /> to <see cref="ElectricConductivity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricConductivity unit value.</returns>
-        public static ElectricConductivity From(QuantityValue value, ElectricConductivityUnit fromUnit)
+        /// <returns><see cref="ElectricConductivity{T}" /> unit value.</returns>
+        public static ElectricConductivity<T> From(T value, ElectricConductivityUnit fromUnit)
         {
-            return new ElectricConductivity((double)value, fromUnit);
+            return new ElectricConductivity<T>(value, fromUnit);
         }
 
         #endregion
@@ -280,7 +275,7 @@ public static ElectricConductivity From(QuantityValue value, ElectricConductivit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricConductivity Parse(string str)
+        public static ElectricConductivity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -308,9 +303,9 @@ public static ElectricConductivity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricConductivity Parse(string str, IFormatProvider? provider)
+        public static ElectricConductivity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricConductivity, ElectricConductivityUnit>(
+            return QuantityParser.Default.Parse<T, ElectricConductivity<T>, ElectricConductivityUnit>(
                 str,
                 provider,
                 From);
@@ -324,7 +319,7 @@ public static ElectricConductivity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricConductivity result)
+        public static bool TryParse(string? str, out ElectricConductivity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -339,9 +334,9 @@ public static bool TryParse(string? str, out ElectricConductivity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricConductivity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricConductivity<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricConductivity, ElectricConductivityUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricConductivity<T>, ElectricConductivityUnit>(
                 str,
                 provider,
                 From,
@@ -403,45 +398,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricConductivity operator -(ElectricConductivity right)
+        public static ElectricConductivity<T> operator -(ElectricConductivity<T> right)
         {
-            return new ElectricConductivity(-right.Value, right.Unit);
+            return new ElectricConductivity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductivity"/> from adding two <see cref="ElectricConductivity"/>.</summary>
-        public static ElectricConductivity operator +(ElectricConductivity left, ElectricConductivity right)
+        /// <summary>Get <see cref="ElectricConductivity{T}"/> from adding two <see cref="ElectricConductivity{T}"/>.</summary>
+        public static ElectricConductivity<T> operator +(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
-            return new ElectricConductivity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductivity"/> from subtracting two <see cref="ElectricConductivity"/>.</summary>
-        public static ElectricConductivity operator -(ElectricConductivity left, ElectricConductivity right)
+        /// <summary>Get <see cref="ElectricConductivity{T}"/> from subtracting two <see cref="ElectricConductivity{T}"/>.</summary>
+        public static ElectricConductivity<T> operator -(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
-            return new ElectricConductivity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductivity"/> from multiplying value and <see cref="ElectricConductivity"/>.</summary>
-        public static ElectricConductivity operator *(double left, ElectricConductivity right)
+        /// <summary>Get <see cref="ElectricConductivity{T}"/> from multiplying value and <see cref="ElectricConductivity{T}"/>.</summary>
+        public static ElectricConductivity<T> operator *(T left, ElectricConductivity<T> right)
         {
-            return new ElectricConductivity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricConductivity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductivity"/> from multiplying value and <see cref="ElectricConductivity"/>.</summary>
-        public static ElectricConductivity operator *(ElectricConductivity left, double right)
+        /// <summary>Get <see cref="ElectricConductivity{T}"/> from multiplying value and <see cref="ElectricConductivity{T}"/>.</summary>
+        public static ElectricConductivity<T> operator *(ElectricConductivity<T> left, T right)
         {
-            return new ElectricConductivity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricConductivity"/> from dividing <see cref="ElectricConductivity"/> by value.</summary>
-        public static ElectricConductivity operator /(ElectricConductivity left, double right)
+        /// <summary>Get <see cref="ElectricConductivity{T}"/> from dividing <see cref="ElectricConductivity{T}"/> by value.</summary>
+        public static ElectricConductivity<T> operator /(ElectricConductivity<T> left, T right)
         {
-            return new ElectricConductivity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricConductivity"/> by <see cref="ElectricConductivity"/>.</summary>
-        public static double operator /(ElectricConductivity left, ElectricConductivity right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricConductivity{T}"/> by <see cref="ElectricConductivity{T}"/>.</summary>
+        public static T operator /(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
-            return left.SiemensPerMeter / right.SiemensPerMeter;
+            return CompiledLambdas.Divide(left.SiemensPerMeter, right.SiemensPerMeter);
         }
 
         #endregion
@@ -449,39 +449,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricConductivity left, ElectricConductivity right)
+        public static bool operator <=(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricConductivity left, ElectricConductivity right)
+        public static bool operator >=(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricConductivity left, ElectricConductivity right)
+        public static bool operator <(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricConductivity left, ElectricConductivity right)
+        public static bool operator >(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricConductivity left, ElectricConductivity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricConductivity left, ElectricConductivity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricConductivity<T> left, ElectricConductivity<T> right)
         {
             return !(left == right);
         }
@@ -490,37 +490,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricConductivity objElectricConductivity)) throw new ArgumentException("Expected type ElectricConductivity.", nameof(obj));
+            if(!(obj is ElectricConductivity<T> objElectricConductivity)) throw new ArgumentException("Expected type ElectricConductivity.", nameof(obj));
 
             return CompareTo(objElectricConductivity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricConductivity other)
+        public int CompareTo(ElectricConductivity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricConductivity objElectricConductivity))
+            if(obj is null || !(obj is ElectricConductivity<T> objElectricConductivity))
                 return false;
 
             return Equals(objElectricConductivity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricConductivity other)
+        /// <remarks>Consider using <see cref="Equals(ElectricConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricConductivity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricConductivity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricConductivity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -558,21 +558,19 @@ public bool Equals(ElectricConductivity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricConductivity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricConductivity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricConductivity.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricConductivity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -586,17 +584,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricConductivityUnit unit)
+        public T As(ElectricConductivityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -616,17 +614,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricConductivityUnit unitAsElectricConductivityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductivityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricConductivityUnit);
+            var asValue = As(unitAsElectricConductivityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricConductivityUnit>.As(ElectricConductivityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricConductivity to another ElectricConductivity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricConductivity{T}" /> to another <see cref="ElectricConductivity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricConductivity with the specified unit.</returns>
-        public ElectricConductivity ToUnit(ElectricConductivityUnit unit)
+        /// <returns>A <see cref="ElectricConductivity{T}" /> with the specified unit.</returns>
+        public ElectricConductivity<T> ToUnit(ElectricConductivityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricConductivity(convertedValue, unit);
+            return new ElectricConductivity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -639,7 +642,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricConductivity ToUnit(UnitSystem unitSystem)
+        public ElectricConductivity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -659,21 +662,27 @@ public ElectricConductivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricConductivityUnit> IQuantity<ElectricConductivityUnit>.ToUnit(ElectricConductivityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricConductivityUnit, T> IQuantityT<ElectricConductivityUnit, T>.ToUnit(ElectricConductivityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricConductivityUnit> IQuantity<ElectricConductivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricConductivityUnit, T> IQuantityT<ElectricConductivityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricConductivityUnit.SiemensPerFoot: return _value * 3.2808398950131234;
-                case ElectricConductivityUnit.SiemensPerInch: return _value * 3.937007874015748e1;
-                case ElectricConductivityUnit.SiemensPerMeter: return _value;
+                case ElectricConductivityUnit.SiemensPerFoot: return Value * 3.2808398950131234;
+                case ElectricConductivityUnit.SiemensPerInch: return Value * 3.937007874015748e1;
+                case ElectricConductivityUnit.SiemensPerMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -684,16 +693,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricConductivity ToBaseUnit()
+        internal ElectricConductivity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricConductivity(baseUnitValue, BaseUnit);
+            return new ElectricConductivity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricConductivityUnit unit)
+        private T GetValueAs(ElectricConductivityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -798,57 +807,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricConductivity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricConductivity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricConductivity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricConductivity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricConductivity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricConductivity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -858,33 +867,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricConductivity))
+            if(conversionType == typeof(ElectricConductivity<T>))
                 return this;
             else if(conversionType == typeof(ElectricConductivityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricConductivity.QuantityType;
+                return ElectricConductivity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricConductivity.Info;
+                return ElectricConductivity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricConductivity.BaseDimensions;
+                return ElectricConductivity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricConductivity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricConductivity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
index a138e6df9a..05292324f9 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     An electric current is a flow of electric charge. In electric circuits this charge is often carried by moving electrons in a wire. It can also be carried by ions in an electrolyte, or by both ions and electrons such as in a plasma.
     /// </summary>
-    public partial struct ElectricCurrent : IQuantity<ElectricCurrentUnit>, IEquatable<ElectricCurrent>, IComparable, IComparable<ElectricCurrent>, IConvertible, IFormattable
+    public partial struct ElectricCurrent<T> : IQuantityT<ElectricCurrentUnit, T>, IEquatable<ElectricCurrent<T>>, IComparable, IComparable<ElectricCurrent<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -70,12 +66,12 @@ static ElectricCurrent()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricCurrent(double value, ElectricCurrentUnit unit)
+        public ElectricCurrent(T value, ElectricCurrentUnit unit)
         {
             if(unit == ElectricCurrentUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -87,14 +83,14 @@ public ElectricCurrent(double value, ElectricCurrentUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCurrent(double value, UnitSystem unitSystem)
+        public ElectricCurrent(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -109,19 +105,19 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricCurrent, which is Ampere. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricCurrent{T}" />, which is Ampere. All conversions go via this value.
         /// </summary>
         public static ElectricCurrentUnit BaseUnit { get; } = ElectricCurrentUnit.Ampere;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricCurrent
+        /// Represents the largest possible value of <see cref="ElectricCurrent{T}" />
         /// </summary>
-        public static ElectricCurrent MaxValue { get; } = new ElectricCurrent(double.MaxValue, BaseUnit);
+        public static ElectricCurrent<T> MaxValue { get; } = new ElectricCurrent<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricCurrent
+        /// Represents the smallest possible value of <see cref="ElectricCurrent{T}" />
         /// </summary>
-        public static ElectricCurrent MinValue { get; } = new ElectricCurrent(double.MinValue, BaseUnit);
+        public static ElectricCurrent<T> MinValue { get; } = new ElectricCurrent<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -130,14 +126,14 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricCurrent;
 
         /// <summary>
-        ///     All units of measurement for the ElectricCurrent quantity.
+        ///     All units of measurement for the <see cref="ElectricCurrent{T}" /> quantity.
         /// </summary>
         public static ElectricCurrentUnit[] Units { get; } = Enum.GetValues(typeof(ElectricCurrentUnit)).Cast<ElectricCurrentUnit>().Except(new ElectricCurrentUnit[]{ ElectricCurrentUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Ampere.
         /// </summary>
-        public static ElectricCurrent Zero { get; } = new ElectricCurrent(0, BaseUnit);
+        public static ElectricCurrent<T> Zero { get; } = new ElectricCurrent<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -146,7 +142,9 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -162,56 +160,56 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricCurrent.QuantityType;
+        public QuantityType Type => ElectricCurrent<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricCurrent.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricCurrent<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricCurrent in Amperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Amperes.
         /// </summary>
-        public double Amperes => As(ElectricCurrentUnit.Ampere);
+        public T Amperes => As(ElectricCurrentUnit.Ampere);
 
         /// <summary>
-        ///     Get ElectricCurrent in Centiamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Centiamperes.
         /// </summary>
-        public double Centiamperes => As(ElectricCurrentUnit.Centiampere);
+        public T Centiamperes => As(ElectricCurrentUnit.Centiampere);
 
         /// <summary>
-        ///     Get ElectricCurrent in Kiloamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Kiloamperes.
         /// </summary>
-        public double Kiloamperes => As(ElectricCurrentUnit.Kiloampere);
+        public T Kiloamperes => As(ElectricCurrentUnit.Kiloampere);
 
         /// <summary>
-        ///     Get ElectricCurrent in Megaamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Megaamperes.
         /// </summary>
-        public double Megaamperes => As(ElectricCurrentUnit.Megaampere);
+        public T Megaamperes => As(ElectricCurrentUnit.Megaampere);
 
         /// <summary>
-        ///     Get ElectricCurrent in Microamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Microamperes.
         /// </summary>
-        public double Microamperes => As(ElectricCurrentUnit.Microampere);
+        public T Microamperes => As(ElectricCurrentUnit.Microampere);
 
         /// <summary>
-        ///     Get ElectricCurrent in Milliamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Milliamperes.
         /// </summary>
-        public double Milliamperes => As(ElectricCurrentUnit.Milliampere);
+        public T Milliamperes => As(ElectricCurrentUnit.Milliampere);
 
         /// <summary>
-        ///     Get ElectricCurrent in Nanoamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Nanoamperes.
         /// </summary>
-        public double Nanoamperes => As(ElectricCurrentUnit.Nanoampere);
+        public T Nanoamperes => As(ElectricCurrentUnit.Nanoampere);
 
         /// <summary>
-        ///     Get ElectricCurrent in Picoamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> in Picoamperes.
         /// </summary>
-        public double Picoamperes => As(ElectricCurrentUnit.Picoampere);
+        public T Picoamperes => As(ElectricCurrentUnit.Picoampere);
 
         #endregion
 
@@ -243,87 +241,79 @@ public static string GetAbbreviation(ElectricCurrentUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricCurrent from Amperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Amperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromAmperes(QuantityValue amperes)
+        public static ElectricCurrent<T> FromAmperes(T amperes)
         {
-            double value = (double) amperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Ampere);
+            return new ElectricCurrent<T>(amperes, ElectricCurrentUnit.Ampere);
         }
         /// <summary>
-        ///     Get ElectricCurrent from Centiamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Centiamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromCentiamperes(QuantityValue centiamperes)
+        public static ElectricCurrent<T> FromCentiamperes(T centiamperes)
         {
-            double value = (double) centiamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere);
+            return new ElectricCurrent<T>(centiamperes, ElectricCurrentUnit.Centiampere);
         }
         /// <summary>
-        ///     Get ElectricCurrent from Kiloamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Kiloamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromKiloamperes(QuantityValue kiloamperes)
+        public static ElectricCurrent<T> FromKiloamperes(T kiloamperes)
         {
-            double value = (double) kiloamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere);
+            return new ElectricCurrent<T>(kiloamperes, ElectricCurrentUnit.Kiloampere);
         }
         /// <summary>
-        ///     Get ElectricCurrent from Megaamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Megaamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMegaamperes(QuantityValue megaamperes)
+        public static ElectricCurrent<T> FromMegaamperes(T megaamperes)
         {
-            double value = (double) megaamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere);
+            return new ElectricCurrent<T>(megaamperes, ElectricCurrentUnit.Megaampere);
         }
         /// <summary>
-        ///     Get ElectricCurrent from Microamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Microamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMicroamperes(QuantityValue microamperes)
+        public static ElectricCurrent<T> FromMicroamperes(T microamperes)
         {
-            double value = (double) microamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Microampere);
+            return new ElectricCurrent<T>(microamperes, ElectricCurrentUnit.Microampere);
         }
         /// <summary>
-        ///     Get ElectricCurrent from Milliamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Milliamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMilliamperes(QuantityValue milliamperes)
+        public static ElectricCurrent<T> FromMilliamperes(T milliamperes)
         {
-            double value = (double) milliamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere);
+            return new ElectricCurrent<T>(milliamperes, ElectricCurrentUnit.Milliampere);
         }
         /// <summary>
-        ///     Get ElectricCurrent from Nanoamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Nanoamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromNanoamperes(QuantityValue nanoamperes)
+        public static ElectricCurrent<T> FromNanoamperes(T nanoamperes)
         {
-            double value = (double) nanoamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere);
+            return new ElectricCurrent<T>(nanoamperes, ElectricCurrentUnit.Nanoampere);
         }
         /// <summary>
-        ///     Get ElectricCurrent from Picoamperes.
+        ///     Get <see cref="ElectricCurrent{T}" /> from Picoamperes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromPicoamperes(QuantityValue picoamperes)
+        public static ElectricCurrent<T> FromPicoamperes(T picoamperes)
         {
-            double value = (double) picoamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere);
+            return new ElectricCurrent<T>(picoamperes, ElectricCurrentUnit.Picoampere);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentUnit" /> to <see cref="ElectricCurrent" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentUnit" /> to <see cref="ElectricCurrent{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCurrent unit value.</returns>
-        public static ElectricCurrent From(QuantityValue value, ElectricCurrentUnit fromUnit)
+        /// <returns><see cref="ElectricCurrent{T}" /> unit value.</returns>
+        public static ElectricCurrent<T> From(T value, ElectricCurrentUnit fromUnit)
         {
-            return new ElectricCurrent((double)value, fromUnit);
+            return new ElectricCurrent<T>(value, fromUnit);
         }
 
         #endregion
@@ -352,7 +342,7 @@ public static ElectricCurrent From(QuantityValue value, ElectricCurrentUnit from
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricCurrent Parse(string str)
+        public static ElectricCurrent<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -380,9 +370,9 @@ public static ElectricCurrent Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricCurrent Parse(string str, IFormatProvider? provider)
+        public static ElectricCurrent<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricCurrent, ElectricCurrentUnit>(
+            return QuantityParser.Default.Parse<T, ElectricCurrent<T>, ElectricCurrentUnit>(
                 str,
                 provider,
                 From);
@@ -396,7 +386,7 @@ public static ElectricCurrent Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricCurrent result)
+        public static bool TryParse(string? str, out ElectricCurrent<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -411,9 +401,9 @@ public static bool TryParse(string? str, out ElectricCurrent result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCurrent result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCurrent<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricCurrent, ElectricCurrentUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricCurrent<T>, ElectricCurrentUnit>(
                 str,
                 provider,
                 From,
@@ -475,45 +465,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricCurrent operator -(ElectricCurrent right)
+        public static ElectricCurrent<T> operator -(ElectricCurrent<T> right)
         {
-            return new ElectricCurrent(-right.Value, right.Unit);
+            return new ElectricCurrent<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrent"/> from adding two <see cref="ElectricCurrent"/>.</summary>
-        public static ElectricCurrent operator +(ElectricCurrent left, ElectricCurrent right)
+        /// <summary>Get <see cref="ElectricCurrent{T}"/> from adding two <see cref="ElectricCurrent{T}"/>.</summary>
+        public static ElectricCurrent<T> operator +(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
-            return new ElectricCurrent(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCurrent<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrent"/> from subtracting two <see cref="ElectricCurrent"/>.</summary>
-        public static ElectricCurrent operator -(ElectricCurrent left, ElectricCurrent right)
+        /// <summary>Get <see cref="ElectricCurrent{T}"/> from subtracting two <see cref="ElectricCurrent{T}"/>.</summary>
+        public static ElectricCurrent<T> operator -(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
-            return new ElectricCurrent(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCurrent<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrent"/> from multiplying value and <see cref="ElectricCurrent"/>.</summary>
-        public static ElectricCurrent operator *(double left, ElectricCurrent right)
+        /// <summary>Get <see cref="ElectricCurrent{T}"/> from multiplying value and <see cref="ElectricCurrent{T}"/>.</summary>
+        public static ElectricCurrent<T> operator *(T left, ElectricCurrent<T> right)
         {
-            return new ElectricCurrent(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricCurrent<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrent"/> from multiplying value and <see cref="ElectricCurrent"/>.</summary>
-        public static ElectricCurrent operator *(ElectricCurrent left, double right)
+        /// <summary>Get <see cref="ElectricCurrent{T}"/> from multiplying value and <see cref="ElectricCurrent{T}"/>.</summary>
+        public static ElectricCurrent<T> operator *(ElectricCurrent<T> left, T right)
         {
-            return new ElectricCurrent(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricCurrent<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrent"/> from dividing <see cref="ElectricCurrent"/> by value.</summary>
-        public static ElectricCurrent operator /(ElectricCurrent left, double right)
+        /// <summary>Get <see cref="ElectricCurrent{T}"/> from dividing <see cref="ElectricCurrent{T}"/> by value.</summary>
+        public static ElectricCurrent<T> operator /(ElectricCurrent<T> left, T right)
         {
-            return new ElectricCurrent(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricCurrent<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricCurrent"/> by <see cref="ElectricCurrent"/>.</summary>
-        public static double operator /(ElectricCurrent left, ElectricCurrent right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricCurrent{T}"/> by <see cref="ElectricCurrent{T}"/>.</summary>
+        public static T operator /(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
-            return left.Amperes / right.Amperes;
+            return CompiledLambdas.Divide(left.Amperes, right.Amperes);
         }
 
         #endregion
@@ -521,39 +516,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricCurrent left, ElectricCurrent right)
+        public static bool operator <=(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricCurrent left, ElectricCurrent right)
+        public static bool operator >=(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricCurrent left, ElectricCurrent right)
+        public static bool operator <(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricCurrent left, ElectricCurrent right)
+        public static bool operator >(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrent, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricCurrent left, ElectricCurrent right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrent{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrent, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricCurrent left, ElectricCurrent right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrent{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricCurrent<T> left, ElectricCurrent<T> right)
         {
             return !(left == right);
         }
@@ -562,37 +557,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricCurrent objElectricCurrent)) throw new ArgumentException("Expected type ElectricCurrent.", nameof(obj));
+            if(!(obj is ElectricCurrent<T> objElectricCurrent)) throw new ArgumentException("Expected type ElectricCurrent.", nameof(obj));
 
             return CompareTo(objElectricCurrent);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricCurrent other)
+        public int CompareTo(ElectricCurrent<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrent, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrent{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricCurrent objElectricCurrent))
+            if(obj is null || !(obj is ElectricCurrent<T> objElectricCurrent))
                 return false;
 
             return Equals(objElectricCurrent);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrent, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricCurrent other)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrent{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricCurrent<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricCurrent within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricCurrent{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -630,21 +625,19 @@ public bool Equals(ElectricCurrent other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricCurrent other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricCurrent<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricCurrent.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricCurrent{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -658,17 +651,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricCurrentUnit unit)
+        public T As(ElectricCurrentUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -688,17 +681,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricCurrentUnit unitAsElectricCurrentUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricCurrentUnit);
+            var asValue = As(unitAsElectricCurrentUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricCurrentUnit>.As(ElectricCurrentUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricCurrent to another ElectricCurrent with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricCurrent{T}" /> to another <see cref="ElectricCurrent{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricCurrent with the specified unit.</returns>
-        public ElectricCurrent ToUnit(ElectricCurrentUnit unit)
+        /// <returns>A <see cref="ElectricCurrent{T}" /> with the specified unit.</returns>
+        public ElectricCurrent<T> ToUnit(ElectricCurrentUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricCurrent(convertedValue, unit);
+            return new ElectricCurrent<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -711,7 +709,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricCurrent ToUnit(UnitSystem unitSystem)
+        public ElectricCurrent<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -731,26 +729,32 @@ public ElectricCurrent ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricCurrentUnit> IQuantity<ElectricCurrentUnit>.ToUnit(ElectricCurrentUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricCurrentUnit, T> IQuantityT<ElectricCurrentUnit, T>.ToUnit(ElectricCurrentUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricCurrentUnit> IQuantity<ElectricCurrentUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricCurrentUnit, T> IQuantityT<ElectricCurrentUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricCurrentUnit.Ampere: return _value;
-                case ElectricCurrentUnit.Centiampere: return (_value) * 1e-2d;
-                case ElectricCurrentUnit.Kiloampere: return (_value) * 1e3d;
-                case ElectricCurrentUnit.Megaampere: return (_value) * 1e6d;
-                case ElectricCurrentUnit.Microampere: return (_value) * 1e-6d;
-                case ElectricCurrentUnit.Milliampere: return (_value) * 1e-3d;
-                case ElectricCurrentUnit.Nanoampere: return (_value) * 1e-9d;
-                case ElectricCurrentUnit.Picoampere: return (_value) * 1e-12d;
+                case ElectricCurrentUnit.Ampere: return Value;
+                case ElectricCurrentUnit.Centiampere: return (Value) * 1e-2d;
+                case ElectricCurrentUnit.Kiloampere: return (Value) * 1e3d;
+                case ElectricCurrentUnit.Megaampere: return (Value) * 1e6d;
+                case ElectricCurrentUnit.Microampere: return (Value) * 1e-6d;
+                case ElectricCurrentUnit.Milliampere: return (Value) * 1e-3d;
+                case ElectricCurrentUnit.Nanoampere: return (Value) * 1e-9d;
+                case ElectricCurrentUnit.Picoampere: return (Value) * 1e-12d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -761,16 +765,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricCurrent ToBaseUnit()
+        internal ElectricCurrent<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricCurrent(baseUnitValue, BaseUnit);
+            return new ElectricCurrent<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricCurrentUnit unit)
+        private T GetValueAs(ElectricCurrentUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -880,57 +884,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrent)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrent<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrent)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrent<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrent)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrent<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -940,33 +944,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricCurrent))
+            if(conversionType == typeof(ElectricCurrent<T>))
                 return this;
             else if(conversionType == typeof(ElectricCurrentUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricCurrent.QuantityType;
+                return ElectricCurrent<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricCurrent.Info;
+                return ElectricCurrent<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricCurrent.BaseDimensions;
+                return ElectricCurrent<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricCurrent)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricCurrent<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
index ad6a6bdee0..ab3b6c7f3d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Current_density
     /// </remarks>
-    public partial struct ElectricCurrentDensity : IQuantity<ElectricCurrentDensityUnit>, IEquatable<ElectricCurrentDensity>, IComparable, IComparable<ElectricCurrentDensity>, IConvertible, IFormattable
+    public partial struct ElectricCurrentDensity<T> : IQuantityT<ElectricCurrentDensityUnit, T>, IEquatable<ElectricCurrentDensity<T>>, IComparable, IComparable<ElectricCurrentDensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static ElectricCurrentDensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricCurrentDensity(double value, ElectricCurrentDensityUnit unit)
+        public ElectricCurrentDensity(T value, ElectricCurrentDensityUnit unit)
         {
             if(unit == ElectricCurrentDensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public ElectricCurrentDensity(double value, ElectricCurrentDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCurrentDensity(double value, UnitSystem unitSystem)
+        public ElectricCurrentDensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricCurrentDensity, which is AmperePerSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricCurrentDensity{T}" />, which is AmperePerSquareMeter. All conversions go via this value.
         /// </summary>
         public static ElectricCurrentDensityUnit BaseUnit { get; } = ElectricCurrentDensityUnit.AmperePerSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricCurrentDensity
+        /// Represents the largest possible value of <see cref="ElectricCurrentDensity{T}" />
         /// </summary>
-        public static ElectricCurrentDensity MaxValue { get; } = new ElectricCurrentDensity(double.MaxValue, BaseUnit);
+        public static ElectricCurrentDensity<T> MaxValue { get; } = new ElectricCurrentDensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricCurrentDensity
+        /// Represents the smallest possible value of <see cref="ElectricCurrentDensity{T}" />
         /// </summary>
-        public static ElectricCurrentDensity MinValue { get; } = new ElectricCurrentDensity(double.MinValue, BaseUnit);
+        public static ElectricCurrentDensity<T> MinValue { get; } = new ElectricCurrentDensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricCurrentDensity;
 
         /// <summary>
-        ///     All units of measurement for the ElectricCurrentDensity quantity.
+        ///     All units of measurement for the <see cref="ElectricCurrentDensity{T}" /> quantity.
         /// </summary>
         public static ElectricCurrentDensityUnit[] Units { get; } = Enum.GetValues(typeof(ElectricCurrentDensityUnit)).Cast<ElectricCurrentDensityUnit>().Except(new ElectricCurrentDensityUnit[]{ ElectricCurrentDensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit AmperePerSquareMeter.
         /// </summary>
-        public static ElectricCurrentDensity Zero { get; } = new ElectricCurrentDensity(0, BaseUnit);
+        public static ElectricCurrentDensity<T> Zero { get; } = new ElectricCurrentDensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,31 +158,31 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricCurrentDensity.QuantityType;
+        public QuantityType Type => ElectricCurrentDensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricCurrentDensity.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricCurrentDensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricCurrentDensity in AmperesPerSquareFoot.
+        ///     Get <see cref="ElectricCurrentDensity{T}" /> in AmperesPerSquareFoot.
         /// </summary>
-        public double AmperesPerSquareFoot => As(ElectricCurrentDensityUnit.AmperePerSquareFoot);
+        public T AmperesPerSquareFoot => As(ElectricCurrentDensityUnit.AmperePerSquareFoot);
 
         /// <summary>
-        ///     Get ElectricCurrentDensity in AmperesPerSquareInch.
+        ///     Get <see cref="ElectricCurrentDensity{T}" /> in AmperesPerSquareInch.
         /// </summary>
-        public double AmperesPerSquareInch => As(ElectricCurrentDensityUnit.AmperePerSquareInch);
+        public T AmperesPerSquareInch => As(ElectricCurrentDensityUnit.AmperePerSquareInch);
 
         /// <summary>
-        ///     Get ElectricCurrentDensity in AmperesPerSquareMeter.
+        ///     Get <see cref="ElectricCurrentDensity{T}" /> in AmperesPerSquareMeter.
         /// </summary>
-        public double AmperesPerSquareMeter => As(ElectricCurrentDensityUnit.AmperePerSquareMeter);
+        public T AmperesPerSquareMeter => As(ElectricCurrentDensityUnit.AmperePerSquareMeter);
 
         #endregion
 
@@ -216,42 +214,39 @@ public static string GetAbbreviation(ElectricCurrentDensityUnit unit, IFormatPro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricCurrentDensity from AmperesPerSquareFoot.
+        ///     Get <see cref="ElectricCurrentDensity{T}" /> from AmperesPerSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareFoot(QuantityValue amperespersquarefoot)
+        public static ElectricCurrentDensity<T> FromAmperesPerSquareFoot(T amperespersquarefoot)
         {
-            double value = (double) amperespersquarefoot;
-            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot);
+            return new ElectricCurrentDensity<T>(amperespersquarefoot, ElectricCurrentDensityUnit.AmperePerSquareFoot);
         }
         /// <summary>
-        ///     Get ElectricCurrentDensity from AmperesPerSquareInch.
+        ///     Get <see cref="ElectricCurrentDensity{T}" /> from AmperesPerSquareInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareInch(QuantityValue amperespersquareinch)
+        public static ElectricCurrentDensity<T> FromAmperesPerSquareInch(T amperespersquareinch)
         {
-            double value = (double) amperespersquareinch;
-            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch);
+            return new ElectricCurrentDensity<T>(amperespersquareinch, ElectricCurrentDensityUnit.AmperePerSquareInch);
         }
         /// <summary>
-        ///     Get ElectricCurrentDensity from AmperesPerSquareMeter.
+        ///     Get <see cref="ElectricCurrentDensity{T}" /> from AmperesPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareMeter(QuantityValue amperespersquaremeter)
+        public static ElectricCurrentDensity<T> FromAmperesPerSquareMeter(T amperespersquaremeter)
         {
-            double value = (double) amperespersquaremeter;
-            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter);
+            return new ElectricCurrentDensity<T>(amperespersquaremeter, ElectricCurrentDensityUnit.AmperePerSquareMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentDensityUnit" /> to <see cref="ElectricCurrentDensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentDensityUnit" /> to <see cref="ElectricCurrentDensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCurrentDensity unit value.</returns>
-        public static ElectricCurrentDensity From(QuantityValue value, ElectricCurrentDensityUnit fromUnit)
+        /// <returns><see cref="ElectricCurrentDensity{T}" /> unit value.</returns>
+        public static ElectricCurrentDensity<T> From(T value, ElectricCurrentDensityUnit fromUnit)
         {
-            return new ElectricCurrentDensity((double)value, fromUnit);
+            return new ElectricCurrentDensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -280,7 +275,7 @@ public static ElectricCurrentDensity From(QuantityValue value, ElectricCurrentDe
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricCurrentDensity Parse(string str)
+        public static ElectricCurrentDensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -308,9 +303,9 @@ public static ElectricCurrentDensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricCurrentDensity Parse(string str, IFormatProvider? provider)
+        public static ElectricCurrentDensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricCurrentDensity, ElectricCurrentDensityUnit>(
+            return QuantityParser.Default.Parse<T, ElectricCurrentDensity<T>, ElectricCurrentDensityUnit>(
                 str,
                 provider,
                 From);
@@ -324,7 +319,7 @@ public static ElectricCurrentDensity Parse(string str, IFormatProvider? provider
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricCurrentDensity result)
+        public static bool TryParse(string? str, out ElectricCurrentDensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -339,9 +334,9 @@ public static bool TryParse(string? str, out ElectricCurrentDensity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCurrentDensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCurrentDensity<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricCurrentDensity, ElectricCurrentDensityUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricCurrentDensity<T>, ElectricCurrentDensityUnit>(
                 str,
                 provider,
                 From,
@@ -403,45 +398,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricCurrentDensity operator -(ElectricCurrentDensity right)
+        public static ElectricCurrentDensity<T> operator -(ElectricCurrentDensity<T> right)
         {
-            return new ElectricCurrentDensity(-right.Value, right.Unit);
+            return new ElectricCurrentDensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentDensity"/> from adding two <see cref="ElectricCurrentDensity"/>.</summary>
-        public static ElectricCurrentDensity operator +(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        /// <summary>Get <see cref="ElectricCurrentDensity{T}"/> from adding two <see cref="ElectricCurrentDensity{T}"/>.</summary>
+        public static ElectricCurrentDensity<T> operator +(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
-            return new ElectricCurrentDensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCurrentDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentDensity"/> from subtracting two <see cref="ElectricCurrentDensity"/>.</summary>
-        public static ElectricCurrentDensity operator -(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        /// <summary>Get <see cref="ElectricCurrentDensity{T}"/> from subtracting two <see cref="ElectricCurrentDensity{T}"/>.</summary>
+        public static ElectricCurrentDensity<T> operator -(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
-            return new ElectricCurrentDensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCurrentDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentDensity"/> from multiplying value and <see cref="ElectricCurrentDensity"/>.</summary>
-        public static ElectricCurrentDensity operator *(double left, ElectricCurrentDensity right)
+        /// <summary>Get <see cref="ElectricCurrentDensity{T}"/> from multiplying value and <see cref="ElectricCurrentDensity{T}"/>.</summary>
+        public static ElectricCurrentDensity<T> operator *(T left, ElectricCurrentDensity<T> right)
         {
-            return new ElectricCurrentDensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricCurrentDensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentDensity"/> from multiplying value and <see cref="ElectricCurrentDensity"/>.</summary>
-        public static ElectricCurrentDensity operator *(ElectricCurrentDensity left, double right)
+        /// <summary>Get <see cref="ElectricCurrentDensity{T}"/> from multiplying value and <see cref="ElectricCurrentDensity{T}"/>.</summary>
+        public static ElectricCurrentDensity<T> operator *(ElectricCurrentDensity<T> left, T right)
         {
-            return new ElectricCurrentDensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricCurrentDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentDensity"/> from dividing <see cref="ElectricCurrentDensity"/> by value.</summary>
-        public static ElectricCurrentDensity operator /(ElectricCurrentDensity left, double right)
+        /// <summary>Get <see cref="ElectricCurrentDensity{T}"/> from dividing <see cref="ElectricCurrentDensity{T}"/> by value.</summary>
+        public static ElectricCurrentDensity<T> operator /(ElectricCurrentDensity<T> left, T right)
         {
-            return new ElectricCurrentDensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricCurrentDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricCurrentDensity"/> by <see cref="ElectricCurrentDensity"/>.</summary>
-        public static double operator /(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricCurrentDensity{T}"/> by <see cref="ElectricCurrentDensity{T}"/>.</summary>
+        public static T operator /(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
-            return left.AmperesPerSquareMeter / right.AmperesPerSquareMeter;
+            return CompiledLambdas.Divide(left.AmperesPerSquareMeter, right.AmperesPerSquareMeter);
         }
 
         #endregion
@@ -449,39 +449,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        public static bool operator <=(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        public static bool operator >=(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        public static bool operator <(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        public static bool operator >(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricCurrentDensity<T> left, ElectricCurrentDensity<T> right)
         {
             return !(left == right);
         }
@@ -490,37 +490,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricCurrentDensity objElectricCurrentDensity)) throw new ArgumentException("Expected type ElectricCurrentDensity.", nameof(obj));
+            if(!(obj is ElectricCurrentDensity<T> objElectricCurrentDensity)) throw new ArgumentException("Expected type ElectricCurrentDensity.", nameof(obj));
 
             return CompareTo(objElectricCurrentDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricCurrentDensity other)
+        public int CompareTo(ElectricCurrentDensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricCurrentDensity objElectricCurrentDensity))
+            if(obj is null || !(obj is ElectricCurrentDensity<T> objElectricCurrentDensity))
                 return false;
 
             return Equals(objElectricCurrentDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricCurrentDensity other)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricCurrentDensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricCurrentDensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricCurrentDensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -558,21 +558,19 @@ public bool Equals(ElectricCurrentDensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricCurrentDensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricCurrentDensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricCurrentDensity.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricCurrentDensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -586,17 +584,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricCurrentDensityUnit unit)
+        public T As(ElectricCurrentDensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -616,17 +614,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricCurrentDensityUnit unitAsElectricCurrentDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentDensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricCurrentDensityUnit);
+            var asValue = As(unitAsElectricCurrentDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricCurrentDensityUnit>.As(ElectricCurrentDensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricCurrentDensity to another ElectricCurrentDensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricCurrentDensity{T}" /> to another <see cref="ElectricCurrentDensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricCurrentDensity with the specified unit.</returns>
-        public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit)
+        /// <returns>A <see cref="ElectricCurrentDensity{T}" /> with the specified unit.</returns>
+        public ElectricCurrentDensity<T> ToUnit(ElectricCurrentDensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricCurrentDensity(convertedValue, unit);
+            return new ElectricCurrentDensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -639,7 +642,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricCurrentDensity ToUnit(UnitSystem unitSystem)
+        public ElectricCurrentDensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -659,21 +662,27 @@ public ElectricCurrentDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricCurrentDensityUnit> IQuantity<ElectricCurrentDensityUnit>.ToUnit(ElectricCurrentDensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricCurrentDensityUnit, T> IQuantityT<ElectricCurrentDensityUnit, T>.ToUnit(ElectricCurrentDensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricCurrentDensityUnit> IQuantity<ElectricCurrentDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricCurrentDensityUnit, T> IQuantityT<ElectricCurrentDensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricCurrentDensityUnit.AmperePerSquareFoot: return _value * 1.0763910416709722e1;
-                case ElectricCurrentDensityUnit.AmperePerSquareInch: return _value * 1.5500031000062000e3;
-                case ElectricCurrentDensityUnit.AmperePerSquareMeter: return _value;
+                case ElectricCurrentDensityUnit.AmperePerSquareFoot: return Value * 1.0763910416709722e1;
+                case ElectricCurrentDensityUnit.AmperePerSquareInch: return Value * 1.5500031000062000e3;
+                case ElectricCurrentDensityUnit.AmperePerSquareMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -684,16 +693,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricCurrentDensity ToBaseUnit()
+        internal ElectricCurrentDensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricCurrentDensity(baseUnitValue, BaseUnit);
+            return new ElectricCurrentDensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricCurrentDensityUnit unit)
+        private T GetValueAs(ElectricCurrentDensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -798,57 +807,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -858,33 +867,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricCurrentDensity))
+            if(conversionType == typeof(ElectricCurrentDensity<T>))
                 return this;
             else if(conversionType == typeof(ElectricCurrentDensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricCurrentDensity.QuantityType;
+                return ElectricCurrentDensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricCurrentDensity.Info;
+                return ElectricCurrentDensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricCurrentDensity.BaseDimensions;
+                return ElectricCurrentDensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricCurrentDensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
index e7ee8be7ec..5e3ff6a174 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In electromagnetism, the current gradient describes how the current changes in time.
     /// </summary>
-    public partial struct ElectricCurrentGradient : IQuantity<ElectricCurrentGradientUnit>, IEquatable<ElectricCurrentGradient>, IComparable, IComparable<ElectricCurrentGradient>, IConvertible, IFormattable
+    public partial struct ElectricCurrentGradient<T> : IQuantityT<ElectricCurrentGradientUnit, T>, IEquatable<ElectricCurrentGradient<T>>, IComparable, IComparable<ElectricCurrentGradient<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static ElectricCurrentGradient()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit)
+        public ElectricCurrentGradient(T value, ElectricCurrentGradientUnit unit)
         {
             if(unit == ElectricCurrentGradientUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCurrentGradient(double value, UnitSystem unitSystem)
+        public ElectricCurrentGradient(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricCurrentGradient, which is AmperePerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricCurrentGradient{T}" />, which is AmperePerSecond. All conversions go via this value.
         /// </summary>
         public static ElectricCurrentGradientUnit BaseUnit { get; } = ElectricCurrentGradientUnit.AmperePerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricCurrentGradient
+        /// Represents the largest possible value of <see cref="ElectricCurrentGradient{T}" />
         /// </summary>
-        public static ElectricCurrentGradient MaxValue { get; } = new ElectricCurrentGradient(double.MaxValue, BaseUnit);
+        public static ElectricCurrentGradient<T> MaxValue { get; } = new ElectricCurrentGradient<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricCurrentGradient
+        /// Represents the smallest possible value of <see cref="ElectricCurrentGradient{T}" />
         /// </summary>
-        public static ElectricCurrentGradient MinValue { get; } = new ElectricCurrentGradient(double.MinValue, BaseUnit);
+        public static ElectricCurrentGradient<T> MinValue { get; } = new ElectricCurrentGradient<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricCurrentGradient;
 
         /// <summary>
-        ///     All units of measurement for the ElectricCurrentGradient quantity.
+        ///     All units of measurement for the <see cref="ElectricCurrentGradient{T}" /> quantity.
         /// </summary>
         public static ElectricCurrentGradientUnit[] Units { get; } = Enum.GetValues(typeof(ElectricCurrentGradientUnit)).Cast<ElectricCurrentGradientUnit>().Except(new ElectricCurrentGradientUnit[]{ ElectricCurrentGradientUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit AmperePerSecond.
         /// </summary>
-        public static ElectricCurrentGradient Zero { get; } = new ElectricCurrentGradient(0, BaseUnit);
+        public static ElectricCurrentGradient<T> Zero { get; } = new ElectricCurrentGradient<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,36 +156,36 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricCurrentGradient.QuantityType;
+        public QuantityType Type => ElectricCurrentGradient<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricCurrentGradient.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricCurrentGradient<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricCurrentGradient in AmperesPerMicrosecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> in AmperesPerMicrosecond.
         /// </summary>
-        public double AmperesPerMicrosecond => As(ElectricCurrentGradientUnit.AmperePerMicrosecond);
+        public T AmperesPerMicrosecond => As(ElectricCurrentGradientUnit.AmperePerMicrosecond);
 
         /// <summary>
-        ///     Get ElectricCurrentGradient in AmperesPerMillisecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> in AmperesPerMillisecond.
         /// </summary>
-        public double AmperesPerMillisecond => As(ElectricCurrentGradientUnit.AmperePerMillisecond);
+        public T AmperesPerMillisecond => As(ElectricCurrentGradientUnit.AmperePerMillisecond);
 
         /// <summary>
-        ///     Get ElectricCurrentGradient in AmperesPerNanosecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> in AmperesPerNanosecond.
         /// </summary>
-        public double AmperesPerNanosecond => As(ElectricCurrentGradientUnit.AmperePerNanosecond);
+        public T AmperesPerNanosecond => As(ElectricCurrentGradientUnit.AmperePerNanosecond);
 
         /// <summary>
-        ///     Get ElectricCurrentGradient in AmperesPerSecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> in AmperesPerSecond.
         /// </summary>
-        public double AmperesPerSecond => As(ElectricCurrentGradientUnit.AmperePerSecond);
+        public T AmperesPerSecond => As(ElectricCurrentGradientUnit.AmperePerSecond);
 
         #endregion
 
@@ -219,51 +217,47 @@ public static string GetAbbreviation(ElectricCurrentGradientUnit unit, IFormatPr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricCurrentGradient from AmperesPerMicrosecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> from AmperesPerMicrosecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMicrosecond(QuantityValue amperespermicrosecond)
+        public static ElectricCurrentGradient<T> FromAmperesPerMicrosecond(T amperespermicrosecond)
         {
-            double value = (double) amperespermicrosecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond);
+            return new ElectricCurrentGradient<T>(amperespermicrosecond, ElectricCurrentGradientUnit.AmperePerMicrosecond);
         }
         /// <summary>
-        ///     Get ElectricCurrentGradient from AmperesPerMillisecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> from AmperesPerMillisecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMillisecond(QuantityValue amperespermillisecond)
+        public static ElectricCurrentGradient<T> FromAmperesPerMillisecond(T amperespermillisecond)
         {
-            double value = (double) amperespermillisecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond);
+            return new ElectricCurrentGradient<T>(amperespermillisecond, ElectricCurrentGradientUnit.AmperePerMillisecond);
         }
         /// <summary>
-        ///     Get ElectricCurrentGradient from AmperesPerNanosecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> from AmperesPerNanosecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerNanosecond(QuantityValue amperespernanosecond)
+        public static ElectricCurrentGradient<T> FromAmperesPerNanosecond(T amperespernanosecond)
         {
-            double value = (double) amperespernanosecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond);
+            return new ElectricCurrentGradient<T>(amperespernanosecond, ElectricCurrentGradientUnit.AmperePerNanosecond);
         }
         /// <summary>
-        ///     Get ElectricCurrentGradient from AmperesPerSecond.
+        ///     Get <see cref="ElectricCurrentGradient{T}" /> from AmperesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerSecond(QuantityValue amperespersecond)
+        public static ElectricCurrentGradient<T> FromAmperesPerSecond(T amperespersecond)
         {
-            double value = (double) amperespersecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond);
+            return new ElectricCurrentGradient<T>(amperespersecond, ElectricCurrentGradientUnit.AmperePerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentGradientUnit" /> to <see cref="ElectricCurrentGradient" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentGradientUnit" /> to <see cref="ElectricCurrentGradient{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCurrentGradient unit value.</returns>
-        public static ElectricCurrentGradient From(QuantityValue value, ElectricCurrentGradientUnit fromUnit)
+        /// <returns><see cref="ElectricCurrentGradient{T}" /> unit value.</returns>
+        public static ElectricCurrentGradient<T> From(T value, ElectricCurrentGradientUnit fromUnit)
         {
-            return new ElectricCurrentGradient((double)value, fromUnit);
+            return new ElectricCurrentGradient<T>(value, fromUnit);
         }
 
         #endregion
@@ -292,7 +286,7 @@ public static ElectricCurrentGradient From(QuantityValue value, ElectricCurrentG
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricCurrentGradient Parse(string str)
+        public static ElectricCurrentGradient<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -320,9 +314,9 @@ public static ElectricCurrentGradient Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricCurrentGradient Parse(string str, IFormatProvider? provider)
+        public static ElectricCurrentGradient<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricCurrentGradient, ElectricCurrentGradientUnit>(
+            return QuantityParser.Default.Parse<T, ElectricCurrentGradient<T>, ElectricCurrentGradientUnit>(
                 str,
                 provider,
                 From);
@@ -336,7 +330,7 @@ public static ElectricCurrentGradient Parse(string str, IFormatProvider? provide
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricCurrentGradient result)
+        public static bool TryParse(string? str, out ElectricCurrentGradient<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -351,9 +345,9 @@ public static bool TryParse(string? str, out ElectricCurrentGradient result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCurrentGradient result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricCurrentGradient<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricCurrentGradient, ElectricCurrentGradientUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricCurrentGradient<T>, ElectricCurrentGradientUnit>(
                 str,
                 provider,
                 From,
@@ -415,45 +409,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricCurrentGradient operator -(ElectricCurrentGradient right)
+        public static ElectricCurrentGradient<T> operator -(ElectricCurrentGradient<T> right)
         {
-            return new ElectricCurrentGradient(-right.Value, right.Unit);
+            return new ElectricCurrentGradient<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentGradient"/> from adding two <see cref="ElectricCurrentGradient"/>.</summary>
-        public static ElectricCurrentGradient operator +(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        /// <summary>Get <see cref="ElectricCurrentGradient{T}"/> from adding two <see cref="ElectricCurrentGradient{T}"/>.</summary>
+        public static ElectricCurrentGradient<T> operator +(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
-            return new ElectricCurrentGradient(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCurrentGradient<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentGradient"/> from subtracting two <see cref="ElectricCurrentGradient"/>.</summary>
-        public static ElectricCurrentGradient operator -(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        /// <summary>Get <see cref="ElectricCurrentGradient{T}"/> from subtracting two <see cref="ElectricCurrentGradient{T}"/>.</summary>
+        public static ElectricCurrentGradient<T> operator -(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
-            return new ElectricCurrentGradient(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricCurrentGradient<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentGradient"/> from multiplying value and <see cref="ElectricCurrentGradient"/>.</summary>
-        public static ElectricCurrentGradient operator *(double left, ElectricCurrentGradient right)
+        /// <summary>Get <see cref="ElectricCurrentGradient{T}"/> from multiplying value and <see cref="ElectricCurrentGradient{T}"/>.</summary>
+        public static ElectricCurrentGradient<T> operator *(T left, ElectricCurrentGradient<T> right)
         {
-            return new ElectricCurrentGradient(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricCurrentGradient<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentGradient"/> from multiplying value and <see cref="ElectricCurrentGradient"/>.</summary>
-        public static ElectricCurrentGradient operator *(ElectricCurrentGradient left, double right)
+        /// <summary>Get <see cref="ElectricCurrentGradient{T}"/> from multiplying value and <see cref="ElectricCurrentGradient{T}"/>.</summary>
+        public static ElectricCurrentGradient<T> operator *(ElectricCurrentGradient<T> left, T right)
         {
-            return new ElectricCurrentGradient(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricCurrentGradient<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricCurrentGradient"/> from dividing <see cref="ElectricCurrentGradient"/> by value.</summary>
-        public static ElectricCurrentGradient operator /(ElectricCurrentGradient left, double right)
+        /// <summary>Get <see cref="ElectricCurrentGradient{T}"/> from dividing <see cref="ElectricCurrentGradient{T}"/> by value.</summary>
+        public static ElectricCurrentGradient<T> operator /(ElectricCurrentGradient<T> left, T right)
         {
-            return new ElectricCurrentGradient(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricCurrentGradient<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricCurrentGradient"/> by <see cref="ElectricCurrentGradient"/>.</summary>
-        public static double operator /(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricCurrentGradient{T}"/> by <see cref="ElectricCurrentGradient{T}"/>.</summary>
+        public static T operator /(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
-            return left.AmperesPerSecond / right.AmperesPerSecond;
+            return CompiledLambdas.Divide(left.AmperesPerSecond, right.AmperesPerSecond);
         }
 
         #endregion
@@ -461,39 +460,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        public static bool operator <=(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        public static bool operator >=(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        public static bool operator <(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        public static bool operator >(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricCurrentGradient<T> left, ElectricCurrentGradient<T> right)
         {
             return !(left == right);
         }
@@ -502,37 +501,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricCurrentGradient objElectricCurrentGradient)) throw new ArgumentException("Expected type ElectricCurrentGradient.", nameof(obj));
+            if(!(obj is ElectricCurrentGradient<T> objElectricCurrentGradient)) throw new ArgumentException("Expected type ElectricCurrentGradient.", nameof(obj));
 
             return CompareTo(objElectricCurrentGradient);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricCurrentGradient other)
+        public int CompareTo(ElectricCurrentGradient<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricCurrentGradient objElectricCurrentGradient))
+            if(obj is null || !(obj is ElectricCurrentGradient<T> objElectricCurrentGradient))
                 return false;
 
             return Equals(objElectricCurrentGradient);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricCurrentGradient other)
+        /// <remarks>Consider using <see cref="Equals(ElectricCurrentGradient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricCurrentGradient<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricCurrentGradient within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricCurrentGradient{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -570,21 +569,19 @@ public bool Equals(ElectricCurrentGradient other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricCurrentGradient other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricCurrentGradient<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricCurrentGradient.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricCurrentGradient{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -598,17 +595,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricCurrentGradientUnit unit)
+        public T As(ElectricCurrentGradientUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -628,17 +625,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricCurrentGradientUnit unitAsElectricCurrentGradientUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentGradientUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricCurrentGradientUnit);
+            var asValue = As(unitAsElectricCurrentGradientUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricCurrentGradientUnit>.As(ElectricCurrentGradientUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricCurrentGradient to another ElectricCurrentGradient with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricCurrentGradient{T}" /> to another <see cref="ElectricCurrentGradient{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricCurrentGradient with the specified unit.</returns>
-        public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit)
+        /// <returns>A <see cref="ElectricCurrentGradient{T}" /> with the specified unit.</returns>
+        public ElectricCurrentGradient<T> ToUnit(ElectricCurrentGradientUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricCurrentGradient(convertedValue, unit);
+            return new ElectricCurrentGradient<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -651,7 +653,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricCurrentGradient ToUnit(UnitSystem unitSystem)
+        public ElectricCurrentGradient<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -671,22 +673,28 @@ public ElectricCurrentGradient ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricCurrentGradientUnit> IQuantity<ElectricCurrentGradientUnit>.ToUnit(ElectricCurrentGradientUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricCurrentGradientUnit, T> IQuantityT<ElectricCurrentGradientUnit, T>.ToUnit(ElectricCurrentGradientUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricCurrentGradientUnit> IQuantity<ElectricCurrentGradientUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricCurrentGradientUnit, T> IQuantityT<ElectricCurrentGradientUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricCurrentGradientUnit.AmperePerMicrosecond: return _value*1E6;
-                case ElectricCurrentGradientUnit.AmperePerMillisecond: return _value*1E3;
-                case ElectricCurrentGradientUnit.AmperePerNanosecond: return _value*1E9;
-                case ElectricCurrentGradientUnit.AmperePerSecond: return _value;
+                case ElectricCurrentGradientUnit.AmperePerMicrosecond: return Value*1E6;
+                case ElectricCurrentGradientUnit.AmperePerMillisecond: return Value*1E3;
+                case ElectricCurrentGradientUnit.AmperePerNanosecond: return Value*1E9;
+                case ElectricCurrentGradientUnit.AmperePerSecond: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -697,16 +705,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricCurrentGradient ToBaseUnit()
+        internal ElectricCurrentGradient<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricCurrentGradient(baseUnitValue, BaseUnit);
+            return new ElectricCurrentGradient<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricCurrentGradientUnit unit)
+        private T GetValueAs(ElectricCurrentGradientUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -812,57 +820,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -872,33 +880,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricCurrentGradient))
+            if(conversionType == typeof(ElectricCurrentGradient<T>))
                 return this;
             else if(conversionType == typeof(ElectricCurrentGradientUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricCurrentGradient.QuantityType;
+                return ElectricCurrentGradient<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricCurrentGradient.Info;
+                return ElectricCurrentGradient<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricCurrentGradient.BaseDimensions;
+                return ElectricCurrentGradient<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricCurrentGradient<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
index 6c96205931..378a039b53 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Electric_field
     /// </remarks>
-    public partial struct ElectricField : IQuantity<ElectricFieldUnit>, IEquatable<ElectricField>, IComparable, IComparable<ElectricField>, IConvertible, IFormattable
+    public partial struct ElectricField<T> : IQuantityT<ElectricFieldUnit, T>, IEquatable<ElectricField<T>>, IComparable, IComparable<ElectricField<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static ElectricField()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricField(double value, ElectricFieldUnit unit)
+        public ElectricField(T value, ElectricFieldUnit unit)
         {
             if(unit == ElectricFieldUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public ElectricField(double value, ElectricFieldUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricField(double value, UnitSystem unitSystem)
+        public ElectricField(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public ElectricField(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricField, which is VoltPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricField{T}" />, which is VoltPerMeter. All conversions go via this value.
         /// </summary>
         public static ElectricFieldUnit BaseUnit { get; } = ElectricFieldUnit.VoltPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricField
+        /// Represents the largest possible value of <see cref="ElectricField{T}" />
         /// </summary>
-        public static ElectricField MaxValue { get; } = new ElectricField(double.MaxValue, BaseUnit);
+        public static ElectricField<T> MaxValue { get; } = new ElectricField<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricField
+        /// Represents the smallest possible value of <see cref="ElectricField{T}" />
         /// </summary>
-        public static ElectricField MinValue { get; } = new ElectricField(double.MinValue, BaseUnit);
+        public static ElectricField<T> MinValue { get; } = new ElectricField<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public ElectricField(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricField;
 
         /// <summary>
-        ///     All units of measurement for the ElectricField quantity.
+        ///     All units of measurement for the <see cref="ElectricField{T}" /> quantity.
         /// </summary>
         public static ElectricFieldUnit[] Units { get; } = Enum.GetValues(typeof(ElectricFieldUnit)).Cast<ElectricFieldUnit>().Except(new ElectricFieldUnit[]{ ElectricFieldUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit VoltPerMeter.
         /// </summary>
-        public static ElectricField Zero { get; } = new ElectricField(0, BaseUnit);
+        public static ElectricField<T> Zero { get; } = new ElectricField<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public ElectricField(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public ElectricField(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricField.QuantityType;
+        public QuantityType Type => ElectricField<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricField.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricField<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricField in VoltsPerMeter.
+        ///     Get <see cref="ElectricField{T}" /> in VoltsPerMeter.
         /// </summary>
-        public double VoltsPerMeter => As(ElectricFieldUnit.VoltPerMeter);
+        public T VoltsPerMeter => As(ElectricFieldUnit.VoltPerMeter);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(ElectricFieldUnit unit, IFormatProvider? pr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricField from VoltsPerMeter.
+        ///     Get <see cref="ElectricField{T}" /> from VoltsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricField FromVoltsPerMeter(QuantityValue voltspermeter)
+        public static ElectricField<T> FromVoltsPerMeter(T voltspermeter)
         {
-            double value = (double) voltspermeter;
-            return new ElectricField(value, ElectricFieldUnit.VoltPerMeter);
+            return new ElectricField<T>(voltspermeter, ElectricFieldUnit.VoltPerMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricFieldUnit" /> to <see cref="ElectricField" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricFieldUnit" /> to <see cref="ElectricField{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricField unit value.</returns>
-        public static ElectricField From(QuantityValue value, ElectricFieldUnit fromUnit)
+        /// <returns><see cref="ElectricField{T}" /> unit value.</returns>
+        public static ElectricField<T> From(T value, ElectricFieldUnit fromUnit)
         {
-            return new ElectricField((double)value, fromUnit);
+            return new ElectricField<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static ElectricField From(QuantityValue value, ElectricFieldUnit fromUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricField Parse(string str)
+        public static ElectricField<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static ElectricField Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricField Parse(string str, IFormatProvider? provider)
+        public static ElectricField<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricField, ElectricFieldUnit>(
+            return QuantityParser.Default.Parse<T, ElectricField<T>, ElectricFieldUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static ElectricField Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricField result)
+        public static bool TryParse(string? str, out ElectricField<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out ElectricField result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricField result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricField<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricField, ElectricFieldUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricField<T>, ElectricFieldUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricField operator -(ElectricField right)
+        public static ElectricField<T> operator -(ElectricField<T> right)
         {
-            return new ElectricField(-right.Value, right.Unit);
+            return new ElectricField<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricField"/> from adding two <see cref="ElectricField"/>.</summary>
-        public static ElectricField operator +(ElectricField left, ElectricField right)
+        /// <summary>Get <see cref="ElectricField{T}"/> from adding two <see cref="ElectricField{T}"/>.</summary>
+        public static ElectricField<T> operator +(ElectricField<T> left, ElectricField<T> right)
         {
-            return new ElectricField(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricField<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricField"/> from subtracting two <see cref="ElectricField"/>.</summary>
-        public static ElectricField operator -(ElectricField left, ElectricField right)
+        /// <summary>Get <see cref="ElectricField{T}"/> from subtracting two <see cref="ElectricField{T}"/>.</summary>
+        public static ElectricField<T> operator -(ElectricField<T> left, ElectricField<T> right)
         {
-            return new ElectricField(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricField<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricField"/> from multiplying value and <see cref="ElectricField"/>.</summary>
-        public static ElectricField operator *(double left, ElectricField right)
+        /// <summary>Get <see cref="ElectricField{T}"/> from multiplying value and <see cref="ElectricField{T}"/>.</summary>
+        public static ElectricField<T> operator *(T left, ElectricField<T> right)
         {
-            return new ElectricField(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricField<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricField"/> from multiplying value and <see cref="ElectricField"/>.</summary>
-        public static ElectricField operator *(ElectricField left, double right)
+        /// <summary>Get <see cref="ElectricField{T}"/> from multiplying value and <see cref="ElectricField{T}"/>.</summary>
+        public static ElectricField<T> operator *(ElectricField<T> left, T right)
         {
-            return new ElectricField(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricField<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricField"/> from dividing <see cref="ElectricField"/> by value.</summary>
-        public static ElectricField operator /(ElectricField left, double right)
+        /// <summary>Get <see cref="ElectricField{T}"/> from dividing <see cref="ElectricField{T}"/> by value.</summary>
+        public static ElectricField<T> operator /(ElectricField<T> left, T right)
         {
-            return new ElectricField(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricField<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricField"/> by <see cref="ElectricField"/>.</summary>
-        public static double operator /(ElectricField left, ElectricField right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricField{T}"/> by <see cref="ElectricField{T}"/>.</summary>
+        public static T operator /(ElectricField<T> left, ElectricField<T> right)
         {
-            return left.VoltsPerMeter / right.VoltsPerMeter;
+            return CompiledLambdas.Divide(left.VoltsPerMeter, right.VoltsPerMeter);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricField left, ElectricField right)
+        public static bool operator <=(ElectricField<T> left, ElectricField<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricField left, ElectricField right)
+        public static bool operator >=(ElectricField<T> left, ElectricField<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricField left, ElectricField right)
+        public static bool operator <(ElectricField<T> left, ElectricField<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricField left, ElectricField right)
+        public static bool operator >(ElectricField<T> left, ElectricField<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricField left, ElectricField right)
+        /// <remarks>Consider using <see cref="Equals(ElectricField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricField<T> left, ElectricField<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricField left, ElectricField right)
+        /// <remarks>Consider using <see cref="Equals(ElectricField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricField<T> left, ElectricField<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricField objElectricField)) throw new ArgumentException("Expected type ElectricField.", nameof(obj));
+            if(!(obj is ElectricField<T> objElectricField)) throw new ArgumentException("Expected type ElectricField.", nameof(obj));
 
             return CompareTo(objElectricField);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricField other)
+        public int CompareTo(ElectricField<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricField objElectricField))
+            if(obj is null || !(obj is ElectricField<T> objElectricField))
                 return false;
 
             return Equals(objElectricField);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricField other)
+        /// <remarks>Consider using <see cref="Equals(ElectricField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricField<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricField within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricField{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(ElectricField other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricField other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricField<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricField.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricField{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricFieldUnit unit)
+        public T As(ElectricFieldUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricFieldUnit unitAsElectricFieldUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricFieldUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricFieldUnit);
+            var asValue = As(unitAsElectricFieldUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricFieldUnit>.As(ElectricFieldUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricField to another ElectricField with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricField{T}" /> to another <see cref="ElectricField{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricField with the specified unit.</returns>
-        public ElectricField ToUnit(ElectricFieldUnit unit)
+        /// <returns>A <see cref="ElectricField{T}" /> with the specified unit.</returns>
+        public ElectricField<T> ToUnit(ElectricFieldUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricField(convertedValue, unit);
+            return new ElectricField<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricField ToUnit(UnitSystem unitSystem)
+        public ElectricField<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public ElectricField ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricFieldUnit> IQuantity<ElectricFieldUnit>.ToUnit(ElectricFieldUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricFieldUnit, T> IQuantityT<ElectricFieldUnit, T>.ToUnit(ElectricFieldUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricFieldUnit> IQuantity<ElectricFieldUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricFieldUnit, T> IQuantityT<ElectricFieldUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricFieldUnit.VoltPerMeter: return _value;
+                case ElectricFieldUnit.VoltPerMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricField ToBaseUnit()
+        internal ElectricField<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricField(baseUnitValue, BaseUnit);
+            return new ElectricField<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricFieldUnit unit)
+        private T GetValueAs(ElectricFieldUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricField)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricField<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricField)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricField<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricField)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricField<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricField))
+            if(conversionType == typeof(ElectricField<T>))
                 return this;
             else if(conversionType == typeof(ElectricFieldUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricField.QuantityType;
+                return ElectricField<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricField.Info;
+                return ElectricField<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricField.BaseDimensions;
+                return ElectricField<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricField)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricField<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
index 274c01939a..e42770088b 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Inductance
     /// </remarks>
-    public partial struct ElectricInductance : IQuantity<ElectricInductanceUnit>, IEquatable<ElectricInductance>, IComparable, IComparable<ElectricInductance>, IConvertible, IFormattable
+    public partial struct ElectricInductance<T> : IQuantityT<ElectricInductanceUnit, T>, IEquatable<ElectricInductance<T>>, IComparable, IComparable<ElectricInductance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -69,12 +65,12 @@ static ElectricInductance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricInductance(double value, ElectricInductanceUnit unit)
+        public ElectricInductance(T value, ElectricInductanceUnit unit)
         {
             if(unit == ElectricInductanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -86,14 +82,14 @@ public ElectricInductance(double value, ElectricInductanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricInductance(double value, UnitSystem unitSystem)
+        public ElectricInductance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -108,19 +104,19 @@ public ElectricInductance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricInductance, which is Henry. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricInductance{T}" />, which is Henry. All conversions go via this value.
         /// </summary>
         public static ElectricInductanceUnit BaseUnit { get; } = ElectricInductanceUnit.Henry;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricInductance
+        /// Represents the largest possible value of <see cref="ElectricInductance{T}" />
         /// </summary>
-        public static ElectricInductance MaxValue { get; } = new ElectricInductance(double.MaxValue, BaseUnit);
+        public static ElectricInductance<T> MaxValue { get; } = new ElectricInductance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricInductance
+        /// Represents the smallest possible value of <see cref="ElectricInductance{T}" />
         /// </summary>
-        public static ElectricInductance MinValue { get; } = new ElectricInductance(double.MinValue, BaseUnit);
+        public static ElectricInductance<T> MinValue { get; } = new ElectricInductance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -129,14 +125,14 @@ public ElectricInductance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricInductance;
 
         /// <summary>
-        ///     All units of measurement for the ElectricInductance quantity.
+        ///     All units of measurement for the <see cref="ElectricInductance{T}" /> quantity.
         /// </summary>
         public static ElectricInductanceUnit[] Units { get; } = Enum.GetValues(typeof(ElectricInductanceUnit)).Cast<ElectricInductanceUnit>().Except(new ElectricInductanceUnit[]{ ElectricInductanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Henry.
         /// </summary>
-        public static ElectricInductance Zero { get; } = new ElectricInductance(0, BaseUnit);
+        public static ElectricInductance<T> Zero { get; } = new ElectricInductance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -145,7 +141,9 @@ public ElectricInductance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -161,36 +159,36 @@ public ElectricInductance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricInductance.QuantityType;
+        public QuantityType Type => ElectricInductance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricInductance.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricInductance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricInductance in Henries.
+        ///     Get <see cref="ElectricInductance{T}" /> in Henries.
         /// </summary>
-        public double Henries => As(ElectricInductanceUnit.Henry);
+        public T Henries => As(ElectricInductanceUnit.Henry);
 
         /// <summary>
-        ///     Get ElectricInductance in Microhenries.
+        ///     Get <see cref="ElectricInductance{T}" /> in Microhenries.
         /// </summary>
-        public double Microhenries => As(ElectricInductanceUnit.Microhenry);
+        public T Microhenries => As(ElectricInductanceUnit.Microhenry);
 
         /// <summary>
-        ///     Get ElectricInductance in Millihenries.
+        ///     Get <see cref="ElectricInductance{T}" /> in Millihenries.
         /// </summary>
-        public double Millihenries => As(ElectricInductanceUnit.Millihenry);
+        public T Millihenries => As(ElectricInductanceUnit.Millihenry);
 
         /// <summary>
-        ///     Get ElectricInductance in Nanohenries.
+        ///     Get <see cref="ElectricInductance{T}" /> in Nanohenries.
         /// </summary>
-        public double Nanohenries => As(ElectricInductanceUnit.Nanohenry);
+        public T Nanohenries => As(ElectricInductanceUnit.Nanohenry);
 
         #endregion
 
@@ -222,51 +220,47 @@ public static string GetAbbreviation(ElectricInductanceUnit unit, IFormatProvide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricInductance from Henries.
+        ///     Get <see cref="ElectricInductance{T}" /> from Henries.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromHenries(QuantityValue henries)
+        public static ElectricInductance<T> FromHenries(T henries)
         {
-            double value = (double) henries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Henry);
+            return new ElectricInductance<T>(henries, ElectricInductanceUnit.Henry);
         }
         /// <summary>
-        ///     Get ElectricInductance from Microhenries.
+        ///     Get <see cref="ElectricInductance{T}" /> from Microhenries.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromMicrohenries(QuantityValue microhenries)
+        public static ElectricInductance<T> FromMicrohenries(T microhenries)
         {
-            double value = (double) microhenries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Microhenry);
+            return new ElectricInductance<T>(microhenries, ElectricInductanceUnit.Microhenry);
         }
         /// <summary>
-        ///     Get ElectricInductance from Millihenries.
+        ///     Get <see cref="ElectricInductance{T}" /> from Millihenries.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromMillihenries(QuantityValue millihenries)
+        public static ElectricInductance<T> FromMillihenries(T millihenries)
         {
-            double value = (double) millihenries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Millihenry);
+            return new ElectricInductance<T>(millihenries, ElectricInductanceUnit.Millihenry);
         }
         /// <summary>
-        ///     Get ElectricInductance from Nanohenries.
+        ///     Get <see cref="ElectricInductance{T}" /> from Nanohenries.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromNanohenries(QuantityValue nanohenries)
+        public static ElectricInductance<T> FromNanohenries(T nanohenries)
         {
-            double value = (double) nanohenries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry);
+            return new ElectricInductance<T>(nanohenries, ElectricInductanceUnit.Nanohenry);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricInductanceUnit" /> to <see cref="ElectricInductance" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricInductanceUnit" /> to <see cref="ElectricInductance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricInductance unit value.</returns>
-        public static ElectricInductance From(QuantityValue value, ElectricInductanceUnit fromUnit)
+        /// <returns><see cref="ElectricInductance{T}" /> unit value.</returns>
+        public static ElectricInductance<T> From(T value, ElectricInductanceUnit fromUnit)
         {
-            return new ElectricInductance((double)value, fromUnit);
+            return new ElectricInductance<T>(value, fromUnit);
         }
 
         #endregion
@@ -295,7 +289,7 @@ public static ElectricInductance From(QuantityValue value, ElectricInductanceUni
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricInductance Parse(string str)
+        public static ElectricInductance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -323,9 +317,9 @@ public static ElectricInductance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricInductance Parse(string str, IFormatProvider? provider)
+        public static ElectricInductance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricInductance, ElectricInductanceUnit>(
+            return QuantityParser.Default.Parse<T, ElectricInductance<T>, ElectricInductanceUnit>(
                 str,
                 provider,
                 From);
@@ -339,7 +333,7 @@ public static ElectricInductance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricInductance result)
+        public static bool TryParse(string? str, out ElectricInductance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -354,9 +348,9 @@ public static bool TryParse(string? str, out ElectricInductance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricInductance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricInductance<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricInductance, ElectricInductanceUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricInductance<T>, ElectricInductanceUnit>(
                 str,
                 provider,
                 From,
@@ -418,45 +412,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricInductance operator -(ElectricInductance right)
+        public static ElectricInductance<T> operator -(ElectricInductance<T> right)
         {
-            return new ElectricInductance(-right.Value, right.Unit);
+            return new ElectricInductance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricInductance"/> from adding two <see cref="ElectricInductance"/>.</summary>
-        public static ElectricInductance operator +(ElectricInductance left, ElectricInductance right)
+        /// <summary>Get <see cref="ElectricInductance{T}"/> from adding two <see cref="ElectricInductance{T}"/>.</summary>
+        public static ElectricInductance<T> operator +(ElectricInductance<T> left, ElectricInductance<T> right)
         {
-            return new ElectricInductance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricInductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricInductance"/> from subtracting two <see cref="ElectricInductance"/>.</summary>
-        public static ElectricInductance operator -(ElectricInductance left, ElectricInductance right)
+        /// <summary>Get <see cref="ElectricInductance{T}"/> from subtracting two <see cref="ElectricInductance{T}"/>.</summary>
+        public static ElectricInductance<T> operator -(ElectricInductance<T> left, ElectricInductance<T> right)
         {
-            return new ElectricInductance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricInductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricInductance"/> from multiplying value and <see cref="ElectricInductance"/>.</summary>
-        public static ElectricInductance operator *(double left, ElectricInductance right)
+        /// <summary>Get <see cref="ElectricInductance{T}"/> from multiplying value and <see cref="ElectricInductance{T}"/>.</summary>
+        public static ElectricInductance<T> operator *(T left, ElectricInductance<T> right)
         {
-            return new ElectricInductance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricInductance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricInductance"/> from multiplying value and <see cref="ElectricInductance"/>.</summary>
-        public static ElectricInductance operator *(ElectricInductance left, double right)
+        /// <summary>Get <see cref="ElectricInductance{T}"/> from multiplying value and <see cref="ElectricInductance{T}"/>.</summary>
+        public static ElectricInductance<T> operator *(ElectricInductance<T> left, T right)
         {
-            return new ElectricInductance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricInductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricInductance"/> from dividing <see cref="ElectricInductance"/> by value.</summary>
-        public static ElectricInductance operator /(ElectricInductance left, double right)
+        /// <summary>Get <see cref="ElectricInductance{T}"/> from dividing <see cref="ElectricInductance{T}"/> by value.</summary>
+        public static ElectricInductance<T> operator /(ElectricInductance<T> left, T right)
         {
-            return new ElectricInductance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricInductance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricInductance"/> by <see cref="ElectricInductance"/>.</summary>
-        public static double operator /(ElectricInductance left, ElectricInductance right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricInductance{T}"/> by <see cref="ElectricInductance{T}"/>.</summary>
+        public static T operator /(ElectricInductance<T> left, ElectricInductance<T> right)
         {
-            return left.Henries / right.Henries;
+            return CompiledLambdas.Divide(left.Henries, right.Henries);
         }
 
         #endregion
@@ -464,39 +463,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricInductance left, ElectricInductance right)
+        public static bool operator <=(ElectricInductance<T> left, ElectricInductance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricInductance left, ElectricInductance right)
+        public static bool operator >=(ElectricInductance<T> left, ElectricInductance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricInductance left, ElectricInductance right)
+        public static bool operator <(ElectricInductance<T> left, ElectricInductance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricInductance left, ElectricInductance right)
+        public static bool operator >(ElectricInductance<T> left, ElectricInductance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricInductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricInductance left, ElectricInductance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricInductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricInductance<T> left, ElectricInductance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricInductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricInductance left, ElectricInductance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricInductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricInductance<T> left, ElectricInductance<T> right)
         {
             return !(left == right);
         }
@@ -505,37 +504,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricInductance objElectricInductance)) throw new ArgumentException("Expected type ElectricInductance.", nameof(obj));
+            if(!(obj is ElectricInductance<T> objElectricInductance)) throw new ArgumentException("Expected type ElectricInductance.", nameof(obj));
 
             return CompareTo(objElectricInductance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricInductance other)
+        public int CompareTo(ElectricInductance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricInductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricInductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricInductance objElectricInductance))
+            if(obj is null || !(obj is ElectricInductance<T> objElectricInductance))
                 return false;
 
             return Equals(objElectricInductance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricInductance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricInductance other)
+        /// <remarks>Consider using <see cref="Equals(ElectricInductance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricInductance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricInductance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricInductance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -573,21 +572,19 @@ public bool Equals(ElectricInductance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricInductance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricInductance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricInductance.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricInductance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -601,17 +598,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricInductanceUnit unit)
+        public T As(ElectricInductanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -631,17 +628,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricInductanceUnit unitAsElectricInductanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricInductanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricInductanceUnit);
+            var asValue = As(unitAsElectricInductanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricInductanceUnit>.As(ElectricInductanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricInductance to another ElectricInductance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricInductance{T}" /> to another <see cref="ElectricInductance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricInductance with the specified unit.</returns>
-        public ElectricInductance ToUnit(ElectricInductanceUnit unit)
+        /// <returns>A <see cref="ElectricInductance{T}" /> with the specified unit.</returns>
+        public ElectricInductance<T> ToUnit(ElectricInductanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricInductance(convertedValue, unit);
+            return new ElectricInductance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -654,7 +656,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricInductance ToUnit(UnitSystem unitSystem)
+        public ElectricInductance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -674,22 +676,28 @@ public ElectricInductance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricInductanceUnit> IQuantity<ElectricInductanceUnit>.ToUnit(ElectricInductanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricInductanceUnit, T> IQuantityT<ElectricInductanceUnit, T>.ToUnit(ElectricInductanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricInductanceUnit> IQuantity<ElectricInductanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricInductanceUnit, T> IQuantityT<ElectricInductanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             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;
+                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.");
             }
@@ -700,16 +708,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricInductance ToBaseUnit()
+        internal ElectricInductance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricInductance(baseUnitValue, BaseUnit);
+            return new ElectricInductance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricInductanceUnit unit)
+        private T GetValueAs(ElectricInductanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -815,57 +823,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricInductance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricInductance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricInductance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricInductance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricInductance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricInductance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -875,33 +883,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricInductance))
+            if(conversionType == typeof(ElectricInductance<T>))
                 return this;
             else if(conversionType == typeof(ElectricInductanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricInductance.QuantityType;
+                return ElectricInductance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricInductance.Info;
+                return ElectricInductance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricInductance.BaseDimensions;
+                return ElectricInductance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricInductance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricInductance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
index 3e55a9d60a..06c5b038a4 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In classical electromagnetism, the electric potential (a scalar quantity denoted by Φ, ΦE or V and also called the electric field potential or the electrostatic potential) at a point is the amount of electric potential energy that a unitary point charge would have when located at that point.
     /// </summary>
-    public partial struct ElectricPotential : IQuantity<ElectricPotentialUnit>, IEquatable<ElectricPotential>, IComparable, IComparable<ElectricPotential>, IConvertible, IFormattable
+    public partial struct ElectricPotential<T> : IQuantityT<ElectricPotentialUnit, T>, IEquatable<ElectricPotential<T>>, IComparable, IComparable<ElectricPotential<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -67,12 +63,12 @@ static ElectricPotential()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricPotential(double value, ElectricPotentialUnit unit)
+        public ElectricPotential(T value, ElectricPotentialUnit unit)
         {
             if(unit == ElectricPotentialUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -84,14 +80,14 @@ public ElectricPotential(double value, ElectricPotentialUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricPotential(double value, UnitSystem unitSystem)
+        public ElectricPotential(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -106,19 +102,19 @@ public ElectricPotential(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricPotential, which is Volt. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricPotential{T}" />, which is Volt. All conversions go via this value.
         /// </summary>
         public static ElectricPotentialUnit BaseUnit { get; } = ElectricPotentialUnit.Volt;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricPotential
+        /// Represents the largest possible value of <see cref="ElectricPotential{T}" />
         /// </summary>
-        public static ElectricPotential MaxValue { get; } = new ElectricPotential(double.MaxValue, BaseUnit);
+        public static ElectricPotential<T> MaxValue { get; } = new ElectricPotential<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricPotential
+        /// Represents the smallest possible value of <see cref="ElectricPotential{T}" />
         /// </summary>
-        public static ElectricPotential MinValue { get; } = new ElectricPotential(double.MinValue, BaseUnit);
+        public static ElectricPotential<T> MinValue { get; } = new ElectricPotential<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -127,14 +123,14 @@ public ElectricPotential(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricPotential;
 
         /// <summary>
-        ///     All units of measurement for the ElectricPotential quantity.
+        ///     All units of measurement for the <see cref="ElectricPotential{T}" /> quantity.
         /// </summary>
         public static ElectricPotentialUnit[] Units { get; } = Enum.GetValues(typeof(ElectricPotentialUnit)).Cast<ElectricPotentialUnit>().Except(new ElectricPotentialUnit[]{ ElectricPotentialUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Volt.
         /// </summary>
-        public static ElectricPotential Zero { get; } = new ElectricPotential(0, BaseUnit);
+        public static ElectricPotential<T> Zero { get; } = new ElectricPotential<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -143,7 +139,9 @@ public ElectricPotential(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -159,41 +157,41 @@ public ElectricPotential(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricPotential.QuantityType;
+        public QuantityType Type => ElectricPotential<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricPotential.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricPotential<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricPotential in Kilovolts.
+        ///     Get <see cref="ElectricPotential{T}" /> in Kilovolts.
         /// </summary>
-        public double Kilovolts => As(ElectricPotentialUnit.Kilovolt);
+        public T Kilovolts => As(ElectricPotentialUnit.Kilovolt);
 
         /// <summary>
-        ///     Get ElectricPotential in Megavolts.
+        ///     Get <see cref="ElectricPotential{T}" /> in Megavolts.
         /// </summary>
-        public double Megavolts => As(ElectricPotentialUnit.Megavolt);
+        public T Megavolts => As(ElectricPotentialUnit.Megavolt);
 
         /// <summary>
-        ///     Get ElectricPotential in Microvolts.
+        ///     Get <see cref="ElectricPotential{T}" /> in Microvolts.
         /// </summary>
-        public double Microvolts => As(ElectricPotentialUnit.Microvolt);
+        public T Microvolts => As(ElectricPotentialUnit.Microvolt);
 
         /// <summary>
-        ///     Get ElectricPotential in Millivolts.
+        ///     Get <see cref="ElectricPotential{T}" /> in Millivolts.
         /// </summary>
-        public double Millivolts => As(ElectricPotentialUnit.Millivolt);
+        public T Millivolts => As(ElectricPotentialUnit.Millivolt);
 
         /// <summary>
-        ///     Get ElectricPotential in Volts.
+        ///     Get <see cref="ElectricPotential{T}" /> in Volts.
         /// </summary>
-        public double Volts => As(ElectricPotentialUnit.Volt);
+        public T Volts => As(ElectricPotentialUnit.Volt);
 
         #endregion
 
@@ -225,60 +223,55 @@ public static string GetAbbreviation(ElectricPotentialUnit unit, IFormatProvider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricPotential from Kilovolts.
+        ///     Get <see cref="ElectricPotential{T}" /> from Kilovolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromKilovolts(QuantityValue kilovolts)
+        public static ElectricPotential<T> FromKilovolts(T kilovolts)
         {
-            double value = (double) kilovolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt);
+            return new ElectricPotential<T>(kilovolts, ElectricPotentialUnit.Kilovolt);
         }
         /// <summary>
-        ///     Get ElectricPotential from Megavolts.
+        ///     Get <see cref="ElectricPotential{T}" /> from Megavolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMegavolts(QuantityValue megavolts)
+        public static ElectricPotential<T> FromMegavolts(T megavolts)
         {
-            double value = (double) megavolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Megavolt);
+            return new ElectricPotential<T>(megavolts, ElectricPotentialUnit.Megavolt);
         }
         /// <summary>
-        ///     Get ElectricPotential from Microvolts.
+        ///     Get <see cref="ElectricPotential{T}" /> from Microvolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMicrovolts(QuantityValue microvolts)
+        public static ElectricPotential<T> FromMicrovolts(T microvolts)
         {
-            double value = (double) microvolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Microvolt);
+            return new ElectricPotential<T>(microvolts, ElectricPotentialUnit.Microvolt);
         }
         /// <summary>
-        ///     Get ElectricPotential from Millivolts.
+        ///     Get <see cref="ElectricPotential{T}" /> from Millivolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMillivolts(QuantityValue millivolts)
+        public static ElectricPotential<T> FromMillivolts(T millivolts)
         {
-            double value = (double) millivolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Millivolt);
+            return new ElectricPotential<T>(millivolts, ElectricPotentialUnit.Millivolt);
         }
         /// <summary>
-        ///     Get ElectricPotential from Volts.
+        ///     Get <see cref="ElectricPotential{T}" /> from Volts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromVolts(QuantityValue volts)
+        public static ElectricPotential<T> FromVolts(T volts)
         {
-            double value = (double) volts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Volt);
+            return new ElectricPotential<T>(volts, ElectricPotentialUnit.Volt);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialUnit" /> to <see cref="ElectricPotential" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialUnit" /> to <see cref="ElectricPotential{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricPotential unit value.</returns>
-        public static ElectricPotential From(QuantityValue value, ElectricPotentialUnit fromUnit)
+        /// <returns><see cref="ElectricPotential{T}" /> unit value.</returns>
+        public static ElectricPotential<T> From(T value, ElectricPotentialUnit fromUnit)
         {
-            return new ElectricPotential((double)value, fromUnit);
+            return new ElectricPotential<T>(value, fromUnit);
         }
 
         #endregion
@@ -307,7 +300,7 @@ public static ElectricPotential From(QuantityValue value, ElectricPotentialUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricPotential Parse(string str)
+        public static ElectricPotential<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -335,9 +328,9 @@ public static ElectricPotential Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricPotential Parse(string str, IFormatProvider? provider)
+        public static ElectricPotential<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricPotential, ElectricPotentialUnit>(
+            return QuantityParser.Default.Parse<T, ElectricPotential<T>, ElectricPotentialUnit>(
                 str,
                 provider,
                 From);
@@ -351,7 +344,7 @@ public static ElectricPotential Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricPotential result)
+        public static bool TryParse(string? str, out ElectricPotential<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -366,9 +359,9 @@ public static bool TryParse(string? str, out ElectricPotential result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotential result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotential<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricPotential, ElectricPotentialUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricPotential<T>, ElectricPotentialUnit>(
                 str,
                 provider,
                 From,
@@ -430,45 +423,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricPotential operator -(ElectricPotential right)
+        public static ElectricPotential<T> operator -(ElectricPotential<T> right)
         {
-            return new ElectricPotential(-right.Value, right.Unit);
+            return new ElectricPotential<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotential"/> from adding two <see cref="ElectricPotential"/>.</summary>
-        public static ElectricPotential operator +(ElectricPotential left, ElectricPotential right)
+        /// <summary>Get <see cref="ElectricPotential{T}"/> from adding two <see cref="ElectricPotential{T}"/>.</summary>
+        public static ElectricPotential<T> operator +(ElectricPotential<T> left, ElectricPotential<T> right)
         {
-            return new ElectricPotential(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotential<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotential"/> from subtracting two <see cref="ElectricPotential"/>.</summary>
-        public static ElectricPotential operator -(ElectricPotential left, ElectricPotential right)
+        /// <summary>Get <see cref="ElectricPotential{T}"/> from subtracting two <see cref="ElectricPotential{T}"/>.</summary>
+        public static ElectricPotential<T> operator -(ElectricPotential<T> left, ElectricPotential<T> right)
         {
-            return new ElectricPotential(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotential<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotential"/> from multiplying value and <see cref="ElectricPotential"/>.</summary>
-        public static ElectricPotential operator *(double left, ElectricPotential right)
+        /// <summary>Get <see cref="ElectricPotential{T}"/> from multiplying value and <see cref="ElectricPotential{T}"/>.</summary>
+        public static ElectricPotential<T> operator *(T left, ElectricPotential<T> right)
         {
-            return new ElectricPotential(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricPotential<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotential"/> from multiplying value and <see cref="ElectricPotential"/>.</summary>
-        public static ElectricPotential operator *(ElectricPotential left, double right)
+        /// <summary>Get <see cref="ElectricPotential{T}"/> from multiplying value and <see cref="ElectricPotential{T}"/>.</summary>
+        public static ElectricPotential<T> operator *(ElectricPotential<T> left, T right)
         {
-            return new ElectricPotential(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricPotential<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotential"/> from dividing <see cref="ElectricPotential"/> by value.</summary>
-        public static ElectricPotential operator /(ElectricPotential left, double right)
+        /// <summary>Get <see cref="ElectricPotential{T}"/> from dividing <see cref="ElectricPotential{T}"/> by value.</summary>
+        public static ElectricPotential<T> operator /(ElectricPotential<T> left, T right)
         {
-            return new ElectricPotential(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricPotential<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricPotential"/> by <see cref="ElectricPotential"/>.</summary>
-        public static double operator /(ElectricPotential left, ElectricPotential right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricPotential{T}"/> by <see cref="ElectricPotential{T}"/>.</summary>
+        public static T operator /(ElectricPotential<T> left, ElectricPotential<T> right)
         {
-            return left.Volts / right.Volts;
+            return CompiledLambdas.Divide(left.Volts, right.Volts);
         }
 
         #endregion
@@ -476,39 +474,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricPotential left, ElectricPotential right)
+        public static bool operator <=(ElectricPotential<T> left, ElectricPotential<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricPotential left, ElectricPotential right)
+        public static bool operator >=(ElectricPotential<T> left, ElectricPotential<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricPotential left, ElectricPotential right)
+        public static bool operator <(ElectricPotential<T> left, ElectricPotential<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricPotential left, ElectricPotential right)
+        public static bool operator >(ElectricPotential<T> left, ElectricPotential<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotential, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricPotential left, ElectricPotential right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotential{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricPotential<T> left, ElectricPotential<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotential, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricPotential left, ElectricPotential right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotential{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricPotential<T> left, ElectricPotential<T> right)
         {
             return !(left == right);
         }
@@ -517,37 +515,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricPotential objElectricPotential)) throw new ArgumentException("Expected type ElectricPotential.", nameof(obj));
+            if(!(obj is ElectricPotential<T> objElectricPotential)) throw new ArgumentException("Expected type ElectricPotential.", nameof(obj));
 
             return CompareTo(objElectricPotential);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricPotential other)
+        public int CompareTo(ElectricPotential<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotential, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricPotential{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricPotential objElectricPotential))
+            if(obj is null || !(obj is ElectricPotential<T> objElectricPotential))
                 return false;
 
             return Equals(objElectricPotential);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotential, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricPotential other)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotential{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricPotential<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricPotential within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricPotential{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -585,21 +583,19 @@ public bool Equals(ElectricPotential other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricPotential other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricPotential<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricPotential.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricPotential{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -613,17 +609,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricPotentialUnit unit)
+        public T As(ElectricPotentialUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -643,17 +639,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricPotentialUnit unitAsElectricPotentialUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricPotentialUnit);
+            var asValue = As(unitAsElectricPotentialUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricPotentialUnit>.As(ElectricPotentialUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricPotential to another ElectricPotential with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricPotential{T}" /> to another <see cref="ElectricPotential{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricPotential with the specified unit.</returns>
-        public ElectricPotential ToUnit(ElectricPotentialUnit unit)
+        /// <returns>A <see cref="ElectricPotential{T}" /> with the specified unit.</returns>
+        public ElectricPotential<T> ToUnit(ElectricPotentialUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricPotential(convertedValue, unit);
+            return new ElectricPotential<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -666,7 +667,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricPotential ToUnit(UnitSystem unitSystem)
+        public ElectricPotential<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -686,23 +687,29 @@ public ElectricPotential ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialUnit> IQuantity<ElectricPotentialUnit>.ToUnit(ElectricPotentialUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialUnit, T> IQuantityT<ElectricPotentialUnit, T>.ToUnit(ElectricPotentialUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricPotentialUnit> IQuantity<ElectricPotentialUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialUnit, T> IQuantityT<ElectricPotentialUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricPotentialUnit.Kilovolt: return (_value) * 1e3d;
-                case ElectricPotentialUnit.Megavolt: return (_value) * 1e6d;
-                case ElectricPotentialUnit.Microvolt: return (_value) * 1e-6d;
-                case ElectricPotentialUnit.Millivolt: return (_value) * 1e-3d;
-                case ElectricPotentialUnit.Volt: return _value;
+                case ElectricPotentialUnit.Kilovolt: return (Value) * 1e3d;
+                case ElectricPotentialUnit.Megavolt: return (Value) * 1e6d;
+                case ElectricPotentialUnit.Microvolt: return (Value) * 1e-6d;
+                case ElectricPotentialUnit.Millivolt: return (Value) * 1e-3d;
+                case ElectricPotentialUnit.Volt: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -713,16 +720,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricPotential ToBaseUnit()
+        internal ElectricPotential<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricPotential(baseUnitValue, BaseUnit);
+            return new ElectricPotential<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricPotentialUnit unit)
+        private T GetValueAs(ElectricPotentialUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -829,57 +836,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotential)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotential<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotential)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotential<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotential)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotential<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -889,33 +896,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricPotential))
+            if(conversionType == typeof(ElectricPotential<T>))
                 return this;
             else if(conversionType == typeof(ElectricPotentialUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricPotential.QuantityType;
+                return ElectricPotential<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricPotential.Info;
+                return ElectricPotential<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricPotential.BaseDimensions;
+                return ElectricPotential<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricPotential)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricPotential<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
index e01e0f06c9..3414bfe576 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The Electric Potential of a system known to use Alternating Current.
     /// </summary>
-    public partial struct ElectricPotentialAc : IQuantity<ElectricPotentialAcUnit>, IEquatable<ElectricPotentialAc>, IComparable, IComparable<ElectricPotentialAc>, IConvertible, IFormattable
+    public partial struct ElectricPotentialAc<T> : IQuantityT<ElectricPotentialAcUnit, T>, IEquatable<ElectricPotentialAc<T>>, IComparable, IComparable<ElectricPotentialAc<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -67,12 +63,12 @@ static ElectricPotentialAc()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricPotentialAc(double value, ElectricPotentialAcUnit unit)
+        public ElectricPotentialAc(T value, ElectricPotentialAcUnit unit)
         {
             if(unit == ElectricPotentialAcUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -84,14 +80,14 @@ public ElectricPotentialAc(double value, ElectricPotentialAcUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricPotentialAc(double value, UnitSystem unitSystem)
+        public ElectricPotentialAc(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -106,19 +102,19 @@ public ElectricPotentialAc(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricPotentialAc, which is VoltAc. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricPotentialAc{T}" />, which is VoltAc. All conversions go via this value.
         /// </summary>
         public static ElectricPotentialAcUnit BaseUnit { get; } = ElectricPotentialAcUnit.VoltAc;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricPotentialAc
+        /// Represents the largest possible value of <see cref="ElectricPotentialAc{T}" />
         /// </summary>
-        public static ElectricPotentialAc MaxValue { get; } = new ElectricPotentialAc(double.MaxValue, BaseUnit);
+        public static ElectricPotentialAc<T> MaxValue { get; } = new ElectricPotentialAc<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricPotentialAc
+        /// Represents the smallest possible value of <see cref="ElectricPotentialAc{T}" />
         /// </summary>
-        public static ElectricPotentialAc MinValue { get; } = new ElectricPotentialAc(double.MinValue, BaseUnit);
+        public static ElectricPotentialAc<T> MinValue { get; } = new ElectricPotentialAc<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -127,14 +123,14 @@ public ElectricPotentialAc(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricPotentialAc;
 
         /// <summary>
-        ///     All units of measurement for the ElectricPotentialAc quantity.
+        ///     All units of measurement for the <see cref="ElectricPotentialAc{T}" /> quantity.
         /// </summary>
         public static ElectricPotentialAcUnit[] Units { get; } = Enum.GetValues(typeof(ElectricPotentialAcUnit)).Cast<ElectricPotentialAcUnit>().Except(new ElectricPotentialAcUnit[]{ ElectricPotentialAcUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit VoltAc.
         /// </summary>
-        public static ElectricPotentialAc Zero { get; } = new ElectricPotentialAc(0, BaseUnit);
+        public static ElectricPotentialAc<T> Zero { get; } = new ElectricPotentialAc<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -143,7 +139,9 @@ public ElectricPotentialAc(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -159,41 +157,41 @@ public ElectricPotentialAc(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricPotentialAc.QuantityType;
+        public QuantityType Type => ElectricPotentialAc<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricPotentialAc.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricPotentialAc<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricPotentialAc in KilovoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> in KilovoltsAc.
         /// </summary>
-        public double KilovoltsAc => As(ElectricPotentialAcUnit.KilovoltAc);
+        public T KilovoltsAc => As(ElectricPotentialAcUnit.KilovoltAc);
 
         /// <summary>
-        ///     Get ElectricPotentialAc in MegavoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> in MegavoltsAc.
         /// </summary>
-        public double MegavoltsAc => As(ElectricPotentialAcUnit.MegavoltAc);
+        public T MegavoltsAc => As(ElectricPotentialAcUnit.MegavoltAc);
 
         /// <summary>
-        ///     Get ElectricPotentialAc in MicrovoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> in MicrovoltsAc.
         /// </summary>
-        public double MicrovoltsAc => As(ElectricPotentialAcUnit.MicrovoltAc);
+        public T MicrovoltsAc => As(ElectricPotentialAcUnit.MicrovoltAc);
 
         /// <summary>
-        ///     Get ElectricPotentialAc in MillivoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> in MillivoltsAc.
         /// </summary>
-        public double MillivoltsAc => As(ElectricPotentialAcUnit.MillivoltAc);
+        public T MillivoltsAc => As(ElectricPotentialAcUnit.MillivoltAc);
 
         /// <summary>
-        ///     Get ElectricPotentialAc in VoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> in VoltsAc.
         /// </summary>
-        public double VoltsAc => As(ElectricPotentialAcUnit.VoltAc);
+        public T VoltsAc => As(ElectricPotentialAcUnit.VoltAc);
 
         #endregion
 
@@ -225,60 +223,55 @@ public static string GetAbbreviation(ElectricPotentialAcUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricPotentialAc from KilovoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> from KilovoltsAc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromKilovoltsAc(QuantityValue kilovoltsac)
+        public static ElectricPotentialAc<T> FromKilovoltsAc(T kilovoltsac)
         {
-            double value = (double) kilovoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.KilovoltAc);
+            return new ElectricPotentialAc<T>(kilovoltsac, ElectricPotentialAcUnit.KilovoltAc);
         }
         /// <summary>
-        ///     Get ElectricPotentialAc from MegavoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> from MegavoltsAc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMegavoltsAc(QuantityValue megavoltsac)
+        public static ElectricPotentialAc<T> FromMegavoltsAc(T megavoltsac)
         {
-            double value = (double) megavoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MegavoltAc);
+            return new ElectricPotentialAc<T>(megavoltsac, ElectricPotentialAcUnit.MegavoltAc);
         }
         /// <summary>
-        ///     Get ElectricPotentialAc from MicrovoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> from MicrovoltsAc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMicrovoltsAc(QuantityValue microvoltsac)
+        public static ElectricPotentialAc<T> FromMicrovoltsAc(T microvoltsac)
         {
-            double value = (double) microvoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MicrovoltAc);
+            return new ElectricPotentialAc<T>(microvoltsac, ElectricPotentialAcUnit.MicrovoltAc);
         }
         /// <summary>
-        ///     Get ElectricPotentialAc from MillivoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> from MillivoltsAc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMillivoltsAc(QuantityValue millivoltsac)
+        public static ElectricPotentialAc<T> FromMillivoltsAc(T millivoltsac)
         {
-            double value = (double) millivoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MillivoltAc);
+            return new ElectricPotentialAc<T>(millivoltsac, ElectricPotentialAcUnit.MillivoltAc);
         }
         /// <summary>
-        ///     Get ElectricPotentialAc from VoltsAc.
+        ///     Get <see cref="ElectricPotentialAc{T}" /> from VoltsAc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromVoltsAc(QuantityValue voltsac)
+        public static ElectricPotentialAc<T> FromVoltsAc(T voltsac)
         {
-            double value = (double) voltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.VoltAc);
+            return new ElectricPotentialAc<T>(voltsac, ElectricPotentialAcUnit.VoltAc);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialAcUnit" /> to <see cref="ElectricPotentialAc" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialAcUnit" /> to <see cref="ElectricPotentialAc{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricPotentialAc unit value.</returns>
-        public static ElectricPotentialAc From(QuantityValue value, ElectricPotentialAcUnit fromUnit)
+        /// <returns><see cref="ElectricPotentialAc{T}" /> unit value.</returns>
+        public static ElectricPotentialAc<T> From(T value, ElectricPotentialAcUnit fromUnit)
         {
-            return new ElectricPotentialAc((double)value, fromUnit);
+            return new ElectricPotentialAc<T>(value, fromUnit);
         }
 
         #endregion
@@ -307,7 +300,7 @@ public static ElectricPotentialAc From(QuantityValue value, ElectricPotentialAcU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricPotentialAc Parse(string str)
+        public static ElectricPotentialAc<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -335,9 +328,9 @@ public static ElectricPotentialAc Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricPotentialAc Parse(string str, IFormatProvider? provider)
+        public static ElectricPotentialAc<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricPotentialAc, ElectricPotentialAcUnit>(
+            return QuantityParser.Default.Parse<T, ElectricPotentialAc<T>, ElectricPotentialAcUnit>(
                 str,
                 provider,
                 From);
@@ -351,7 +344,7 @@ public static ElectricPotentialAc Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricPotentialAc result)
+        public static bool TryParse(string? str, out ElectricPotentialAc<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -366,9 +359,9 @@ public static bool TryParse(string? str, out ElectricPotentialAc result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotentialAc result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotentialAc<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricPotentialAc, ElectricPotentialAcUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricPotentialAc<T>, ElectricPotentialAcUnit>(
                 str,
                 provider,
                 From,
@@ -430,45 +423,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricPotentialAc operator -(ElectricPotentialAc right)
+        public static ElectricPotentialAc<T> operator -(ElectricPotentialAc<T> right)
         {
-            return new ElectricPotentialAc(-right.Value, right.Unit);
+            return new ElectricPotentialAc<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialAc"/> from adding two <see cref="ElectricPotentialAc"/>.</summary>
-        public static ElectricPotentialAc operator +(ElectricPotentialAc left, ElectricPotentialAc right)
+        /// <summary>Get <see cref="ElectricPotentialAc{T}"/> from adding two <see cref="ElectricPotentialAc{T}"/>.</summary>
+        public static ElectricPotentialAc<T> operator +(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
-            return new ElectricPotentialAc(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotentialAc<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialAc"/> from subtracting two <see cref="ElectricPotentialAc"/>.</summary>
-        public static ElectricPotentialAc operator -(ElectricPotentialAc left, ElectricPotentialAc right)
+        /// <summary>Get <see cref="ElectricPotentialAc{T}"/> from subtracting two <see cref="ElectricPotentialAc{T}"/>.</summary>
+        public static ElectricPotentialAc<T> operator -(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
-            return new ElectricPotentialAc(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotentialAc<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialAc"/> from multiplying value and <see cref="ElectricPotentialAc"/>.</summary>
-        public static ElectricPotentialAc operator *(double left, ElectricPotentialAc right)
+        /// <summary>Get <see cref="ElectricPotentialAc{T}"/> from multiplying value and <see cref="ElectricPotentialAc{T}"/>.</summary>
+        public static ElectricPotentialAc<T> operator *(T left, ElectricPotentialAc<T> right)
         {
-            return new ElectricPotentialAc(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricPotentialAc<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialAc"/> from multiplying value and <see cref="ElectricPotentialAc"/>.</summary>
-        public static ElectricPotentialAc operator *(ElectricPotentialAc left, double right)
+        /// <summary>Get <see cref="ElectricPotentialAc{T}"/> from multiplying value and <see cref="ElectricPotentialAc{T}"/>.</summary>
+        public static ElectricPotentialAc<T> operator *(ElectricPotentialAc<T> left, T right)
         {
-            return new ElectricPotentialAc(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricPotentialAc<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialAc"/> from dividing <see cref="ElectricPotentialAc"/> by value.</summary>
-        public static ElectricPotentialAc operator /(ElectricPotentialAc left, double right)
+        /// <summary>Get <see cref="ElectricPotentialAc{T}"/> from dividing <see cref="ElectricPotentialAc{T}"/> by value.</summary>
+        public static ElectricPotentialAc<T> operator /(ElectricPotentialAc<T> left, T right)
         {
-            return new ElectricPotentialAc(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricPotentialAc<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricPotentialAc"/> by <see cref="ElectricPotentialAc"/>.</summary>
-        public static double operator /(ElectricPotentialAc left, ElectricPotentialAc right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricPotentialAc{T}"/> by <see cref="ElectricPotentialAc{T}"/>.</summary>
+        public static T operator /(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
-            return left.VoltsAc / right.VoltsAc;
+            return CompiledLambdas.Divide(left.VoltsAc, right.VoltsAc);
         }
 
         #endregion
@@ -476,39 +474,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricPotentialAc left, ElectricPotentialAc right)
+        public static bool operator <=(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricPotentialAc left, ElectricPotentialAc right)
+        public static bool operator >=(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricPotentialAc left, ElectricPotentialAc right)
+        public static bool operator <(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricPotentialAc left, ElectricPotentialAc right)
+        public static bool operator >(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricPotentialAc left, ElectricPotentialAc right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricPotentialAc left, ElectricPotentialAc right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricPotentialAc<T> left, ElectricPotentialAc<T> right)
         {
             return !(left == right);
         }
@@ -517,37 +515,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricPotentialAc objElectricPotentialAc)) throw new ArgumentException("Expected type ElectricPotentialAc.", nameof(obj));
+            if(!(obj is ElectricPotentialAc<T> objElectricPotentialAc)) throw new ArgumentException("Expected type ElectricPotentialAc.", nameof(obj));
 
             return CompareTo(objElectricPotentialAc);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricPotentialAc other)
+        public int CompareTo(ElectricPotentialAc<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricPotentialAc objElectricPotentialAc))
+            if(obj is null || !(obj is ElectricPotentialAc<T> objElectricPotentialAc))
                 return false;
 
             return Equals(objElectricPotentialAc);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricPotentialAc other)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialAc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricPotentialAc<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricPotentialAc within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricPotentialAc{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -585,21 +583,19 @@ public bool Equals(ElectricPotentialAc other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricPotentialAc other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricPotentialAc<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricPotentialAc.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricPotentialAc{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -613,17 +609,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricPotentialAcUnit unit)
+        public T As(ElectricPotentialAcUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -643,17 +639,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricPotentialAcUnit unitAsElectricPotentialAcUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialAcUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricPotentialAcUnit);
+            var asValue = As(unitAsElectricPotentialAcUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricPotentialAcUnit>.As(ElectricPotentialAcUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricPotentialAc to another ElectricPotentialAc with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricPotentialAc{T}" /> to another <see cref="ElectricPotentialAc{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricPotentialAc with the specified unit.</returns>
-        public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit)
+        /// <returns>A <see cref="ElectricPotentialAc{T}" /> with the specified unit.</returns>
+        public ElectricPotentialAc<T> ToUnit(ElectricPotentialAcUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricPotentialAc(convertedValue, unit);
+            return new ElectricPotentialAc<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -666,7 +667,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricPotentialAc ToUnit(UnitSystem unitSystem)
+        public ElectricPotentialAc<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -686,23 +687,29 @@ public ElectricPotentialAc ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialAcUnit> IQuantity<ElectricPotentialAcUnit>.ToUnit(ElectricPotentialAcUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialAcUnit, T> IQuantityT<ElectricPotentialAcUnit, T>.ToUnit(ElectricPotentialAcUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricPotentialAcUnit> IQuantity<ElectricPotentialAcUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialAcUnit, T> IQuantityT<ElectricPotentialAcUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricPotentialAcUnit.KilovoltAc: return (_value) * 1e3d;
-                case ElectricPotentialAcUnit.MegavoltAc: return (_value) * 1e6d;
-                case ElectricPotentialAcUnit.MicrovoltAc: return (_value) * 1e-6d;
-                case ElectricPotentialAcUnit.MillivoltAc: return (_value) * 1e-3d;
-                case ElectricPotentialAcUnit.VoltAc: return _value;
+                case ElectricPotentialAcUnit.KilovoltAc: return (Value) * 1e3d;
+                case ElectricPotentialAcUnit.MegavoltAc: return (Value) * 1e6d;
+                case ElectricPotentialAcUnit.MicrovoltAc: return (Value) * 1e-6d;
+                case ElectricPotentialAcUnit.MillivoltAc: return (Value) * 1e-3d;
+                case ElectricPotentialAcUnit.VoltAc: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -713,16 +720,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricPotentialAc ToBaseUnit()
+        internal ElectricPotentialAc<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricPotentialAc(baseUnitValue, BaseUnit);
+            return new ElectricPotentialAc<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricPotentialAcUnit unit)
+        private T GetValueAs(ElectricPotentialAcUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -829,57 +836,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -889,33 +896,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricPotentialAc))
+            if(conversionType == typeof(ElectricPotentialAc<T>))
                 return this;
             else if(conversionType == typeof(ElectricPotentialAcUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricPotentialAc.QuantityType;
+                return ElectricPotentialAc<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricPotentialAc.Info;
+                return ElectricPotentialAc<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricPotentialAc.BaseDimensions;
+                return ElectricPotentialAc<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricPotentialAc<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
index d69a040bf5..ceb840eee1 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     ElectricPotential change rate is the ratio of the electric potential change to the time during which the change occurred (value of electric potential changes per unit time).
     /// </summary>
-    public partial struct ElectricPotentialChangeRate : IQuantity<ElectricPotentialChangeRateUnit>, IEquatable<ElectricPotentialChangeRate>, IComparable, IComparable<ElectricPotentialChangeRate>, IConvertible, IFormattable
+    public partial struct ElectricPotentialChangeRate<T> : IQuantityT<ElectricPotentialChangeRateUnit, T>, IEquatable<ElectricPotentialChangeRate<T>>, IComparable, IComparable<ElectricPotentialChangeRate<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -82,12 +78,12 @@ static ElectricPotentialChangeRate()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricPotentialChangeRate(double value, ElectricPotentialChangeRateUnit unit)
+        public ElectricPotentialChangeRate(T value, ElectricPotentialChangeRateUnit unit)
         {
             if(unit == ElectricPotentialChangeRateUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -99,14 +95,14 @@ public ElectricPotentialChangeRate(double value, ElectricPotentialChangeRateUnit
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
+        public ElectricPotentialChangeRate(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -121,19 +117,19 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricPotentialChangeRate, which is VoltPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricPotentialChangeRate{T}" />, which is VoltPerSecond. All conversions go via this value.
         /// </summary>
         public static ElectricPotentialChangeRateUnit BaseUnit { get; } = ElectricPotentialChangeRateUnit.VoltPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricPotentialChangeRate
+        /// Represents the largest possible value of <see cref="ElectricPotentialChangeRate{T}" />
         /// </summary>
-        public static ElectricPotentialChangeRate MaxValue { get; } = new ElectricPotentialChangeRate(double.MaxValue, BaseUnit);
+        public static ElectricPotentialChangeRate<T> MaxValue { get; } = new ElectricPotentialChangeRate<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricPotentialChangeRate
+        /// Represents the smallest possible value of <see cref="ElectricPotentialChangeRate{T}" />
         /// </summary>
-        public static ElectricPotentialChangeRate MinValue { get; } = new ElectricPotentialChangeRate(double.MinValue, BaseUnit);
+        public static ElectricPotentialChangeRate<T> MinValue { get; } = new ElectricPotentialChangeRate<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -142,14 +138,14 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricPotentialChangeRate;
 
         /// <summary>
-        ///     All units of measurement for the ElectricPotentialChangeRate quantity.
+        ///     All units of measurement for the <see cref="ElectricPotentialChangeRate{T}" /> quantity.
         /// </summary>
         public static ElectricPotentialChangeRateUnit[] Units { get; } = Enum.GetValues(typeof(ElectricPotentialChangeRateUnit)).Cast<ElectricPotentialChangeRateUnit>().Except(new ElectricPotentialChangeRateUnit[]{ ElectricPotentialChangeRateUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit VoltPerSecond.
         /// </summary>
-        public static ElectricPotentialChangeRate Zero { get; } = new ElectricPotentialChangeRate(0, BaseUnit);
+        public static ElectricPotentialChangeRate<T> Zero { get; } = new ElectricPotentialChangeRate<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -158,7 +154,9 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -174,116 +172,116 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricPotentialChangeRate.QuantityType;
+        public QuantityType Type => ElectricPotentialChangeRate<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricPotentialChangeRate.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricPotentialChangeRate<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in KilovoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in KilovoltsPerHours.
         /// </summary>
-        public double KilovoltsPerHours => As(ElectricPotentialChangeRateUnit.KilovoltPerHour);
+        public T KilovoltsPerHours => As(ElectricPotentialChangeRateUnit.KilovoltPerHour);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in KilovoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in KilovoltsPerMicroseconds.
         /// </summary>
-        public double KilovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
+        public T KilovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in KilovoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in KilovoltsPerMinutes.
         /// </summary>
-        public double KilovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute);
+        public T KilovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in KilovoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in KilovoltsPerSeconds.
         /// </summary>
-        public double KilovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond);
+        public T KilovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MegavoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MegavoltsPerHours.
         /// </summary>
-        public double MegavoltsPerHours => As(ElectricPotentialChangeRateUnit.MegavoltPerHour);
+        public T MegavoltsPerHours => As(ElectricPotentialChangeRateUnit.MegavoltPerHour);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MegavoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MegavoltsPerMicroseconds.
         /// </summary>
-        public double MegavoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
+        public T MegavoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MegavoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MegavoltsPerMinutes.
         /// </summary>
-        public double MegavoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute);
+        public T MegavoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MegavoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MegavoltsPerSeconds.
         /// </summary>
-        public double MegavoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond);
+        public T MegavoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MicrovoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MicrovoltsPerHours.
         /// </summary>
-        public double MicrovoltsPerHours => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour);
+        public T MicrovoltsPerHours => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MicrovoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MicrovoltsPerMicroseconds.
         /// </summary>
-        public double MicrovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
+        public T MicrovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MicrovoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MicrovoltsPerMinutes.
         /// </summary>
-        public double MicrovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
+        public T MicrovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MicrovoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MicrovoltsPerSeconds.
         /// </summary>
-        public double MicrovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
+        public T MicrovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MillivoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MillivoltsPerHours.
         /// </summary>
-        public double MillivoltsPerHours => As(ElectricPotentialChangeRateUnit.MillivoltPerHour);
+        public T MillivoltsPerHours => As(ElectricPotentialChangeRateUnit.MillivoltPerHour);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MillivoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MillivoltsPerMicroseconds.
         /// </summary>
-        public double MillivoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
+        public T MillivoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MillivoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MillivoltsPerMinutes.
         /// </summary>
-        public double MillivoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute);
+        public T MillivoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in MillivoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in MillivoltsPerSeconds.
         /// </summary>
-        public double MillivoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond);
+        public T MillivoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in VoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in VoltsPerHours.
         /// </summary>
-        public double VoltsPerHours => As(ElectricPotentialChangeRateUnit.VoltPerHour);
+        public T VoltsPerHours => As(ElectricPotentialChangeRateUnit.VoltPerHour);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in VoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in VoltsPerMicroseconds.
         /// </summary>
-        public double VoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
+        public T VoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in VoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in VoltsPerMinutes.
         /// </summary>
-        public double VoltsPerMinutes => As(ElectricPotentialChangeRateUnit.VoltPerMinute);
+        public T VoltsPerMinutes => As(ElectricPotentialChangeRateUnit.VoltPerMinute);
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate in VoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> in VoltsPerSeconds.
         /// </summary>
-        public double VoltsPerSeconds => As(ElectricPotentialChangeRateUnit.VoltPerSecond);
+        public T VoltsPerSeconds => As(ElectricPotentialChangeRateUnit.VoltPerSecond);
 
         #endregion
 
@@ -315,195 +313,175 @@ public static string GetAbbreviation(ElectricPotentialChangeRateUnit unit, IForm
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from KilovoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from KilovoltsPerHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerHours(QuantityValue kilovoltsperhours)
+        public static ElectricPotentialChangeRate<T> FromKilovoltsPerHours(T kilovoltsperhours)
         {
-            double value = (double) kilovoltsperhours;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour);
+            return new ElectricPotentialChangeRate<T>(kilovoltsperhours, ElectricPotentialChangeRateUnit.KilovoltPerHour);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from KilovoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from KilovoltsPerMicroseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(QuantityValue kilovoltspermicroseconds)
+        public static ElectricPotentialChangeRate<T> FromKilovoltsPerMicroseconds(T kilovoltspermicroseconds)
         {
-            double value = (double) kilovoltspermicroseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
+            return new ElectricPotentialChangeRate<T>(kilovoltspermicroseconds, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from KilovoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from KilovoltsPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(QuantityValue kilovoltsperminutes)
+        public static ElectricPotentialChangeRate<T> FromKilovoltsPerMinutes(T kilovoltsperminutes)
         {
-            double value = (double) kilovoltsperminutes;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
+            return new ElectricPotentialChangeRate<T>(kilovoltsperminutes, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from KilovoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from KilovoltsPerSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(QuantityValue kilovoltsperseconds)
+        public static ElectricPotentialChangeRate<T> FromKilovoltsPerSeconds(T kilovoltsperseconds)
         {
-            double value = (double) kilovoltsperseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
+            return new ElectricPotentialChangeRate<T>(kilovoltsperseconds, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MegavoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MegavoltsPerHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerHours(QuantityValue megavoltsperhours)
+        public static ElectricPotentialChangeRate<T> FromMegavoltsPerHours(T megavoltsperhours)
         {
-            double value = (double) megavoltsperhours;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour);
+            return new ElectricPotentialChangeRate<T>(megavoltsperhours, ElectricPotentialChangeRateUnit.MegavoltPerHour);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MegavoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MegavoltsPerMicroseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(QuantityValue megavoltspermicroseconds)
+        public static ElectricPotentialChangeRate<T> FromMegavoltsPerMicroseconds(T megavoltspermicroseconds)
         {
-            double value = (double) megavoltspermicroseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
+            return new ElectricPotentialChangeRate<T>(megavoltspermicroseconds, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MegavoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MegavoltsPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(QuantityValue megavoltsperminutes)
+        public static ElectricPotentialChangeRate<T> FromMegavoltsPerMinutes(T megavoltsperminutes)
         {
-            double value = (double) megavoltsperminutes;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
+            return new ElectricPotentialChangeRate<T>(megavoltsperminutes, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MegavoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MegavoltsPerSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(QuantityValue megavoltsperseconds)
+        public static ElectricPotentialChangeRate<T> FromMegavoltsPerSeconds(T megavoltsperseconds)
         {
-            double value = (double) megavoltsperseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
+            return new ElectricPotentialChangeRate<T>(megavoltsperseconds, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MicrovoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MicrovoltsPerHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerHours(QuantityValue microvoltsperhours)
+        public static ElectricPotentialChangeRate<T> FromMicrovoltsPerHours(T microvoltsperhours)
         {
-            double value = (double) microvoltsperhours;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
+            return new ElectricPotentialChangeRate<T>(microvoltsperhours, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MicrovoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MicrovoltsPerMicroseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(QuantityValue microvoltspermicroseconds)
+        public static ElectricPotentialChangeRate<T> FromMicrovoltsPerMicroseconds(T microvoltspermicroseconds)
         {
-            double value = (double) microvoltspermicroseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
+            return new ElectricPotentialChangeRate<T>(microvoltspermicroseconds, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MicrovoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MicrovoltsPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(QuantityValue microvoltsperminutes)
+        public static ElectricPotentialChangeRate<T> FromMicrovoltsPerMinutes(T microvoltsperminutes)
         {
-            double value = (double) microvoltsperminutes;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
+            return new ElectricPotentialChangeRate<T>(microvoltsperminutes, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MicrovoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MicrovoltsPerSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(QuantityValue microvoltsperseconds)
+        public static ElectricPotentialChangeRate<T> FromMicrovoltsPerSeconds(T microvoltsperseconds)
         {
-            double value = (double) microvoltsperseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
+            return new ElectricPotentialChangeRate<T>(microvoltsperseconds, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MillivoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MillivoltsPerHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerHours(QuantityValue millivoltsperhours)
+        public static ElectricPotentialChangeRate<T> FromMillivoltsPerHours(T millivoltsperhours)
         {
-            double value = (double) millivoltsperhours;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour);
+            return new ElectricPotentialChangeRate<T>(millivoltsperhours, ElectricPotentialChangeRateUnit.MillivoltPerHour);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MillivoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MillivoltsPerMicroseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(QuantityValue millivoltspermicroseconds)
+        public static ElectricPotentialChangeRate<T> FromMillivoltsPerMicroseconds(T millivoltspermicroseconds)
         {
-            double value = (double) millivoltspermicroseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
+            return new ElectricPotentialChangeRate<T>(millivoltspermicroseconds, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MillivoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MillivoltsPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(QuantityValue millivoltsperminutes)
+        public static ElectricPotentialChangeRate<T> FromMillivoltsPerMinutes(T millivoltsperminutes)
         {
-            double value = (double) millivoltsperminutes;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
+            return new ElectricPotentialChangeRate<T>(millivoltsperminutes, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from MillivoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from MillivoltsPerSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(QuantityValue millivoltsperseconds)
+        public static ElectricPotentialChangeRate<T> FromMillivoltsPerSeconds(T millivoltsperseconds)
         {
-            double value = (double) millivoltsperseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
+            return new ElectricPotentialChangeRate<T>(millivoltsperseconds, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from VoltsPerHours.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from VoltsPerHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerHours(QuantityValue voltsperhours)
+        public static ElectricPotentialChangeRate<T> FromVoltsPerHours(T voltsperhours)
         {
-            double value = (double) voltsperhours;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour);
+            return new ElectricPotentialChangeRate<T>(voltsperhours, ElectricPotentialChangeRateUnit.VoltPerHour);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from VoltsPerMicroseconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from VoltsPerMicroseconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(QuantityValue voltspermicroseconds)
+        public static ElectricPotentialChangeRate<T> FromVoltsPerMicroseconds(T voltspermicroseconds)
         {
-            double value = (double) voltspermicroseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
+            return new ElectricPotentialChangeRate<T>(voltspermicroseconds, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from VoltsPerMinutes.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from VoltsPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerMinutes(QuantityValue voltsperminutes)
+        public static ElectricPotentialChangeRate<T> FromVoltsPerMinutes(T voltsperminutes)
         {
-            double value = (double) voltsperminutes;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute);
+            return new ElectricPotentialChangeRate<T>(voltsperminutes, ElectricPotentialChangeRateUnit.VoltPerMinute);
         }
         /// <summary>
-        ///     Get ElectricPotentialChangeRate from VoltsPerSeconds.
+        ///     Get <see cref="ElectricPotentialChangeRate{T}" /> from VoltsPerSeconds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerSeconds(QuantityValue voltsperseconds)
+        public static ElectricPotentialChangeRate<T> FromVoltsPerSeconds(T voltsperseconds)
         {
-            double value = (double) voltsperseconds;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond);
+            return new ElectricPotentialChangeRate<T>(voltsperseconds, ElectricPotentialChangeRateUnit.VoltPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialChangeRateUnit" /> to <see cref="ElectricPotentialChangeRate" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialChangeRateUnit" /> to <see cref="ElectricPotentialChangeRate{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricPotentialChangeRate unit value.</returns>
-        public static ElectricPotentialChangeRate From(QuantityValue value, ElectricPotentialChangeRateUnit fromUnit)
+        /// <returns><see cref="ElectricPotentialChangeRate{T}" /> unit value.</returns>
+        public static ElectricPotentialChangeRate<T> From(T value, ElectricPotentialChangeRateUnit fromUnit)
         {
-            return new ElectricPotentialChangeRate((double)value, fromUnit);
+            return new ElectricPotentialChangeRate<T>(value, fromUnit);
         }
 
         #endregion
@@ -532,7 +510,7 @@ public static ElectricPotentialChangeRate From(QuantityValue value, ElectricPote
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricPotentialChangeRate Parse(string str)
+        public static ElectricPotentialChangeRate<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -560,9 +538,9 @@ public static ElectricPotentialChangeRate Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricPotentialChangeRate Parse(string str, IFormatProvider? provider)
+        public static ElectricPotentialChangeRate<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>(
+            return QuantityParser.Default.Parse<T, ElectricPotentialChangeRate<T>, ElectricPotentialChangeRateUnit>(
                 str,
                 provider,
                 From);
@@ -576,7 +554,7 @@ public static ElectricPotentialChangeRate Parse(string str, IFormatProvider? pro
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricPotentialChangeRate result)
+        public static bool TryParse(string? str, out ElectricPotentialChangeRate<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -591,9 +569,9 @@ public static bool TryParse(string? str, out ElectricPotentialChangeRate result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotentialChangeRate result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotentialChangeRate<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricPotentialChangeRate<T>, ElectricPotentialChangeRateUnit>(
                 str,
                 provider,
                 From,
@@ -655,45 +633,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricPotentialChangeRate operator -(ElectricPotentialChangeRate right)
+        public static ElectricPotentialChangeRate<T> operator -(ElectricPotentialChangeRate<T> right)
         {
-            return new ElectricPotentialChangeRate(-right.Value, right.Unit);
+            return new ElectricPotentialChangeRate<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from adding two <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static ElectricPotentialChangeRate operator +(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        /// <summary>Get <see cref="ElectricPotentialChangeRate{T}"/> from adding two <see cref="ElectricPotentialChangeRate{T}"/>.</summary>
+        public static ElectricPotentialChangeRate<T> operator +(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
-            return new ElectricPotentialChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotentialChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from subtracting two <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static ElectricPotentialChangeRate operator -(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        /// <summary>Get <see cref="ElectricPotentialChangeRate{T}"/> from subtracting two <see cref="ElectricPotentialChangeRate{T}"/>.</summary>
+        public static ElectricPotentialChangeRate<T> operator -(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
-            return new ElectricPotentialChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotentialChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from multiplying value and <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static ElectricPotentialChangeRate operator *(double left, ElectricPotentialChangeRate right)
+        /// <summary>Get <see cref="ElectricPotentialChangeRate{T}"/> from multiplying value and <see cref="ElectricPotentialChangeRate{T}"/>.</summary>
+        public static ElectricPotentialChangeRate<T> operator *(T left, ElectricPotentialChangeRate<T> right)
         {
-            return new ElectricPotentialChangeRate(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricPotentialChangeRate<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from multiplying value and <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static ElectricPotentialChangeRate operator *(ElectricPotentialChangeRate left, double right)
+        /// <summary>Get <see cref="ElectricPotentialChangeRate{T}"/> from multiplying value and <see cref="ElectricPotentialChangeRate{T}"/>.</summary>
+        public static ElectricPotentialChangeRate<T> operator *(ElectricPotentialChangeRate<T> left, T right)
         {
-            return new ElectricPotentialChangeRate(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricPotentialChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from dividing <see cref="ElectricPotentialChangeRate"/> by value.</summary>
-        public static ElectricPotentialChangeRate operator /(ElectricPotentialChangeRate left, double right)
+        /// <summary>Get <see cref="ElectricPotentialChangeRate{T}"/> from dividing <see cref="ElectricPotentialChangeRate{T}"/> by value.</summary>
+        public static ElectricPotentialChangeRate<T> operator /(ElectricPotentialChangeRate<T> left, T right)
         {
-            return new ElectricPotentialChangeRate(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricPotentialChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricPotentialChangeRate"/> by <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static double operator /(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricPotentialChangeRate{T}"/> by <see cref="ElectricPotentialChangeRate{T}"/>.</summary>
+        public static T operator /(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
-            return left.VoltsPerSeconds / right.VoltsPerSeconds;
+            return CompiledLambdas.Divide(left.VoltsPerSeconds, right.VoltsPerSeconds);
         }
 
         #endregion
@@ -701,39 +684,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        public static bool operator <=(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        public static bool operator >=(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        public static bool operator <(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        public static bool operator >(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricPotentialChangeRate<T> left, ElectricPotentialChangeRate<T> right)
         {
             return !(left == right);
         }
@@ -742,37 +725,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricPotentialChangeRate objElectricPotentialChangeRate)) throw new ArgumentException("Expected type ElectricPotentialChangeRate.", nameof(obj));
+            if(!(obj is ElectricPotentialChangeRate<T> objElectricPotentialChangeRate)) throw new ArgumentException("Expected type ElectricPotentialChangeRate.", nameof(obj));
 
             return CompareTo(objElectricPotentialChangeRate);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricPotentialChangeRate other)
+        public int CompareTo(ElectricPotentialChangeRate<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricPotentialChangeRate objElectricPotentialChangeRate))
+            if(obj is null || !(obj is ElectricPotentialChangeRate<T> objElectricPotentialChangeRate))
                 return false;
 
             return Equals(objElectricPotentialChangeRate);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricPotentialChangeRate other)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricPotentialChangeRate<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricPotentialChangeRate within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricPotentialChangeRate{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -810,21 +793,19 @@ public bool Equals(ElectricPotentialChangeRate other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricPotentialChangeRate other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricPotentialChangeRate<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricPotentialChangeRate.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricPotentialChangeRate{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -838,17 +819,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricPotentialChangeRateUnit unit)
+        public T As(ElectricPotentialChangeRateUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -868,17 +849,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricPotentialChangeRateUnit unitAsElectricPotentialChangeRateUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialChangeRateUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricPotentialChangeRateUnit);
+            var asValue = As(unitAsElectricPotentialChangeRateUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricPotentialChangeRateUnit>.As(ElectricPotentialChangeRateUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricPotentialChangeRate to another ElectricPotentialChangeRate with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricPotentialChangeRate{T}" /> to another <see cref="ElectricPotentialChangeRate{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricPotentialChangeRate with the specified unit.</returns>
-        public ElectricPotentialChangeRate ToUnit(ElectricPotentialChangeRateUnit unit)
+        /// <returns>A <see cref="ElectricPotentialChangeRate{T}" /> with the specified unit.</returns>
+        public ElectricPotentialChangeRate<T> ToUnit(ElectricPotentialChangeRateUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricPotentialChangeRate(convertedValue, unit);
+            return new ElectricPotentialChangeRate<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -891,7 +877,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricPotentialChangeRate ToUnit(UnitSystem unitSystem)
+        public ElectricPotentialChangeRate<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -911,38 +897,44 @@ public ElectricPotentialChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialChangeRateUnit> IQuantity<ElectricPotentialChangeRateUnit>.ToUnit(ElectricPotentialChangeRateUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialChangeRateUnit, T> IQuantityT<ElectricPotentialChangeRateUnit, T>.ToUnit(ElectricPotentialChangeRateUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricPotentialChangeRateUnit> IQuantity<ElectricPotentialChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialChangeRateUnit, T> IQuantityT<ElectricPotentialChangeRateUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricPotentialChangeRateUnit.KilovoltPerHour: return (_value/3600) * 1e3d;
-                case ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond: return (_value*1E6) * 1e3d;
-                case ElectricPotentialChangeRateUnit.KilovoltPerMinute: return (_value/60) * 1e3d;
-                case ElectricPotentialChangeRateUnit.KilovoltPerSecond: return (_value) * 1e3d;
-                case ElectricPotentialChangeRateUnit.MegavoltPerHour: return (_value/3600) * 1e6d;
-                case ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond: return (_value*1E6) * 1e6d;
-                case ElectricPotentialChangeRateUnit.MegavoltPerMinute: return (_value/60) * 1e6d;
-                case ElectricPotentialChangeRateUnit.MegavoltPerSecond: return (_value) * 1e6d;
-                case ElectricPotentialChangeRateUnit.MicrovoltPerHour: return (_value/3600) * 1e-6d;
-                case ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond: return (_value*1E6) * 1e-6d;
-                case ElectricPotentialChangeRateUnit.MicrovoltPerMinute: return (_value/60) * 1e-6d;
-                case ElectricPotentialChangeRateUnit.MicrovoltPerSecond: return (_value) * 1e-6d;
-                case ElectricPotentialChangeRateUnit.MillivoltPerHour: return (_value/3600) * 1e-3d;
-                case ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond: return (_value*1E6) * 1e-3d;
-                case ElectricPotentialChangeRateUnit.MillivoltPerMinute: return (_value/60) * 1e-3d;
-                case ElectricPotentialChangeRateUnit.MillivoltPerSecond: return (_value) * 1e-3d;
-                case ElectricPotentialChangeRateUnit.VoltPerHour: return _value/3600;
-                case ElectricPotentialChangeRateUnit.VoltPerMicrosecond: return _value*1E6;
-                case ElectricPotentialChangeRateUnit.VoltPerMinute: return _value/60;
-                case ElectricPotentialChangeRateUnit.VoltPerSecond: return _value;
+                case ElectricPotentialChangeRateUnit.KilovoltPerHour: return (Value/3600) * 1e3d;
+                case ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond: return (Value*1E6) * 1e3d;
+                case ElectricPotentialChangeRateUnit.KilovoltPerMinute: return (Value/60) * 1e3d;
+                case ElectricPotentialChangeRateUnit.KilovoltPerSecond: return (Value) * 1e3d;
+                case ElectricPotentialChangeRateUnit.MegavoltPerHour: return (Value/3600) * 1e6d;
+                case ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond: return (Value*1E6) * 1e6d;
+                case ElectricPotentialChangeRateUnit.MegavoltPerMinute: return (Value/60) * 1e6d;
+                case ElectricPotentialChangeRateUnit.MegavoltPerSecond: return (Value) * 1e6d;
+                case ElectricPotentialChangeRateUnit.MicrovoltPerHour: return (Value/3600) * 1e-6d;
+                case ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond: return (Value*1E6) * 1e-6d;
+                case ElectricPotentialChangeRateUnit.MicrovoltPerMinute: return (Value/60) * 1e-6d;
+                case ElectricPotentialChangeRateUnit.MicrovoltPerSecond: return (Value) * 1e-6d;
+                case ElectricPotentialChangeRateUnit.MillivoltPerHour: return (Value/3600) * 1e-3d;
+                case ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond: return (Value*1E6) * 1e-3d;
+                case ElectricPotentialChangeRateUnit.MillivoltPerMinute: return (Value/60) * 1e-3d;
+                case ElectricPotentialChangeRateUnit.MillivoltPerSecond: return (Value) * 1e-3d;
+                case ElectricPotentialChangeRateUnit.VoltPerHour: return Value/3600;
+                case ElectricPotentialChangeRateUnit.VoltPerMicrosecond: return Value*1E6;
+                case ElectricPotentialChangeRateUnit.VoltPerMinute: return Value/60;
+                case ElectricPotentialChangeRateUnit.VoltPerSecond: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -953,16 +945,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricPotentialChangeRate ToBaseUnit()
+        internal ElectricPotentialChangeRate<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricPotentialChangeRate(baseUnitValue, BaseUnit);
+            return new ElectricPotentialChangeRate<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricPotentialChangeRateUnit unit)
+        private T GetValueAs(ElectricPotentialChangeRateUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1084,57 +1076,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1144,33 +1136,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricPotentialChangeRate))
+            if(conversionType == typeof(ElectricPotentialChangeRate<T>))
                 return this;
             else if(conversionType == typeof(ElectricPotentialChangeRateUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricPotentialChangeRate.QuantityType;
+                return ElectricPotentialChangeRate<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricPotentialChangeRate.Info;
+                return ElectricPotentialChangeRate<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricPotentialChangeRate.BaseDimensions;
+                return ElectricPotentialChangeRate<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricPotentialChangeRate<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
index 998adeb224..7abfde2e27 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The Electric Potential of a system known to use Direct Current.
     /// </summary>
-    public partial struct ElectricPotentialDc : IQuantity<ElectricPotentialDcUnit>, IEquatable<ElectricPotentialDc>, IComparable, IComparable<ElectricPotentialDc>, IConvertible, IFormattable
+    public partial struct ElectricPotentialDc<T> : IQuantityT<ElectricPotentialDcUnit, T>, IEquatable<ElectricPotentialDc<T>>, IComparable, IComparable<ElectricPotentialDc<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -67,12 +63,12 @@ static ElectricPotentialDc()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricPotentialDc(double value, ElectricPotentialDcUnit unit)
+        public ElectricPotentialDc(T value, ElectricPotentialDcUnit unit)
         {
             if(unit == ElectricPotentialDcUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -84,14 +80,14 @@ public ElectricPotentialDc(double value, ElectricPotentialDcUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricPotentialDc(double value, UnitSystem unitSystem)
+        public ElectricPotentialDc(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -106,19 +102,19 @@ public ElectricPotentialDc(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricPotentialDc, which is VoltDc. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricPotentialDc{T}" />, which is VoltDc. All conversions go via this value.
         /// </summary>
         public static ElectricPotentialDcUnit BaseUnit { get; } = ElectricPotentialDcUnit.VoltDc;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricPotentialDc
+        /// Represents the largest possible value of <see cref="ElectricPotentialDc{T}" />
         /// </summary>
-        public static ElectricPotentialDc MaxValue { get; } = new ElectricPotentialDc(double.MaxValue, BaseUnit);
+        public static ElectricPotentialDc<T> MaxValue { get; } = new ElectricPotentialDc<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricPotentialDc
+        /// Represents the smallest possible value of <see cref="ElectricPotentialDc{T}" />
         /// </summary>
-        public static ElectricPotentialDc MinValue { get; } = new ElectricPotentialDc(double.MinValue, BaseUnit);
+        public static ElectricPotentialDc<T> MinValue { get; } = new ElectricPotentialDc<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -127,14 +123,14 @@ public ElectricPotentialDc(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricPotentialDc;
 
         /// <summary>
-        ///     All units of measurement for the ElectricPotentialDc quantity.
+        ///     All units of measurement for the <see cref="ElectricPotentialDc{T}" /> quantity.
         /// </summary>
         public static ElectricPotentialDcUnit[] Units { get; } = Enum.GetValues(typeof(ElectricPotentialDcUnit)).Cast<ElectricPotentialDcUnit>().Except(new ElectricPotentialDcUnit[]{ ElectricPotentialDcUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit VoltDc.
         /// </summary>
-        public static ElectricPotentialDc Zero { get; } = new ElectricPotentialDc(0, BaseUnit);
+        public static ElectricPotentialDc<T> Zero { get; } = new ElectricPotentialDc<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -143,7 +139,9 @@ public ElectricPotentialDc(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -159,41 +157,41 @@ public ElectricPotentialDc(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricPotentialDc.QuantityType;
+        public QuantityType Type => ElectricPotentialDc<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricPotentialDc.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricPotentialDc<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricPotentialDc in KilovoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> in KilovoltsDc.
         /// </summary>
-        public double KilovoltsDc => As(ElectricPotentialDcUnit.KilovoltDc);
+        public T KilovoltsDc => As(ElectricPotentialDcUnit.KilovoltDc);
 
         /// <summary>
-        ///     Get ElectricPotentialDc in MegavoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> in MegavoltsDc.
         /// </summary>
-        public double MegavoltsDc => As(ElectricPotentialDcUnit.MegavoltDc);
+        public T MegavoltsDc => As(ElectricPotentialDcUnit.MegavoltDc);
 
         /// <summary>
-        ///     Get ElectricPotentialDc in MicrovoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> in MicrovoltsDc.
         /// </summary>
-        public double MicrovoltsDc => As(ElectricPotentialDcUnit.MicrovoltDc);
+        public T MicrovoltsDc => As(ElectricPotentialDcUnit.MicrovoltDc);
 
         /// <summary>
-        ///     Get ElectricPotentialDc in MillivoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> in MillivoltsDc.
         /// </summary>
-        public double MillivoltsDc => As(ElectricPotentialDcUnit.MillivoltDc);
+        public T MillivoltsDc => As(ElectricPotentialDcUnit.MillivoltDc);
 
         /// <summary>
-        ///     Get ElectricPotentialDc in VoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> in VoltsDc.
         /// </summary>
-        public double VoltsDc => As(ElectricPotentialDcUnit.VoltDc);
+        public T VoltsDc => As(ElectricPotentialDcUnit.VoltDc);
 
         #endregion
 
@@ -225,60 +223,55 @@ public static string GetAbbreviation(ElectricPotentialDcUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricPotentialDc from KilovoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> from KilovoltsDc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromKilovoltsDc(QuantityValue kilovoltsdc)
+        public static ElectricPotentialDc<T> FromKilovoltsDc(T kilovoltsdc)
         {
-            double value = (double) kilovoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.KilovoltDc);
+            return new ElectricPotentialDc<T>(kilovoltsdc, ElectricPotentialDcUnit.KilovoltDc);
         }
         /// <summary>
-        ///     Get ElectricPotentialDc from MegavoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> from MegavoltsDc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMegavoltsDc(QuantityValue megavoltsdc)
+        public static ElectricPotentialDc<T> FromMegavoltsDc(T megavoltsdc)
         {
-            double value = (double) megavoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MegavoltDc);
+            return new ElectricPotentialDc<T>(megavoltsdc, ElectricPotentialDcUnit.MegavoltDc);
         }
         /// <summary>
-        ///     Get ElectricPotentialDc from MicrovoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> from MicrovoltsDc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMicrovoltsDc(QuantityValue microvoltsdc)
+        public static ElectricPotentialDc<T> FromMicrovoltsDc(T microvoltsdc)
         {
-            double value = (double) microvoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MicrovoltDc);
+            return new ElectricPotentialDc<T>(microvoltsdc, ElectricPotentialDcUnit.MicrovoltDc);
         }
         /// <summary>
-        ///     Get ElectricPotentialDc from MillivoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> from MillivoltsDc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMillivoltsDc(QuantityValue millivoltsdc)
+        public static ElectricPotentialDc<T> FromMillivoltsDc(T millivoltsdc)
         {
-            double value = (double) millivoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MillivoltDc);
+            return new ElectricPotentialDc<T>(millivoltsdc, ElectricPotentialDcUnit.MillivoltDc);
         }
         /// <summary>
-        ///     Get ElectricPotentialDc from VoltsDc.
+        ///     Get <see cref="ElectricPotentialDc{T}" /> from VoltsDc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromVoltsDc(QuantityValue voltsdc)
+        public static ElectricPotentialDc<T> FromVoltsDc(T voltsdc)
         {
-            double value = (double) voltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.VoltDc);
+            return new ElectricPotentialDc<T>(voltsdc, ElectricPotentialDcUnit.VoltDc);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialDcUnit" /> to <see cref="ElectricPotentialDc" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialDcUnit" /> to <see cref="ElectricPotentialDc{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricPotentialDc unit value.</returns>
-        public static ElectricPotentialDc From(QuantityValue value, ElectricPotentialDcUnit fromUnit)
+        /// <returns><see cref="ElectricPotentialDc{T}" /> unit value.</returns>
+        public static ElectricPotentialDc<T> From(T value, ElectricPotentialDcUnit fromUnit)
         {
-            return new ElectricPotentialDc((double)value, fromUnit);
+            return new ElectricPotentialDc<T>(value, fromUnit);
         }
 
         #endregion
@@ -307,7 +300,7 @@ public static ElectricPotentialDc From(QuantityValue value, ElectricPotentialDcU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricPotentialDc Parse(string str)
+        public static ElectricPotentialDc<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -335,9 +328,9 @@ public static ElectricPotentialDc Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricPotentialDc Parse(string str, IFormatProvider? provider)
+        public static ElectricPotentialDc<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricPotentialDc, ElectricPotentialDcUnit>(
+            return QuantityParser.Default.Parse<T, ElectricPotentialDc<T>, ElectricPotentialDcUnit>(
                 str,
                 provider,
                 From);
@@ -351,7 +344,7 @@ public static ElectricPotentialDc Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricPotentialDc result)
+        public static bool TryParse(string? str, out ElectricPotentialDc<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -366,9 +359,9 @@ public static bool TryParse(string? str, out ElectricPotentialDc result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotentialDc result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricPotentialDc<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricPotentialDc, ElectricPotentialDcUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricPotentialDc<T>, ElectricPotentialDcUnit>(
                 str,
                 provider,
                 From,
@@ -430,45 +423,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricPotentialDc operator -(ElectricPotentialDc right)
+        public static ElectricPotentialDc<T> operator -(ElectricPotentialDc<T> right)
         {
-            return new ElectricPotentialDc(-right.Value, right.Unit);
+            return new ElectricPotentialDc<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialDc"/> from adding two <see cref="ElectricPotentialDc"/>.</summary>
-        public static ElectricPotentialDc operator +(ElectricPotentialDc left, ElectricPotentialDc right)
+        /// <summary>Get <see cref="ElectricPotentialDc{T}"/> from adding two <see cref="ElectricPotentialDc{T}"/>.</summary>
+        public static ElectricPotentialDc<T> operator +(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
-            return new ElectricPotentialDc(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotentialDc<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialDc"/> from subtracting two <see cref="ElectricPotentialDc"/>.</summary>
-        public static ElectricPotentialDc operator -(ElectricPotentialDc left, ElectricPotentialDc right)
+        /// <summary>Get <see cref="ElectricPotentialDc{T}"/> from subtracting two <see cref="ElectricPotentialDc{T}"/>.</summary>
+        public static ElectricPotentialDc<T> operator -(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
-            return new ElectricPotentialDc(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricPotentialDc<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialDc"/> from multiplying value and <see cref="ElectricPotentialDc"/>.</summary>
-        public static ElectricPotentialDc operator *(double left, ElectricPotentialDc right)
+        /// <summary>Get <see cref="ElectricPotentialDc{T}"/> from multiplying value and <see cref="ElectricPotentialDc{T}"/>.</summary>
+        public static ElectricPotentialDc<T> operator *(T left, ElectricPotentialDc<T> right)
         {
-            return new ElectricPotentialDc(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricPotentialDc<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialDc"/> from multiplying value and <see cref="ElectricPotentialDc"/>.</summary>
-        public static ElectricPotentialDc operator *(ElectricPotentialDc left, double right)
+        /// <summary>Get <see cref="ElectricPotentialDc{T}"/> from multiplying value and <see cref="ElectricPotentialDc{T}"/>.</summary>
+        public static ElectricPotentialDc<T> operator *(ElectricPotentialDc<T> left, T right)
         {
-            return new ElectricPotentialDc(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricPotentialDc<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricPotentialDc"/> from dividing <see cref="ElectricPotentialDc"/> by value.</summary>
-        public static ElectricPotentialDc operator /(ElectricPotentialDc left, double right)
+        /// <summary>Get <see cref="ElectricPotentialDc{T}"/> from dividing <see cref="ElectricPotentialDc{T}"/> by value.</summary>
+        public static ElectricPotentialDc<T> operator /(ElectricPotentialDc<T> left, T right)
         {
-            return new ElectricPotentialDc(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricPotentialDc<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricPotentialDc"/> by <see cref="ElectricPotentialDc"/>.</summary>
-        public static double operator /(ElectricPotentialDc left, ElectricPotentialDc right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricPotentialDc{T}"/> by <see cref="ElectricPotentialDc{T}"/>.</summary>
+        public static T operator /(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
-            return left.VoltsDc / right.VoltsDc;
+            return CompiledLambdas.Divide(left.VoltsDc, right.VoltsDc);
         }
 
         #endregion
@@ -476,39 +474,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricPotentialDc left, ElectricPotentialDc right)
+        public static bool operator <=(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricPotentialDc left, ElectricPotentialDc right)
+        public static bool operator >=(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricPotentialDc left, ElectricPotentialDc right)
+        public static bool operator <(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricPotentialDc left, ElectricPotentialDc right)
+        public static bool operator >(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricPotentialDc left, ElectricPotentialDc right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricPotentialDc left, ElectricPotentialDc right)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricPotentialDc<T> left, ElectricPotentialDc<T> right)
         {
             return !(left == right);
         }
@@ -517,37 +515,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricPotentialDc objElectricPotentialDc)) throw new ArgumentException("Expected type ElectricPotentialDc.", nameof(obj));
+            if(!(obj is ElectricPotentialDc<T> objElectricPotentialDc)) throw new ArgumentException("Expected type ElectricPotentialDc.", nameof(obj));
 
             return CompareTo(objElectricPotentialDc);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricPotentialDc other)
+        public int CompareTo(ElectricPotentialDc<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricPotentialDc objElectricPotentialDc))
+            if(obj is null || !(obj is ElectricPotentialDc<T> objElectricPotentialDc))
                 return false;
 
             return Equals(objElectricPotentialDc);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricPotentialDc other)
+        /// <remarks>Consider using <see cref="Equals(ElectricPotentialDc{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricPotentialDc<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricPotentialDc within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricPotentialDc{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -585,21 +583,19 @@ public bool Equals(ElectricPotentialDc other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricPotentialDc other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricPotentialDc<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricPotentialDc.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricPotentialDc{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -613,17 +609,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricPotentialDcUnit unit)
+        public T As(ElectricPotentialDcUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -643,17 +639,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricPotentialDcUnit unitAsElectricPotentialDcUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialDcUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricPotentialDcUnit);
+            var asValue = As(unitAsElectricPotentialDcUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricPotentialDcUnit>.As(ElectricPotentialDcUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricPotentialDc to another ElectricPotentialDc with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricPotentialDc{T}" /> to another <see cref="ElectricPotentialDc{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricPotentialDc with the specified unit.</returns>
-        public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit)
+        /// <returns>A <see cref="ElectricPotentialDc{T}" /> with the specified unit.</returns>
+        public ElectricPotentialDc<T> ToUnit(ElectricPotentialDcUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricPotentialDc(convertedValue, unit);
+            return new ElectricPotentialDc<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -666,7 +667,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricPotentialDc ToUnit(UnitSystem unitSystem)
+        public ElectricPotentialDc<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -686,23 +687,29 @@ public ElectricPotentialDc ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialDcUnit> IQuantity<ElectricPotentialDcUnit>.ToUnit(ElectricPotentialDcUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialDcUnit, T> IQuantityT<ElectricPotentialDcUnit, T>.ToUnit(ElectricPotentialDcUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricPotentialDcUnit> IQuantity<ElectricPotentialDcUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricPotentialDcUnit, T> IQuantityT<ElectricPotentialDcUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricPotentialDcUnit.KilovoltDc: return (_value) * 1e3d;
-                case ElectricPotentialDcUnit.MegavoltDc: return (_value) * 1e6d;
-                case ElectricPotentialDcUnit.MicrovoltDc: return (_value) * 1e-6d;
-                case ElectricPotentialDcUnit.MillivoltDc: return (_value) * 1e-3d;
-                case ElectricPotentialDcUnit.VoltDc: return _value;
+                case ElectricPotentialDcUnit.KilovoltDc: return (Value) * 1e3d;
+                case ElectricPotentialDcUnit.MegavoltDc: return (Value) * 1e6d;
+                case ElectricPotentialDcUnit.MicrovoltDc: return (Value) * 1e-6d;
+                case ElectricPotentialDcUnit.MillivoltDc: return (Value) * 1e-3d;
+                case ElectricPotentialDcUnit.VoltDc: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -713,16 +720,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricPotentialDc ToBaseUnit()
+        internal ElectricPotentialDc<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricPotentialDc(baseUnitValue, BaseUnit);
+            return new ElectricPotentialDc<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricPotentialDcUnit unit)
+        private T GetValueAs(ElectricPotentialDcUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -829,57 +836,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -889,33 +896,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricPotentialDc))
+            if(conversionType == typeof(ElectricPotentialDc<T>))
                 return this;
             else if(conversionType == typeof(ElectricPotentialDcUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricPotentialDc.QuantityType;
+                return ElectricPotentialDc<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricPotentialDc.Info;
+                return ElectricPotentialDc<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricPotentialDc.BaseDimensions;
+                return ElectricPotentialDc<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricPotentialDc<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
index 3f7b425639..f253a88446 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The electrical resistance of an electrical conductor is the opposition to the passage of an electric current through that conductor.
     /// </summary>
-    public partial struct ElectricResistance : IQuantity<ElectricResistanceUnit>, IEquatable<ElectricResistance>, IComparable, IComparable<ElectricResistance>, IConvertible, IFormattable
+    public partial struct ElectricResistance<T> : IQuantityT<ElectricResistanceUnit, T>, IEquatable<ElectricResistance<T>>, IComparable, IComparable<ElectricResistance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static ElectricResistance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricResistance(double value, ElectricResistanceUnit unit)
+        public ElectricResistance(T value, ElectricResistanceUnit unit)
         {
             if(unit == ElectricResistanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public ElectricResistance(double value, ElectricResistanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricResistance(double value, UnitSystem unitSystem)
+        public ElectricResistance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public ElectricResistance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricResistance, which is Ohm. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricResistance{T}" />, which is Ohm. All conversions go via this value.
         /// </summary>
         public static ElectricResistanceUnit BaseUnit { get; } = ElectricResistanceUnit.Ohm;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricResistance
+        /// Represents the largest possible value of <see cref="ElectricResistance{T}" />
         /// </summary>
-        public static ElectricResistance MaxValue { get; } = new ElectricResistance(double.MaxValue, BaseUnit);
+        public static ElectricResistance<T> MaxValue { get; } = new ElectricResistance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricResistance
+        /// Represents the smallest possible value of <see cref="ElectricResistance{T}" />
         /// </summary>
-        public static ElectricResistance MinValue { get; } = new ElectricResistance(double.MinValue, BaseUnit);
+        public static ElectricResistance<T> MinValue { get; } = new ElectricResistance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public ElectricResistance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricResistance;
 
         /// <summary>
-        ///     All units of measurement for the ElectricResistance quantity.
+        ///     All units of measurement for the <see cref="ElectricResistance{T}" /> quantity.
         /// </summary>
         public static ElectricResistanceUnit[] Units { get; } = Enum.GetValues(typeof(ElectricResistanceUnit)).Cast<ElectricResistanceUnit>().Except(new ElectricResistanceUnit[]{ ElectricResistanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Ohm.
         /// </summary>
-        public static ElectricResistance Zero { get; } = new ElectricResistance(0, BaseUnit);
+        public static ElectricResistance<T> Zero { get; } = new ElectricResistance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public ElectricResistance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,46 +158,46 @@ public ElectricResistance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricResistance.QuantityType;
+        public QuantityType Type => ElectricResistance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricResistance.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricResistance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricResistance in Gigaohms.
+        ///     Get <see cref="ElectricResistance{T}" /> in Gigaohms.
         /// </summary>
-        public double Gigaohms => As(ElectricResistanceUnit.Gigaohm);
+        public T Gigaohms => As(ElectricResistanceUnit.Gigaohm);
 
         /// <summary>
-        ///     Get ElectricResistance in Kiloohms.
+        ///     Get <see cref="ElectricResistance{T}" /> in Kiloohms.
         /// </summary>
-        public double Kiloohms => As(ElectricResistanceUnit.Kiloohm);
+        public T Kiloohms => As(ElectricResistanceUnit.Kiloohm);
 
         /// <summary>
-        ///     Get ElectricResistance in Megaohms.
+        ///     Get <see cref="ElectricResistance{T}" /> in Megaohms.
         /// </summary>
-        public double Megaohms => As(ElectricResistanceUnit.Megaohm);
+        public T Megaohms => As(ElectricResistanceUnit.Megaohm);
 
         /// <summary>
-        ///     Get ElectricResistance in Microohms.
+        ///     Get <see cref="ElectricResistance{T}" /> in Microohms.
         /// </summary>
-        public double Microohms => As(ElectricResistanceUnit.Microohm);
+        public T Microohms => As(ElectricResistanceUnit.Microohm);
 
         /// <summary>
-        ///     Get ElectricResistance in Milliohms.
+        ///     Get <see cref="ElectricResistance{T}" /> in Milliohms.
         /// </summary>
-        public double Milliohms => As(ElectricResistanceUnit.Milliohm);
+        public T Milliohms => As(ElectricResistanceUnit.Milliohm);
 
         /// <summary>
-        ///     Get ElectricResistance in Ohms.
+        ///     Get <see cref="ElectricResistance{T}" /> in Ohms.
         /// </summary>
-        public double Ohms => As(ElectricResistanceUnit.Ohm);
+        public T Ohms => As(ElectricResistanceUnit.Ohm);
 
         #endregion
 
@@ -231,69 +229,63 @@ public static string GetAbbreviation(ElectricResistanceUnit unit, IFormatProvide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricResistance from Gigaohms.
+        ///     Get <see cref="ElectricResistance{T}" /> from Gigaohms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromGigaohms(QuantityValue gigaohms)
+        public static ElectricResistance<T> FromGigaohms(T gigaohms)
         {
-            double value = (double) gigaohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm);
+            return new ElectricResistance<T>(gigaohms, ElectricResistanceUnit.Gigaohm);
         }
         /// <summary>
-        ///     Get ElectricResistance from Kiloohms.
+        ///     Get <see cref="ElectricResistance{T}" /> from Kiloohms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromKiloohms(QuantityValue kiloohms)
+        public static ElectricResistance<T> FromKiloohms(T kiloohms)
         {
-            double value = (double) kiloohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm);
+            return new ElectricResistance<T>(kiloohms, ElectricResistanceUnit.Kiloohm);
         }
         /// <summary>
-        ///     Get ElectricResistance from Megaohms.
+        ///     Get <see cref="ElectricResistance{T}" /> from Megaohms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMegaohms(QuantityValue megaohms)
+        public static ElectricResistance<T> FromMegaohms(T megaohms)
         {
-            double value = (double) megaohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Megaohm);
+            return new ElectricResistance<T>(megaohms, ElectricResistanceUnit.Megaohm);
         }
         /// <summary>
-        ///     Get ElectricResistance from Microohms.
+        ///     Get <see cref="ElectricResistance{T}" /> from Microohms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMicroohms(QuantityValue microohms)
+        public static ElectricResistance<T> FromMicroohms(T microohms)
         {
-            double value = (double) microohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Microohm);
+            return new ElectricResistance<T>(microohms, ElectricResistanceUnit.Microohm);
         }
         /// <summary>
-        ///     Get ElectricResistance from Milliohms.
+        ///     Get <see cref="ElectricResistance{T}" /> from Milliohms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMilliohms(QuantityValue milliohms)
+        public static ElectricResistance<T> FromMilliohms(T milliohms)
         {
-            double value = (double) milliohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Milliohm);
+            return new ElectricResistance<T>(milliohms, ElectricResistanceUnit.Milliohm);
         }
         /// <summary>
-        ///     Get ElectricResistance from Ohms.
+        ///     Get <see cref="ElectricResistance{T}" /> from Ohms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromOhms(QuantityValue ohms)
+        public static ElectricResistance<T> FromOhms(T ohms)
         {
-            double value = (double) ohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Ohm);
+            return new ElectricResistance<T>(ohms, ElectricResistanceUnit.Ohm);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricResistanceUnit" /> to <see cref="ElectricResistance" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricResistanceUnit" /> to <see cref="ElectricResistance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricResistance unit value.</returns>
-        public static ElectricResistance From(QuantityValue value, ElectricResistanceUnit fromUnit)
+        /// <returns><see cref="ElectricResistance{T}" /> unit value.</returns>
+        public static ElectricResistance<T> From(T value, ElectricResistanceUnit fromUnit)
         {
-            return new ElectricResistance((double)value, fromUnit);
+            return new ElectricResistance<T>(value, fromUnit);
         }
 
         #endregion
@@ -322,7 +314,7 @@ public static ElectricResistance From(QuantityValue value, ElectricResistanceUni
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricResistance Parse(string str)
+        public static ElectricResistance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -350,9 +342,9 @@ public static ElectricResistance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricResistance Parse(string str, IFormatProvider? provider)
+        public static ElectricResistance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricResistance, ElectricResistanceUnit>(
+            return QuantityParser.Default.Parse<T, ElectricResistance<T>, ElectricResistanceUnit>(
                 str,
                 provider,
                 From);
@@ -366,7 +358,7 @@ public static ElectricResistance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricResistance result)
+        public static bool TryParse(string? str, out ElectricResistance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -381,9 +373,9 @@ public static bool TryParse(string? str, out ElectricResistance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricResistance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricResistance<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricResistance, ElectricResistanceUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricResistance<T>, ElectricResistanceUnit>(
                 str,
                 provider,
                 From,
@@ -445,45 +437,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricResistance operator -(ElectricResistance right)
+        public static ElectricResistance<T> operator -(ElectricResistance<T> right)
         {
-            return new ElectricResistance(-right.Value, right.Unit);
+            return new ElectricResistance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistance"/> from adding two <see cref="ElectricResistance"/>.</summary>
-        public static ElectricResistance operator +(ElectricResistance left, ElectricResistance right)
+        /// <summary>Get <see cref="ElectricResistance{T}"/> from adding two <see cref="ElectricResistance{T}"/>.</summary>
+        public static ElectricResistance<T> operator +(ElectricResistance<T> left, ElectricResistance<T> right)
         {
-            return new ElectricResistance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistance"/> from subtracting two <see cref="ElectricResistance"/>.</summary>
-        public static ElectricResistance operator -(ElectricResistance left, ElectricResistance right)
+        /// <summary>Get <see cref="ElectricResistance{T}"/> from subtracting two <see cref="ElectricResistance{T}"/>.</summary>
+        public static ElectricResistance<T> operator -(ElectricResistance<T> left, ElectricResistance<T> right)
         {
-            return new ElectricResistance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistance"/> from multiplying value and <see cref="ElectricResistance"/>.</summary>
-        public static ElectricResistance operator *(double left, ElectricResistance right)
+        /// <summary>Get <see cref="ElectricResistance{T}"/> from multiplying value and <see cref="ElectricResistance{T}"/>.</summary>
+        public static ElectricResistance<T> operator *(T left, ElectricResistance<T> right)
         {
-            return new ElectricResistance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricResistance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistance"/> from multiplying value and <see cref="ElectricResistance"/>.</summary>
-        public static ElectricResistance operator *(ElectricResistance left, double right)
+        /// <summary>Get <see cref="ElectricResistance{T}"/> from multiplying value and <see cref="ElectricResistance{T}"/>.</summary>
+        public static ElectricResistance<T> operator *(ElectricResistance<T> left, T right)
         {
-            return new ElectricResistance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistance"/> from dividing <see cref="ElectricResistance"/> by value.</summary>
-        public static ElectricResistance operator /(ElectricResistance left, double right)
+        /// <summary>Get <see cref="ElectricResistance{T}"/> from dividing <see cref="ElectricResistance{T}"/> by value.</summary>
+        public static ElectricResistance<T> operator /(ElectricResistance<T> left, T right)
         {
-            return new ElectricResistance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricResistance"/> by <see cref="ElectricResistance"/>.</summary>
-        public static double operator /(ElectricResistance left, ElectricResistance right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricResistance{T}"/> by <see cref="ElectricResistance{T}"/>.</summary>
+        public static T operator /(ElectricResistance<T> left, ElectricResistance<T> right)
         {
-            return left.Ohms / right.Ohms;
+            return CompiledLambdas.Divide(left.Ohms, right.Ohms);
         }
 
         #endregion
@@ -491,39 +488,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricResistance left, ElectricResistance right)
+        public static bool operator <=(ElectricResistance<T> left, ElectricResistance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricResistance left, ElectricResistance right)
+        public static bool operator >=(ElectricResistance<T> left, ElectricResistance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricResistance left, ElectricResistance right)
+        public static bool operator <(ElectricResistance<T> left, ElectricResistance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricResistance left, ElectricResistance right)
+        public static bool operator >(ElectricResistance<T> left, ElectricResistance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricResistance left, ElectricResistance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricResistance<T> left, ElectricResistance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricResistance left, ElectricResistance right)
+        /// <remarks>Consider using <see cref="Equals(ElectricResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricResistance<T> left, ElectricResistance<T> right)
         {
             return !(left == right);
         }
@@ -532,37 +529,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricResistance objElectricResistance)) throw new ArgumentException("Expected type ElectricResistance.", nameof(obj));
+            if(!(obj is ElectricResistance<T> objElectricResistance)) throw new ArgumentException("Expected type ElectricResistance.", nameof(obj));
 
             return CompareTo(objElectricResistance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricResistance other)
+        public int CompareTo(ElectricResistance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricResistance objElectricResistance))
+            if(obj is null || !(obj is ElectricResistance<T> objElectricResistance))
                 return false;
 
             return Equals(objElectricResistance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricResistance other)
+        /// <remarks>Consider using <see cref="Equals(ElectricResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricResistance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricResistance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricResistance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -600,21 +597,19 @@ public bool Equals(ElectricResistance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricResistance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricResistance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricResistance.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricResistance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -628,17 +623,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricResistanceUnit unit)
+        public T As(ElectricResistanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -658,17 +653,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricResistanceUnit unitAsElectricResistanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricResistanceUnit);
+            var asValue = As(unitAsElectricResistanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricResistanceUnit>.As(ElectricResistanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricResistance to another ElectricResistance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricResistance{T}" /> to another <see cref="ElectricResistance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricResistance with the specified unit.</returns>
-        public ElectricResistance ToUnit(ElectricResistanceUnit unit)
+        /// <returns>A <see cref="ElectricResistance{T}" /> with the specified unit.</returns>
+        public ElectricResistance<T> ToUnit(ElectricResistanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricResistance(convertedValue, unit);
+            return new ElectricResistance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -681,7 +681,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricResistance ToUnit(UnitSystem unitSystem)
+        public ElectricResistance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -701,24 +701,30 @@ public ElectricResistance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricResistanceUnit> IQuantity<ElectricResistanceUnit>.ToUnit(ElectricResistanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricResistanceUnit, T> IQuantityT<ElectricResistanceUnit, T>.ToUnit(ElectricResistanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricResistanceUnit> IQuantity<ElectricResistanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricResistanceUnit, T> IQuantityT<ElectricResistanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricResistanceUnit.Gigaohm: return (_value) * 1e9d;
-                case ElectricResistanceUnit.Kiloohm: return (_value) * 1e3d;
-                case ElectricResistanceUnit.Megaohm: return (_value) * 1e6d;
-                case ElectricResistanceUnit.Microohm: return (_value) * 1e-6d;
-                case ElectricResistanceUnit.Milliohm: return (_value) * 1e-3d;
-                case ElectricResistanceUnit.Ohm: return _value;
+                case ElectricResistanceUnit.Gigaohm: return (Value) * 1e9d;
+                case ElectricResistanceUnit.Kiloohm: return (Value) * 1e3d;
+                case ElectricResistanceUnit.Megaohm: return (Value) * 1e6d;
+                case ElectricResistanceUnit.Microohm: return (Value) * 1e-6d;
+                case ElectricResistanceUnit.Milliohm: return (Value) * 1e-3d;
+                case ElectricResistanceUnit.Ohm: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -729,16 +735,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricResistance ToBaseUnit()
+        internal ElectricResistance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricResistance(baseUnitValue, BaseUnit);
+            return new ElectricResistance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricResistanceUnit unit)
+        private T GetValueAs(ElectricResistanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -846,57 +852,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricResistance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricResistance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricResistance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricResistance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricResistance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricResistance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -906,33 +912,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricResistance))
+            if(conversionType == typeof(ElectricResistance<T>))
                 return this;
             else if(conversionType == typeof(ElectricResistanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricResistance.QuantityType;
+                return ElectricResistance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricResistance.Info;
+                return ElectricResistance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricResistance.BaseDimensions;
+                return ElectricResistance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricResistance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricResistance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
index 56726eaeaf..eec0c3e5b7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Electrical_resistivity_and_conductivity
     /// </remarks>
-    public partial struct ElectricResistivity : IQuantity<ElectricResistivityUnit>, IEquatable<ElectricResistivity>, IComparable, IComparable<ElectricResistivity>, IConvertible, IFormattable
+    public partial struct ElectricResistivity<T> : IQuantityT<ElectricResistivityUnit, T>, IEquatable<ElectricResistivity<T>>, IComparable, IComparable<ElectricResistivity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -79,12 +75,12 @@ static ElectricResistivity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricResistivity(double value, ElectricResistivityUnit unit)
+        public ElectricResistivity(T value, ElectricResistivityUnit unit)
         {
             if(unit == ElectricResistivityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -96,14 +92,14 @@ public ElectricResistivity(double value, ElectricResistivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricResistivity(double value, UnitSystem unitSystem)
+        public ElectricResistivity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -118,19 +114,19 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricResistivity, which is OhmMeter. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricResistivity{T}" />, which is OhmMeter. All conversions go via this value.
         /// </summary>
         public static ElectricResistivityUnit BaseUnit { get; } = ElectricResistivityUnit.OhmMeter;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricResistivity
+        /// Represents the largest possible value of <see cref="ElectricResistivity{T}" />
         /// </summary>
-        public static ElectricResistivity MaxValue { get; } = new ElectricResistivity(double.MaxValue, BaseUnit);
+        public static ElectricResistivity<T> MaxValue { get; } = new ElectricResistivity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricResistivity
+        /// Represents the smallest possible value of <see cref="ElectricResistivity{T}" />
         /// </summary>
-        public static ElectricResistivity MinValue { get; } = new ElectricResistivity(double.MinValue, BaseUnit);
+        public static ElectricResistivity<T> MinValue { get; } = new ElectricResistivity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -139,14 +135,14 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricResistivity;
 
         /// <summary>
-        ///     All units of measurement for the ElectricResistivity quantity.
+        ///     All units of measurement for the <see cref="ElectricResistivity{T}" /> quantity.
         /// </summary>
         public static ElectricResistivityUnit[] Units { get; } = Enum.GetValues(typeof(ElectricResistivityUnit)).Cast<ElectricResistivityUnit>().Except(new ElectricResistivityUnit[]{ ElectricResistivityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit OhmMeter.
         /// </summary>
-        public static ElectricResistivity Zero { get; } = new ElectricResistivity(0, BaseUnit);
+        public static ElectricResistivity<T> Zero { get; } = new ElectricResistivity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -155,7 +151,9 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -171,86 +169,86 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricResistivity.QuantityType;
+        public QuantityType Type => ElectricResistivity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricResistivity.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricResistivity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricResistivity in KiloohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> in KiloohmsCentimeter.
         /// </summary>
-        public double KiloohmsCentimeter => As(ElectricResistivityUnit.KiloohmCentimeter);
+        public T KiloohmsCentimeter => As(ElectricResistivityUnit.KiloohmCentimeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in KiloohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> in KiloohmMeters.
         /// </summary>
-        public double KiloohmMeters => As(ElectricResistivityUnit.KiloohmMeter);
+        public T KiloohmMeters => As(ElectricResistivityUnit.KiloohmMeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in MegaohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> in MegaohmsCentimeter.
         /// </summary>
-        public double MegaohmsCentimeter => As(ElectricResistivityUnit.MegaohmCentimeter);
+        public T MegaohmsCentimeter => As(ElectricResistivityUnit.MegaohmCentimeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in MegaohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> in MegaohmMeters.
         /// </summary>
-        public double MegaohmMeters => As(ElectricResistivityUnit.MegaohmMeter);
+        public T MegaohmMeters => As(ElectricResistivityUnit.MegaohmMeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in MicroohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> in MicroohmsCentimeter.
         /// </summary>
-        public double MicroohmsCentimeter => As(ElectricResistivityUnit.MicroohmCentimeter);
+        public T MicroohmsCentimeter => As(ElectricResistivityUnit.MicroohmCentimeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in MicroohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> in MicroohmMeters.
         /// </summary>
-        public double MicroohmMeters => As(ElectricResistivityUnit.MicroohmMeter);
+        public T MicroohmMeters => As(ElectricResistivityUnit.MicroohmMeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in MilliohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> in MilliohmsCentimeter.
         /// </summary>
-        public double MilliohmsCentimeter => As(ElectricResistivityUnit.MilliohmCentimeter);
+        public T MilliohmsCentimeter => As(ElectricResistivityUnit.MilliohmCentimeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in MilliohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> in MilliohmMeters.
         /// </summary>
-        public double MilliohmMeters => As(ElectricResistivityUnit.MilliohmMeter);
+        public T MilliohmMeters => As(ElectricResistivityUnit.MilliohmMeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in NanoohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> in NanoohmsCentimeter.
         /// </summary>
-        public double NanoohmsCentimeter => As(ElectricResistivityUnit.NanoohmCentimeter);
+        public T NanoohmsCentimeter => As(ElectricResistivityUnit.NanoohmCentimeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in NanoohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> in NanoohmMeters.
         /// </summary>
-        public double NanoohmMeters => As(ElectricResistivityUnit.NanoohmMeter);
+        public T NanoohmMeters => As(ElectricResistivityUnit.NanoohmMeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in OhmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> in OhmsCentimeter.
         /// </summary>
-        public double OhmsCentimeter => As(ElectricResistivityUnit.OhmCentimeter);
+        public T OhmsCentimeter => As(ElectricResistivityUnit.OhmCentimeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in OhmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> in OhmMeters.
         /// </summary>
-        public double OhmMeters => As(ElectricResistivityUnit.OhmMeter);
+        public T OhmMeters => As(ElectricResistivityUnit.OhmMeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in PicoohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> in PicoohmsCentimeter.
         /// </summary>
-        public double PicoohmsCentimeter => As(ElectricResistivityUnit.PicoohmCentimeter);
+        public T PicoohmsCentimeter => As(ElectricResistivityUnit.PicoohmCentimeter);
 
         /// <summary>
-        ///     Get ElectricResistivity in PicoohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> in PicoohmMeters.
         /// </summary>
-        public double PicoohmMeters => As(ElectricResistivityUnit.PicoohmMeter);
+        public T PicoohmMeters => As(ElectricResistivityUnit.PicoohmMeter);
 
         #endregion
 
@@ -282,141 +280,127 @@ public static string GetAbbreviation(ElectricResistivityUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricResistivity from KiloohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> from KiloohmsCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromKiloohmsCentimeter(QuantityValue kiloohmscentimeter)
+        public static ElectricResistivity<T> FromKiloohmsCentimeter(T kiloohmscentimeter)
         {
-            double value = (double) kiloohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter);
+            return new ElectricResistivity<T>(kiloohmscentimeter, ElectricResistivityUnit.KiloohmCentimeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from KiloohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> from KiloohmMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromKiloohmMeters(QuantityValue kiloohmmeters)
+        public static ElectricResistivity<T> FromKiloohmMeters(T kiloohmmeters)
         {
-            double value = (double) kiloohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter);
+            return new ElectricResistivity<T>(kiloohmmeters, ElectricResistivityUnit.KiloohmMeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from MegaohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> from MegaohmsCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMegaohmsCentimeter(QuantityValue megaohmscentimeter)
+        public static ElectricResistivity<T> FromMegaohmsCentimeter(T megaohmscentimeter)
         {
-            double value = (double) megaohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter);
+            return new ElectricResistivity<T>(megaohmscentimeter, ElectricResistivityUnit.MegaohmCentimeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from MegaohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> from MegaohmMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMegaohmMeters(QuantityValue megaohmmeters)
+        public static ElectricResistivity<T> FromMegaohmMeters(T megaohmmeters)
         {
-            double value = (double) megaohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter);
+            return new ElectricResistivity<T>(megaohmmeters, ElectricResistivityUnit.MegaohmMeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from MicroohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> from MicroohmsCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMicroohmsCentimeter(QuantityValue microohmscentimeter)
+        public static ElectricResistivity<T> FromMicroohmsCentimeter(T microohmscentimeter)
         {
-            double value = (double) microohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter);
+            return new ElectricResistivity<T>(microohmscentimeter, ElectricResistivityUnit.MicroohmCentimeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from MicroohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> from MicroohmMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMicroohmMeters(QuantityValue microohmmeters)
+        public static ElectricResistivity<T> FromMicroohmMeters(T microohmmeters)
         {
-            double value = (double) microohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter);
+            return new ElectricResistivity<T>(microohmmeters, ElectricResistivityUnit.MicroohmMeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from MilliohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> from MilliohmsCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMilliohmsCentimeter(QuantityValue milliohmscentimeter)
+        public static ElectricResistivity<T> FromMilliohmsCentimeter(T milliohmscentimeter)
         {
-            double value = (double) milliohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter);
+            return new ElectricResistivity<T>(milliohmscentimeter, ElectricResistivityUnit.MilliohmCentimeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from MilliohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> from MilliohmMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMilliohmMeters(QuantityValue milliohmmeters)
+        public static ElectricResistivity<T> FromMilliohmMeters(T milliohmmeters)
         {
-            double value = (double) milliohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter);
+            return new ElectricResistivity<T>(milliohmmeters, ElectricResistivityUnit.MilliohmMeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from NanoohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> from NanoohmsCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromNanoohmsCentimeter(QuantityValue nanoohmscentimeter)
+        public static ElectricResistivity<T> FromNanoohmsCentimeter(T nanoohmscentimeter)
         {
-            double value = (double) nanoohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter);
+            return new ElectricResistivity<T>(nanoohmscentimeter, ElectricResistivityUnit.NanoohmCentimeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from NanoohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> from NanoohmMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromNanoohmMeters(QuantityValue nanoohmmeters)
+        public static ElectricResistivity<T> FromNanoohmMeters(T nanoohmmeters)
         {
-            double value = (double) nanoohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter);
+            return new ElectricResistivity<T>(nanoohmmeters, ElectricResistivityUnit.NanoohmMeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from OhmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> from OhmsCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromOhmsCentimeter(QuantityValue ohmscentimeter)
+        public static ElectricResistivity<T> FromOhmsCentimeter(T ohmscentimeter)
         {
-            double value = (double) ohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter);
+            return new ElectricResistivity<T>(ohmscentimeter, ElectricResistivityUnit.OhmCentimeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from OhmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> from OhmMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromOhmMeters(QuantityValue ohmmeters)
+        public static ElectricResistivity<T> FromOhmMeters(T ohmmeters)
         {
-            double value = (double) ohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter);
+            return new ElectricResistivity<T>(ohmmeters, ElectricResistivityUnit.OhmMeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from PicoohmsCentimeter.
+        ///     Get <see cref="ElectricResistivity{T}" /> from PicoohmsCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromPicoohmsCentimeter(QuantityValue picoohmscentimeter)
+        public static ElectricResistivity<T> FromPicoohmsCentimeter(T picoohmscentimeter)
         {
-            double value = (double) picoohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter);
+            return new ElectricResistivity<T>(picoohmscentimeter, ElectricResistivityUnit.PicoohmCentimeter);
         }
         /// <summary>
-        ///     Get ElectricResistivity from PicoohmMeters.
+        ///     Get <see cref="ElectricResistivity{T}" /> from PicoohmMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromPicoohmMeters(QuantityValue picoohmmeters)
+        public static ElectricResistivity<T> FromPicoohmMeters(T picoohmmeters)
         {
-            double value = (double) picoohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter);
+            return new ElectricResistivity<T>(picoohmmeters, ElectricResistivityUnit.PicoohmMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricResistivityUnit" /> to <see cref="ElectricResistivity" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricResistivityUnit" /> to <see cref="ElectricResistivity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricResistivity unit value.</returns>
-        public static ElectricResistivity From(QuantityValue value, ElectricResistivityUnit fromUnit)
+        /// <returns><see cref="ElectricResistivity{T}" /> unit value.</returns>
+        public static ElectricResistivity<T> From(T value, ElectricResistivityUnit fromUnit)
         {
-            return new ElectricResistivity((double)value, fromUnit);
+            return new ElectricResistivity<T>(value, fromUnit);
         }
 
         #endregion
@@ -445,7 +429,7 @@ public static ElectricResistivity From(QuantityValue value, ElectricResistivityU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricResistivity Parse(string str)
+        public static ElectricResistivity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -473,9 +457,9 @@ public static ElectricResistivity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricResistivity Parse(string str, IFormatProvider? provider)
+        public static ElectricResistivity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricResistivity, ElectricResistivityUnit>(
+            return QuantityParser.Default.Parse<T, ElectricResistivity<T>, ElectricResistivityUnit>(
                 str,
                 provider,
                 From);
@@ -489,7 +473,7 @@ public static ElectricResistivity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricResistivity result)
+        public static bool TryParse(string? str, out ElectricResistivity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -504,9 +488,9 @@ public static bool TryParse(string? str, out ElectricResistivity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricResistivity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricResistivity<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricResistivity, ElectricResistivityUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricResistivity<T>, ElectricResistivityUnit>(
                 str,
                 provider,
                 From,
@@ -568,45 +552,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricResistivity operator -(ElectricResistivity right)
+        public static ElectricResistivity<T> operator -(ElectricResistivity<T> right)
         {
-            return new ElectricResistivity(-right.Value, right.Unit);
+            return new ElectricResistivity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistivity"/> from adding two <see cref="ElectricResistivity"/>.</summary>
-        public static ElectricResistivity operator +(ElectricResistivity left, ElectricResistivity right)
+        /// <summary>Get <see cref="ElectricResistivity{T}"/> from adding two <see cref="ElectricResistivity{T}"/>.</summary>
+        public static ElectricResistivity<T> operator +(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
-            return new ElectricResistivity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricResistivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistivity"/> from subtracting two <see cref="ElectricResistivity"/>.</summary>
-        public static ElectricResistivity operator -(ElectricResistivity left, ElectricResistivity right)
+        /// <summary>Get <see cref="ElectricResistivity{T}"/> from subtracting two <see cref="ElectricResistivity{T}"/>.</summary>
+        public static ElectricResistivity<T> operator -(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
-            return new ElectricResistivity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricResistivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistivity"/> from multiplying value and <see cref="ElectricResistivity"/>.</summary>
-        public static ElectricResistivity operator *(double left, ElectricResistivity right)
+        /// <summary>Get <see cref="ElectricResistivity{T}"/> from multiplying value and <see cref="ElectricResistivity{T}"/>.</summary>
+        public static ElectricResistivity<T> operator *(T left, ElectricResistivity<T> right)
         {
-            return new ElectricResistivity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricResistivity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistivity"/> from multiplying value and <see cref="ElectricResistivity"/>.</summary>
-        public static ElectricResistivity operator *(ElectricResistivity left, double right)
+        /// <summary>Get <see cref="ElectricResistivity{T}"/> from multiplying value and <see cref="ElectricResistivity{T}"/>.</summary>
+        public static ElectricResistivity<T> operator *(ElectricResistivity<T> left, T right)
         {
-            return new ElectricResistivity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricResistivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricResistivity"/> from dividing <see cref="ElectricResistivity"/> by value.</summary>
-        public static ElectricResistivity operator /(ElectricResistivity left, double right)
+        /// <summary>Get <see cref="ElectricResistivity{T}"/> from dividing <see cref="ElectricResistivity{T}"/> by value.</summary>
+        public static ElectricResistivity<T> operator /(ElectricResistivity<T> left, T right)
         {
-            return new ElectricResistivity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricResistivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricResistivity"/> by <see cref="ElectricResistivity"/>.</summary>
-        public static double operator /(ElectricResistivity left, ElectricResistivity right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricResistivity{T}"/> by <see cref="ElectricResistivity{T}"/>.</summary>
+        public static T operator /(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
-            return left.OhmMeters / right.OhmMeters;
+            return CompiledLambdas.Divide(left.OhmMeters, right.OhmMeters);
         }
 
         #endregion
@@ -614,39 +603,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricResistivity left, ElectricResistivity right)
+        public static bool operator <=(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricResistivity left, ElectricResistivity right)
+        public static bool operator >=(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricResistivity left, ElectricResistivity right)
+        public static bool operator <(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricResistivity left, ElectricResistivity right)
+        public static bool operator >(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricResistivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricResistivity left, ElectricResistivity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricResistivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricResistivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricResistivity left, ElectricResistivity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricResistivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricResistivity<T> left, ElectricResistivity<T> right)
         {
             return !(left == right);
         }
@@ -655,37 +644,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricResistivity objElectricResistivity)) throw new ArgumentException("Expected type ElectricResistivity.", nameof(obj));
+            if(!(obj is ElectricResistivity<T> objElectricResistivity)) throw new ArgumentException("Expected type ElectricResistivity.", nameof(obj));
 
             return CompareTo(objElectricResistivity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricResistivity other)
+        public int CompareTo(ElectricResistivity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricResistivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricResistivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricResistivity objElectricResistivity))
+            if(obj is null || !(obj is ElectricResistivity<T> objElectricResistivity))
                 return false;
 
             return Equals(objElectricResistivity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricResistivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricResistivity other)
+        /// <remarks>Consider using <see cref="Equals(ElectricResistivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricResistivity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricResistivity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricResistivity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -723,21 +712,19 @@ public bool Equals(ElectricResistivity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricResistivity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricResistivity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricResistivity.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricResistivity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -751,17 +738,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricResistivityUnit unit)
+        public T As(ElectricResistivityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -781,17 +768,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricResistivityUnit unitAsElectricResistivityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistivityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricResistivityUnit);
+            var asValue = As(unitAsElectricResistivityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricResistivityUnit>.As(ElectricResistivityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricResistivity to another ElectricResistivity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricResistivity{T}" /> to another <see cref="ElectricResistivity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricResistivity with the specified unit.</returns>
-        public ElectricResistivity ToUnit(ElectricResistivityUnit unit)
+        /// <returns>A <see cref="ElectricResistivity{T}" /> with the specified unit.</returns>
+        public ElectricResistivity<T> ToUnit(ElectricResistivityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricResistivity(convertedValue, unit);
+            return new ElectricResistivity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -804,7 +796,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricResistivity ToUnit(UnitSystem unitSystem)
+        public ElectricResistivity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -824,32 +816,38 @@ public ElectricResistivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricResistivityUnit> IQuantity<ElectricResistivityUnit>.ToUnit(ElectricResistivityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricResistivityUnit, T> IQuantityT<ElectricResistivityUnit, T>.ToUnit(ElectricResistivityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricResistivityUnit> IQuantity<ElectricResistivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricResistivityUnit, T> IQuantityT<ElectricResistivityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricResistivityUnit.KiloohmCentimeter: return (_value/100) * 1e3d;
-                case ElectricResistivityUnit.KiloohmMeter: return (_value) * 1e3d;
-                case ElectricResistivityUnit.MegaohmCentimeter: return (_value/100) * 1e6d;
-                case ElectricResistivityUnit.MegaohmMeter: return (_value) * 1e6d;
-                case ElectricResistivityUnit.MicroohmCentimeter: return (_value/100) * 1e-6d;
-                case ElectricResistivityUnit.MicroohmMeter: return (_value) * 1e-6d;
-                case ElectricResistivityUnit.MilliohmCentimeter: return (_value/100) * 1e-3d;
-                case ElectricResistivityUnit.MilliohmMeter: return (_value) * 1e-3d;
-                case ElectricResistivityUnit.NanoohmCentimeter: return (_value/100) * 1e-9d;
-                case ElectricResistivityUnit.NanoohmMeter: return (_value) * 1e-9d;
-                case ElectricResistivityUnit.OhmCentimeter: return _value/100;
-                case ElectricResistivityUnit.OhmMeter: return _value;
-                case ElectricResistivityUnit.PicoohmCentimeter: return (_value/100) * 1e-12d;
-                case ElectricResistivityUnit.PicoohmMeter: return (_value) * 1e-12d;
+                case ElectricResistivityUnit.KiloohmCentimeter: return (Value/100) * 1e3d;
+                case ElectricResistivityUnit.KiloohmMeter: return (Value) * 1e3d;
+                case ElectricResistivityUnit.MegaohmCentimeter: return (Value/100) * 1e6d;
+                case ElectricResistivityUnit.MegaohmMeter: return (Value) * 1e6d;
+                case ElectricResistivityUnit.MicroohmCentimeter: return (Value/100) * 1e-6d;
+                case ElectricResistivityUnit.MicroohmMeter: return (Value) * 1e-6d;
+                case ElectricResistivityUnit.MilliohmCentimeter: return (Value/100) * 1e-3d;
+                case ElectricResistivityUnit.MilliohmMeter: return (Value) * 1e-3d;
+                case ElectricResistivityUnit.NanoohmCentimeter: return (Value/100) * 1e-9d;
+                case ElectricResistivityUnit.NanoohmMeter: return (Value) * 1e-9d;
+                case ElectricResistivityUnit.OhmCentimeter: return Value/100;
+                case ElectricResistivityUnit.OhmMeter: return Value;
+                case ElectricResistivityUnit.PicoohmCentimeter: return (Value/100) * 1e-12d;
+                case ElectricResistivityUnit.PicoohmMeter: return (Value) * 1e-12d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -860,16 +858,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricResistivity ToBaseUnit()
+        internal ElectricResistivity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricResistivity(baseUnitValue, BaseUnit);
+            return new ElectricResistivity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricResistivityUnit unit)
+        private T GetValueAs(ElectricResistivityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -985,57 +983,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricResistivity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricResistivity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricResistivity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricResistivity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricResistivity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricResistivity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1045,33 +1043,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricResistivity))
+            if(conversionType == typeof(ElectricResistivity<T>))
                 return this;
             else if(conversionType == typeof(ElectricResistivityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricResistivity.QuantityType;
+                return ElectricResistivity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricResistivity.Info;
+                return ElectricResistivity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricResistivity.BaseDimensions;
+                return ElectricResistivity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricResistivity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricResistivity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
index 4e3b431a64..c3b62a2ad1 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Charge_density
     /// </remarks>
-    public partial struct ElectricSurfaceChargeDensity : IQuantity<ElectricSurfaceChargeDensityUnit>, IEquatable<ElectricSurfaceChargeDensity>, IComparable, IComparable<ElectricSurfaceChargeDensity>, IConvertible, IFormattable
+    public partial struct ElectricSurfaceChargeDensity<T> : IQuantityT<ElectricSurfaceChargeDensityUnit, T>, IEquatable<ElectricSurfaceChargeDensity<T>>, IComparable, IComparable<ElectricSurfaceChargeDensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static ElectricSurfaceChargeDensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ElectricSurfaceChargeDensity(double value, ElectricSurfaceChargeDensityUnit unit)
+        public ElectricSurfaceChargeDensity(T value, ElectricSurfaceChargeDensityUnit unit)
         {
             if(unit == ElectricSurfaceChargeDensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public ElectricSurfaceChargeDensity(double value, ElectricSurfaceChargeDensityUn
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
+        public ElectricSurfaceChargeDensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ElectricSurfaceChargeDensity, which is CoulombPerSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="ElectricSurfaceChargeDensity{T}" />, which is CoulombPerSquareMeter. All conversions go via this value.
         /// </summary>
         public static ElectricSurfaceChargeDensityUnit BaseUnit { get; } = ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of ElectricSurfaceChargeDensity
+        /// Represents the largest possible value of <see cref="ElectricSurfaceChargeDensity{T}" />
         /// </summary>
-        public static ElectricSurfaceChargeDensity MaxValue { get; } = new ElectricSurfaceChargeDensity(double.MaxValue, BaseUnit);
+        public static ElectricSurfaceChargeDensity<T> MaxValue { get; } = new ElectricSurfaceChargeDensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ElectricSurfaceChargeDensity
+        /// Represents the smallest possible value of <see cref="ElectricSurfaceChargeDensity{T}" />
         /// </summary>
-        public static ElectricSurfaceChargeDensity MinValue { get; } = new ElectricSurfaceChargeDensity(double.MinValue, BaseUnit);
+        public static ElectricSurfaceChargeDensity<T> MinValue { get; } = new ElectricSurfaceChargeDensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ElectricSurfaceChargeDensity;
 
         /// <summary>
-        ///     All units of measurement for the ElectricSurfaceChargeDensity quantity.
+        ///     All units of measurement for the <see cref="ElectricSurfaceChargeDensity{T}" /> quantity.
         /// </summary>
         public static ElectricSurfaceChargeDensityUnit[] Units { get; } = Enum.GetValues(typeof(ElectricSurfaceChargeDensityUnit)).Cast<ElectricSurfaceChargeDensityUnit>().Except(new ElectricSurfaceChargeDensityUnit[]{ ElectricSurfaceChargeDensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit CoulombPerSquareMeter.
         /// </summary>
-        public static ElectricSurfaceChargeDensity Zero { get; } = new ElectricSurfaceChargeDensity(0, BaseUnit);
+        public static ElectricSurfaceChargeDensity<T> Zero { get; } = new ElectricSurfaceChargeDensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,31 +158,31 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ElectricSurfaceChargeDensity.QuantityType;
+        public QuantityType Type => ElectricSurfaceChargeDensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ElectricSurfaceChargeDensity.BaseDimensions;
+        public BaseDimensions Dimensions => ElectricSurfaceChargeDensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ElectricSurfaceChargeDensity in CoulombsPerSquareCentimeter.
+        ///     Get <see cref="ElectricSurfaceChargeDensity{T}" /> in CoulombsPerSquareCentimeter.
         /// </summary>
-        public double CoulombsPerSquareCentimeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
+        public T CoulombsPerSquareCentimeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
 
         /// <summary>
-        ///     Get ElectricSurfaceChargeDensity in CoulombsPerSquareInch.
+        ///     Get <see cref="ElectricSurfaceChargeDensity{T}" /> in CoulombsPerSquareInch.
         /// </summary>
-        public double CoulombsPerSquareInch => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
+        public T CoulombsPerSquareInch => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
 
         /// <summary>
-        ///     Get ElectricSurfaceChargeDensity in CoulombsPerSquareMeter.
+        ///     Get <see cref="ElectricSurfaceChargeDensity{T}" /> in CoulombsPerSquareMeter.
         /// </summary>
-        public double CoulombsPerSquareMeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
+        public T CoulombsPerSquareMeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
 
         #endregion
 
@@ -216,42 +214,39 @@ public static string GetAbbreviation(ElectricSurfaceChargeDensityUnit unit, IFor
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ElectricSurfaceChargeDensity from CoulombsPerSquareCentimeter.
+        ///     Get <see cref="ElectricSurfaceChargeDensity{T}" /> from CoulombsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(QuantityValue coulombspersquarecentimeter)
+        public static ElectricSurfaceChargeDensity<T> FromCoulombsPerSquareCentimeter(T coulombspersquarecentimeter)
         {
-            double value = (double) coulombspersquarecentimeter;
-            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
+            return new ElectricSurfaceChargeDensity<T>(coulombspersquarecentimeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get ElectricSurfaceChargeDensity from CoulombsPerSquareInch.
+        ///     Get <see cref="ElectricSurfaceChargeDensity{T}" /> from CoulombsPerSquareInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(QuantityValue coulombspersquareinch)
+        public static ElectricSurfaceChargeDensity<T> FromCoulombsPerSquareInch(T coulombspersquareinch)
         {
-            double value = (double) coulombspersquareinch;
-            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
+            return new ElectricSurfaceChargeDensity<T>(coulombspersquareinch, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
         }
         /// <summary>
-        ///     Get ElectricSurfaceChargeDensity from CoulombsPerSquareMeter.
+        ///     Get <see cref="ElectricSurfaceChargeDensity{T}" /> from CoulombsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(QuantityValue coulombspersquaremeter)
+        public static ElectricSurfaceChargeDensity<T> FromCoulombsPerSquareMeter(T coulombspersquaremeter)
         {
-            double value = (double) coulombspersquaremeter;
-            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
+            return new ElectricSurfaceChargeDensity<T>(coulombspersquaremeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricSurfaceChargeDensityUnit" /> to <see cref="ElectricSurfaceChargeDensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="ElectricSurfaceChargeDensityUnit" /> to <see cref="ElectricSurfaceChargeDensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricSurfaceChargeDensity unit value.</returns>
-        public static ElectricSurfaceChargeDensity From(QuantityValue value, ElectricSurfaceChargeDensityUnit fromUnit)
+        /// <returns><see cref="ElectricSurfaceChargeDensity{T}" /> unit value.</returns>
+        public static ElectricSurfaceChargeDensity<T> From(T value, ElectricSurfaceChargeDensityUnit fromUnit)
         {
-            return new ElectricSurfaceChargeDensity((double)value, fromUnit);
+            return new ElectricSurfaceChargeDensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -280,7 +275,7 @@ public static ElectricSurfaceChargeDensity From(QuantityValue value, ElectricSur
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ElectricSurfaceChargeDensity Parse(string str)
+        public static ElectricSurfaceChargeDensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -308,9 +303,9 @@ public static ElectricSurfaceChargeDensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ElectricSurfaceChargeDensity Parse(string str, IFormatProvider? provider)
+        public static ElectricSurfaceChargeDensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>(
+            return QuantityParser.Default.Parse<T, ElectricSurfaceChargeDensity<T>, ElectricSurfaceChargeDensityUnit>(
                 str,
                 provider,
                 From);
@@ -324,7 +319,7 @@ public static ElectricSurfaceChargeDensity Parse(string str, IFormatProvider? pr
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ElectricSurfaceChargeDensity result)
+        public static bool TryParse(string? str, out ElectricSurfaceChargeDensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -339,9 +334,9 @@ public static bool TryParse(string? str, out ElectricSurfaceChargeDensity result
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricSurfaceChargeDensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ElectricSurfaceChargeDensity<T> result)
         {
-            return QuantityParser.Default.TryParse<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>(
+            return QuantityParser.Default.TryParse<T, ElectricSurfaceChargeDensity<T>, ElectricSurfaceChargeDensityUnit>(
                 str,
                 provider,
                 From,
@@ -403,45 +398,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ElectricSurfaceChargeDensity operator -(ElectricSurfaceChargeDensity right)
+        public static ElectricSurfaceChargeDensity<T> operator -(ElectricSurfaceChargeDensity<T> right)
         {
-            return new ElectricSurfaceChargeDensity(-right.Value, right.Unit);
+            return new ElectricSurfaceChargeDensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from adding two <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static ElectricSurfaceChargeDensity operator +(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        /// <summary>Get <see cref="ElectricSurfaceChargeDensity{T}"/> from adding two <see cref="ElectricSurfaceChargeDensity{T}"/>.</summary>
+        public static ElectricSurfaceChargeDensity<T> operator +(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
-            return new ElectricSurfaceChargeDensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricSurfaceChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from subtracting two <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static ElectricSurfaceChargeDensity operator -(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        /// <summary>Get <see cref="ElectricSurfaceChargeDensity{T}"/> from subtracting two <see cref="ElectricSurfaceChargeDensity{T}"/>.</summary>
+        public static ElectricSurfaceChargeDensity<T> operator -(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
-            return new ElectricSurfaceChargeDensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ElectricSurfaceChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from multiplying value and <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static ElectricSurfaceChargeDensity operator *(double left, ElectricSurfaceChargeDensity right)
+        /// <summary>Get <see cref="ElectricSurfaceChargeDensity{T}"/> from multiplying value and <see cref="ElectricSurfaceChargeDensity{T}"/>.</summary>
+        public static ElectricSurfaceChargeDensity<T> operator *(T left, ElectricSurfaceChargeDensity<T> right)
         {
-            return new ElectricSurfaceChargeDensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ElectricSurfaceChargeDensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from multiplying value and <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static ElectricSurfaceChargeDensity operator *(ElectricSurfaceChargeDensity left, double right)
+        /// <summary>Get <see cref="ElectricSurfaceChargeDensity{T}"/> from multiplying value and <see cref="ElectricSurfaceChargeDensity{T}"/>.</summary>
+        public static ElectricSurfaceChargeDensity<T> operator *(ElectricSurfaceChargeDensity<T> left, T right)
         {
-            return new ElectricSurfaceChargeDensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ElectricSurfaceChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from dividing <see cref="ElectricSurfaceChargeDensity"/> by value.</summary>
-        public static ElectricSurfaceChargeDensity operator /(ElectricSurfaceChargeDensity left, double right)
+        /// <summary>Get <see cref="ElectricSurfaceChargeDensity{T}"/> from dividing <see cref="ElectricSurfaceChargeDensity{T}"/> by value.</summary>
+        public static ElectricSurfaceChargeDensity<T> operator /(ElectricSurfaceChargeDensity<T> left, T right)
         {
-            return new ElectricSurfaceChargeDensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ElectricSurfaceChargeDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ElectricSurfaceChargeDensity"/> by <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static double operator /(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        /// <summary>Get ratio value from dividing <see cref="ElectricSurfaceChargeDensity{T}"/> by <see cref="ElectricSurfaceChargeDensity{T}"/>.</summary>
+        public static T operator /(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
-            return left.CoulombsPerSquareMeter / right.CoulombsPerSquareMeter;
+            return CompiledLambdas.Divide(left.CoulombsPerSquareMeter, right.CoulombsPerSquareMeter);
         }
 
         #endregion
@@ -449,39 +449,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        public static bool operator <=(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        public static bool operator >=(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        public static bool operator <(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        public static bool operator >(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ElectricSurfaceChargeDensity<T> left, ElectricSurfaceChargeDensity<T> right)
         {
             return !(left == right);
         }
@@ -490,37 +490,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ElectricSurfaceChargeDensity objElectricSurfaceChargeDensity)) throw new ArgumentException("Expected type ElectricSurfaceChargeDensity.", nameof(obj));
+            if(!(obj is ElectricSurfaceChargeDensity<T> objElectricSurfaceChargeDensity)) throw new ArgumentException("Expected type ElectricSurfaceChargeDensity.", nameof(obj));
 
             return CompareTo(objElectricSurfaceChargeDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ElectricSurfaceChargeDensity other)
+        public int CompareTo(ElectricSurfaceChargeDensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ElectricSurfaceChargeDensity objElectricSurfaceChargeDensity))
+            if(obj is null || !(obj is ElectricSurfaceChargeDensity<T> objElectricSurfaceChargeDensity))
                 return false;
 
             return Equals(objElectricSurfaceChargeDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ElectricSurfaceChargeDensity other)
+        /// <remarks>Consider using <see cref="Equals(ElectricSurfaceChargeDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ElectricSurfaceChargeDensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ElectricSurfaceChargeDensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ElectricSurfaceChargeDensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -558,21 +558,19 @@ public bool Equals(ElectricSurfaceChargeDensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ElectricSurfaceChargeDensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ElectricSurfaceChargeDensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ElectricSurfaceChargeDensity.</returns>
+        /// <returns>A hash code for the current <see cref="ElectricSurfaceChargeDensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -586,17 +584,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricSurfaceChargeDensityUnit unit)
+        public T As(ElectricSurfaceChargeDensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -616,17 +614,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ElectricSurfaceChargeDensityUnit unitAsElectricSurfaceChargeDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSurfaceChargeDensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsElectricSurfaceChargeDensityUnit);
+            var asValue = As(unitAsElectricSurfaceChargeDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ElectricSurfaceChargeDensityUnit>.As(ElectricSurfaceChargeDensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ElectricSurfaceChargeDensity to another ElectricSurfaceChargeDensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ElectricSurfaceChargeDensity{T}" /> to another <see cref="ElectricSurfaceChargeDensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ElectricSurfaceChargeDensity with the specified unit.</returns>
-        public ElectricSurfaceChargeDensity ToUnit(ElectricSurfaceChargeDensityUnit unit)
+        /// <returns>A <see cref="ElectricSurfaceChargeDensity{T}" /> with the specified unit.</returns>
+        public ElectricSurfaceChargeDensity<T> ToUnit(ElectricSurfaceChargeDensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ElectricSurfaceChargeDensity(convertedValue, unit);
+            return new ElectricSurfaceChargeDensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -639,7 +642,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ElectricSurfaceChargeDensity ToUnit(UnitSystem unitSystem)
+        public ElectricSurfaceChargeDensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -659,21 +662,27 @@ public ElectricSurfaceChargeDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricSurfaceChargeDensityUnit> IQuantity<ElectricSurfaceChargeDensityUnit>.ToUnit(ElectricSurfaceChargeDensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricSurfaceChargeDensityUnit, T> IQuantityT<ElectricSurfaceChargeDensityUnit, T>.ToUnit(ElectricSurfaceChargeDensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ElectricSurfaceChargeDensityUnit> IQuantity<ElectricSurfaceChargeDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ElectricSurfaceChargeDensityUnit, T> IQuantityT<ElectricSurfaceChargeDensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter: return _value * 1.0e4;
-                case ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch: return _value * 1.5500031000062000e3;
-                case ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter: return _value;
+                case ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter: return Value * 1.0e4;
+                case ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch: return Value * 1.5500031000062000e3;
+                case ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -684,16 +693,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ElectricSurfaceChargeDensity ToBaseUnit()
+        internal ElectricSurfaceChargeDensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ElectricSurfaceChargeDensity(baseUnitValue, BaseUnit);
+            return new ElectricSurfaceChargeDensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ElectricSurfaceChargeDensityUnit unit)
+        private T GetValueAs(ElectricSurfaceChargeDensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -798,57 +807,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -858,33 +867,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ElectricSurfaceChargeDensity))
+            if(conversionType == typeof(ElectricSurfaceChargeDensity<T>))
                 return this;
             else if(conversionType == typeof(ElectricSurfaceChargeDensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ElectricSurfaceChargeDensity.QuantityType;
+                return ElectricSurfaceChargeDensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ElectricSurfaceChargeDensity.Info;
+                return ElectricSurfaceChargeDensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ElectricSurfaceChargeDensity.BaseDimensions;
+                return ElectricSurfaceChargeDensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ElectricSurfaceChargeDensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
index 6e9e2d05f8..fed655573c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The joule, symbol J, is a derived unit of energy, work, or amount of heat in the International System of Units. It is equal to the energy transferred (or work done) when applying a force of one newton through a distance of one metre (1 newton metre or N·m), or in passing an electric current of one ampere through a resistance of one ohm for one second. Many other units of energy are included. Please do not confuse this definition of the calorie with the one colloquially used by the food industry, the large calorie, which is equivalent to 1 kcal. Thermochemical definition of the calorie is used. For BTU, the IT definition is used.
     /// </summary>
-    public partial struct Energy : IQuantity<EnergyUnit>, IEquatable<Energy>, IComparable, IComparable<Energy>, IConvertible, IFormattable
+    public partial struct Energy<T> : IQuantityT<EnergyUnit, T>, IEquatable<Energy<T>>, IComparable, IComparable<Energy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -98,12 +94,12 @@ static Energy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Energy(double value, EnergyUnit unit)
+        public Energy(T value, EnergyUnit unit)
         {
             if(unit == EnergyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -115,14 +111,14 @@ public Energy(double value, EnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Energy(double value, UnitSystem unitSystem)
+        public Energy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -137,19 +133,19 @@ public Energy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Energy, which is Joule. All conversions go via this value.
+        ///     The base unit of <see cref="Energy{T}" />, which is Joule. All conversions go via this value.
         /// </summary>
         public static EnergyUnit BaseUnit { get; } = EnergyUnit.Joule;
 
         /// <summary>
-        /// Represents the largest possible value of Energy
+        /// Represents the largest possible value of <see cref="Energy{T}" />
         /// </summary>
-        public static Energy MaxValue { get; } = new Energy(double.MaxValue, BaseUnit);
+        public static Energy<T> MaxValue { get; } = new Energy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Energy
+        /// Represents the smallest possible value of <see cref="Energy{T}" />
         /// </summary>
-        public static Energy MinValue { get; } = new Energy(double.MinValue, BaseUnit);
+        public static Energy<T> MinValue { get; } = new Energy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -158,14 +154,14 @@ public Energy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Energy;
 
         /// <summary>
-        ///     All units of measurement for the Energy quantity.
+        ///     All units of measurement for the <see cref="Energy{T}" /> quantity.
         /// </summary>
         public static EnergyUnit[] Units { get; } = Enum.GetValues(typeof(EnergyUnit)).Cast<EnergyUnit>().Except(new EnergyUnit[]{ EnergyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Joule.
         /// </summary>
-        public static Energy Zero { get; } = new Energy(0, BaseUnit);
+        public static Energy<T> Zero { get; } = new Energy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -174,7 +170,9 @@ public Energy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -190,196 +188,196 @@ public Energy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Energy.QuantityType;
+        public QuantityType Type => Energy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Energy.BaseDimensions;
+        public BaseDimensions Dimensions => Energy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Energy in BritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> in BritishThermalUnits.
         /// </summary>
-        public double BritishThermalUnits => As(EnergyUnit.BritishThermalUnit);
+        public T BritishThermalUnits => As(EnergyUnit.BritishThermalUnit);
 
         /// <summary>
-        ///     Get Energy in Calories.
+        ///     Get <see cref="Energy{T}" /> in Calories.
         /// </summary>
-        public double Calories => As(EnergyUnit.Calorie);
+        public T Calories => As(EnergyUnit.Calorie);
 
         /// <summary>
-        ///     Get Energy in DecathermsEc.
+        ///     Get <see cref="Energy{T}" /> in DecathermsEc.
         /// </summary>
-        public double DecathermsEc => As(EnergyUnit.DecathermEc);
+        public T DecathermsEc => As(EnergyUnit.DecathermEc);
 
         /// <summary>
-        ///     Get Energy in DecathermsImperial.
+        ///     Get <see cref="Energy{T}" /> in DecathermsImperial.
         /// </summary>
-        public double DecathermsImperial => As(EnergyUnit.DecathermImperial);
+        public T DecathermsImperial => As(EnergyUnit.DecathermImperial);
 
         /// <summary>
-        ///     Get Energy in DecathermsUs.
+        ///     Get <see cref="Energy{T}" /> in DecathermsUs.
         /// </summary>
-        public double DecathermsUs => As(EnergyUnit.DecathermUs);
+        public T DecathermsUs => As(EnergyUnit.DecathermUs);
 
         /// <summary>
-        ///     Get Energy in ElectronVolts.
+        ///     Get <see cref="Energy{T}" /> in ElectronVolts.
         /// </summary>
-        public double ElectronVolts => As(EnergyUnit.ElectronVolt);
+        public T ElectronVolts => As(EnergyUnit.ElectronVolt);
 
         /// <summary>
-        ///     Get Energy in Ergs.
+        ///     Get <see cref="Energy{T}" /> in Ergs.
         /// </summary>
-        public double Ergs => As(EnergyUnit.Erg);
+        public T Ergs => As(EnergyUnit.Erg);
 
         /// <summary>
-        ///     Get Energy in FootPounds.
+        ///     Get <see cref="Energy{T}" /> in FootPounds.
         /// </summary>
-        public double FootPounds => As(EnergyUnit.FootPound);
+        public T FootPounds => As(EnergyUnit.FootPound);
 
         /// <summary>
-        ///     Get Energy in GigabritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> in GigabritishThermalUnits.
         /// </summary>
-        public double GigabritishThermalUnits => As(EnergyUnit.GigabritishThermalUnit);
+        public T GigabritishThermalUnits => As(EnergyUnit.GigabritishThermalUnit);
 
         /// <summary>
-        ///     Get Energy in GigaelectronVolts.
+        ///     Get <see cref="Energy{T}" /> in GigaelectronVolts.
         /// </summary>
-        public double GigaelectronVolts => As(EnergyUnit.GigaelectronVolt);
+        public T GigaelectronVolts => As(EnergyUnit.GigaelectronVolt);
 
         /// <summary>
-        ///     Get Energy in Gigajoules.
+        ///     Get <see cref="Energy{T}" /> in Gigajoules.
         /// </summary>
-        public double Gigajoules => As(EnergyUnit.Gigajoule);
+        public T Gigajoules => As(EnergyUnit.Gigajoule);
 
         /// <summary>
-        ///     Get Energy in GigawattDays.
+        ///     Get <see cref="Energy{T}" /> in GigawattDays.
         /// </summary>
-        public double GigawattDays => As(EnergyUnit.GigawattDay);
+        public T GigawattDays => As(EnergyUnit.GigawattDay);
 
         /// <summary>
-        ///     Get Energy in GigawattHours.
+        ///     Get <see cref="Energy{T}" /> in GigawattHours.
         /// </summary>
-        public double GigawattHours => As(EnergyUnit.GigawattHour);
+        public T GigawattHours => As(EnergyUnit.GigawattHour);
 
         /// <summary>
-        ///     Get Energy in HorsepowerHours.
+        ///     Get <see cref="Energy{T}" /> in HorsepowerHours.
         /// </summary>
-        public double HorsepowerHours => As(EnergyUnit.HorsepowerHour);
+        public T HorsepowerHours => As(EnergyUnit.HorsepowerHour);
 
         /// <summary>
-        ///     Get Energy in Joules.
+        ///     Get <see cref="Energy{T}" /> in Joules.
         /// </summary>
-        public double Joules => As(EnergyUnit.Joule);
+        public T Joules => As(EnergyUnit.Joule);
 
         /// <summary>
-        ///     Get Energy in KilobritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> in KilobritishThermalUnits.
         /// </summary>
-        public double KilobritishThermalUnits => As(EnergyUnit.KilobritishThermalUnit);
+        public T KilobritishThermalUnits => As(EnergyUnit.KilobritishThermalUnit);
 
         /// <summary>
-        ///     Get Energy in Kilocalories.
+        ///     Get <see cref="Energy{T}" /> in Kilocalories.
         /// </summary>
-        public double Kilocalories => As(EnergyUnit.Kilocalorie);
+        public T Kilocalories => As(EnergyUnit.Kilocalorie);
 
         /// <summary>
-        ///     Get Energy in KiloelectronVolts.
+        ///     Get <see cref="Energy{T}" /> in KiloelectronVolts.
         /// </summary>
-        public double KiloelectronVolts => As(EnergyUnit.KiloelectronVolt);
+        public T KiloelectronVolts => As(EnergyUnit.KiloelectronVolt);
 
         /// <summary>
-        ///     Get Energy in Kilojoules.
+        ///     Get <see cref="Energy{T}" /> in Kilojoules.
         /// </summary>
-        public double Kilojoules => As(EnergyUnit.Kilojoule);
+        public T Kilojoules => As(EnergyUnit.Kilojoule);
 
         /// <summary>
-        ///     Get Energy in KilowattDays.
+        ///     Get <see cref="Energy{T}" /> in KilowattDays.
         /// </summary>
-        public double KilowattDays => As(EnergyUnit.KilowattDay);
+        public T KilowattDays => As(EnergyUnit.KilowattDay);
 
         /// <summary>
-        ///     Get Energy in KilowattHours.
+        ///     Get <see cref="Energy{T}" /> in KilowattHours.
         /// </summary>
-        public double KilowattHours => As(EnergyUnit.KilowattHour);
+        public T KilowattHours => As(EnergyUnit.KilowattHour);
 
         /// <summary>
-        ///     Get Energy in MegabritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> in MegabritishThermalUnits.
         /// </summary>
-        public double MegabritishThermalUnits => As(EnergyUnit.MegabritishThermalUnit);
+        public T MegabritishThermalUnits => As(EnergyUnit.MegabritishThermalUnit);
 
         /// <summary>
-        ///     Get Energy in Megacalories.
+        ///     Get <see cref="Energy{T}" /> in Megacalories.
         /// </summary>
-        public double Megacalories => As(EnergyUnit.Megacalorie);
+        public T Megacalories => As(EnergyUnit.Megacalorie);
 
         /// <summary>
-        ///     Get Energy in MegaelectronVolts.
+        ///     Get <see cref="Energy{T}" /> in MegaelectronVolts.
         /// </summary>
-        public double MegaelectronVolts => As(EnergyUnit.MegaelectronVolt);
+        public T MegaelectronVolts => As(EnergyUnit.MegaelectronVolt);
 
         /// <summary>
-        ///     Get Energy in Megajoules.
+        ///     Get <see cref="Energy{T}" /> in Megajoules.
         /// </summary>
-        public double Megajoules => As(EnergyUnit.Megajoule);
+        public T Megajoules => As(EnergyUnit.Megajoule);
 
         /// <summary>
-        ///     Get Energy in MegawattDays.
+        ///     Get <see cref="Energy{T}" /> in MegawattDays.
         /// </summary>
-        public double MegawattDays => As(EnergyUnit.MegawattDay);
+        public T MegawattDays => As(EnergyUnit.MegawattDay);
 
         /// <summary>
-        ///     Get Energy in MegawattHours.
+        ///     Get <see cref="Energy{T}" /> in MegawattHours.
         /// </summary>
-        public double MegawattHours => As(EnergyUnit.MegawattHour);
+        public T MegawattHours => As(EnergyUnit.MegawattHour);
 
         /// <summary>
-        ///     Get Energy in Millijoules.
+        ///     Get <see cref="Energy{T}" /> in Millijoules.
         /// </summary>
-        public double Millijoules => As(EnergyUnit.Millijoule);
+        public T Millijoules => As(EnergyUnit.Millijoule);
 
         /// <summary>
-        ///     Get Energy in TeraelectronVolts.
+        ///     Get <see cref="Energy{T}" /> in TeraelectronVolts.
         /// </summary>
-        public double TeraelectronVolts => As(EnergyUnit.TeraelectronVolt);
+        public T TeraelectronVolts => As(EnergyUnit.TeraelectronVolt);
 
         /// <summary>
-        ///     Get Energy in TerawattDays.
+        ///     Get <see cref="Energy{T}" /> in TerawattDays.
         /// </summary>
-        public double TerawattDays => As(EnergyUnit.TerawattDay);
+        public T TerawattDays => As(EnergyUnit.TerawattDay);
 
         /// <summary>
-        ///     Get Energy in TerawattHours.
+        ///     Get <see cref="Energy{T}" /> in TerawattHours.
         /// </summary>
-        public double TerawattHours => As(EnergyUnit.TerawattHour);
+        public T TerawattHours => As(EnergyUnit.TerawattHour);
 
         /// <summary>
-        ///     Get Energy in ThermsEc.
+        ///     Get <see cref="Energy{T}" /> in ThermsEc.
         /// </summary>
-        public double ThermsEc => As(EnergyUnit.ThermEc);
+        public T ThermsEc => As(EnergyUnit.ThermEc);
 
         /// <summary>
-        ///     Get Energy in ThermsImperial.
+        ///     Get <see cref="Energy{T}" /> in ThermsImperial.
         /// </summary>
-        public double ThermsImperial => As(EnergyUnit.ThermImperial);
+        public T ThermsImperial => As(EnergyUnit.ThermImperial);
 
         /// <summary>
-        ///     Get Energy in ThermsUs.
+        ///     Get <see cref="Energy{T}" /> in ThermsUs.
         /// </summary>
-        public double ThermsUs => As(EnergyUnit.ThermUs);
+        public T ThermsUs => As(EnergyUnit.ThermUs);
 
         /// <summary>
-        ///     Get Energy in WattDays.
+        ///     Get <see cref="Energy{T}" /> in WattDays.
         /// </summary>
-        public double WattDays => As(EnergyUnit.WattDay);
+        public T WattDays => As(EnergyUnit.WattDay);
 
         /// <summary>
-        ///     Get Energy in WattHours.
+        ///     Get <see cref="Energy{T}" /> in WattHours.
         /// </summary>
-        public double WattHours => As(EnergyUnit.WattHour);
+        public T WattHours => As(EnergyUnit.WattHour);
 
         #endregion
 
@@ -411,339 +409,303 @@ public static string GetAbbreviation(EnergyUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Energy from BritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> from BritishThermalUnits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromBritishThermalUnits(QuantityValue britishthermalunits)
+        public static Energy<T> FromBritishThermalUnits(T britishthermalunits)
         {
-            double value = (double) britishthermalunits;
-            return new Energy(value, EnergyUnit.BritishThermalUnit);
+            return new Energy<T>(britishthermalunits, EnergyUnit.BritishThermalUnit);
         }
         /// <summary>
-        ///     Get Energy from Calories.
+        ///     Get <see cref="Energy{T}" /> from Calories.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromCalories(QuantityValue calories)
+        public static Energy<T> FromCalories(T calories)
         {
-            double value = (double) calories;
-            return new Energy(value, EnergyUnit.Calorie);
+            return new Energy<T>(calories, EnergyUnit.Calorie);
         }
         /// <summary>
-        ///     Get Energy from DecathermsEc.
+        ///     Get <see cref="Energy{T}" /> from DecathermsEc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsEc(QuantityValue decathermsec)
+        public static Energy<T> FromDecathermsEc(T decathermsec)
         {
-            double value = (double) decathermsec;
-            return new Energy(value, EnergyUnit.DecathermEc);
+            return new Energy<T>(decathermsec, EnergyUnit.DecathermEc);
         }
         /// <summary>
-        ///     Get Energy from DecathermsImperial.
+        ///     Get <see cref="Energy{T}" /> from DecathermsImperial.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsImperial(QuantityValue decathermsimperial)
+        public static Energy<T> FromDecathermsImperial(T decathermsimperial)
         {
-            double value = (double) decathermsimperial;
-            return new Energy(value, EnergyUnit.DecathermImperial);
+            return new Energy<T>(decathermsimperial, EnergyUnit.DecathermImperial);
         }
         /// <summary>
-        ///     Get Energy from DecathermsUs.
+        ///     Get <see cref="Energy{T}" /> from DecathermsUs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsUs(QuantityValue decathermsus)
+        public static Energy<T> FromDecathermsUs(T decathermsus)
         {
-            double value = (double) decathermsus;
-            return new Energy(value, EnergyUnit.DecathermUs);
+            return new Energy<T>(decathermsus, EnergyUnit.DecathermUs);
         }
         /// <summary>
-        ///     Get Energy from ElectronVolts.
+        ///     Get <see cref="Energy{T}" /> from ElectronVolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromElectronVolts(QuantityValue electronvolts)
+        public static Energy<T> FromElectronVolts(T electronvolts)
         {
-            double value = (double) electronvolts;
-            return new Energy(value, EnergyUnit.ElectronVolt);
+            return new Energy<T>(electronvolts, EnergyUnit.ElectronVolt);
         }
         /// <summary>
-        ///     Get Energy from Ergs.
+        ///     Get <see cref="Energy{T}" /> from Ergs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromErgs(QuantityValue ergs)
+        public static Energy<T> FromErgs(T ergs)
         {
-            double value = (double) ergs;
-            return new Energy(value, EnergyUnit.Erg);
+            return new Energy<T>(ergs, EnergyUnit.Erg);
         }
         /// <summary>
-        ///     Get Energy from FootPounds.
+        ///     Get <see cref="Energy{T}" /> from FootPounds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromFootPounds(QuantityValue footpounds)
+        public static Energy<T> FromFootPounds(T footpounds)
         {
-            double value = (double) footpounds;
-            return new Energy(value, EnergyUnit.FootPound);
+            return new Energy<T>(footpounds, EnergyUnit.FootPound);
         }
         /// <summary>
-        ///     Get Energy from GigabritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> from GigabritishThermalUnits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigabritishThermalUnits(QuantityValue gigabritishthermalunits)
+        public static Energy<T> FromGigabritishThermalUnits(T gigabritishthermalunits)
         {
-            double value = (double) gigabritishthermalunits;
-            return new Energy(value, EnergyUnit.GigabritishThermalUnit);
+            return new Energy<T>(gigabritishthermalunits, EnergyUnit.GigabritishThermalUnit);
         }
         /// <summary>
-        ///     Get Energy from GigaelectronVolts.
+        ///     Get <see cref="Energy{T}" /> from GigaelectronVolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigaelectronVolts(QuantityValue gigaelectronvolts)
+        public static Energy<T> FromGigaelectronVolts(T gigaelectronvolts)
         {
-            double value = (double) gigaelectronvolts;
-            return new Energy(value, EnergyUnit.GigaelectronVolt);
+            return new Energy<T>(gigaelectronvolts, EnergyUnit.GigaelectronVolt);
         }
         /// <summary>
-        ///     Get Energy from Gigajoules.
+        ///     Get <see cref="Energy{T}" /> from Gigajoules.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigajoules(QuantityValue gigajoules)
+        public static Energy<T> FromGigajoules(T gigajoules)
         {
-            double value = (double) gigajoules;
-            return new Energy(value, EnergyUnit.Gigajoule);
+            return new Energy<T>(gigajoules, EnergyUnit.Gigajoule);
         }
         /// <summary>
-        ///     Get Energy from GigawattDays.
+        ///     Get <see cref="Energy{T}" /> from GigawattDays.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigawattDays(QuantityValue gigawattdays)
+        public static Energy<T> FromGigawattDays(T gigawattdays)
         {
-            double value = (double) gigawattdays;
-            return new Energy(value, EnergyUnit.GigawattDay);
+            return new Energy<T>(gigawattdays, EnergyUnit.GigawattDay);
         }
         /// <summary>
-        ///     Get Energy from GigawattHours.
+        ///     Get <see cref="Energy{T}" /> from GigawattHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigawattHours(QuantityValue gigawatthours)
+        public static Energy<T> FromGigawattHours(T gigawatthours)
         {
-            double value = (double) gigawatthours;
-            return new Energy(value, EnergyUnit.GigawattHour);
+            return new Energy<T>(gigawatthours, EnergyUnit.GigawattHour);
         }
         /// <summary>
-        ///     Get Energy from HorsepowerHours.
+        ///     Get <see cref="Energy{T}" /> from HorsepowerHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromHorsepowerHours(QuantityValue horsepowerhours)
+        public static Energy<T> FromHorsepowerHours(T horsepowerhours)
         {
-            double value = (double) horsepowerhours;
-            return new Energy(value, EnergyUnit.HorsepowerHour);
+            return new Energy<T>(horsepowerhours, EnergyUnit.HorsepowerHour);
         }
         /// <summary>
-        ///     Get Energy from Joules.
+        ///     Get <see cref="Energy{T}" /> from Joules.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromJoules(QuantityValue joules)
+        public static Energy<T> FromJoules(T joules)
         {
-            double value = (double) joules;
-            return new Energy(value, EnergyUnit.Joule);
+            return new Energy<T>(joules, EnergyUnit.Joule);
         }
         /// <summary>
-        ///     Get Energy from KilobritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> from KilobritishThermalUnits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilobritishThermalUnits(QuantityValue kilobritishthermalunits)
+        public static Energy<T> FromKilobritishThermalUnits(T kilobritishthermalunits)
         {
-            double value = (double) kilobritishthermalunits;
-            return new Energy(value, EnergyUnit.KilobritishThermalUnit);
+            return new Energy<T>(kilobritishthermalunits, EnergyUnit.KilobritishThermalUnit);
         }
         /// <summary>
-        ///     Get Energy from Kilocalories.
+        ///     Get <see cref="Energy{T}" /> from Kilocalories.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilocalories(QuantityValue kilocalories)
+        public static Energy<T> FromKilocalories(T kilocalories)
         {
-            double value = (double) kilocalories;
-            return new Energy(value, EnergyUnit.Kilocalorie);
+            return new Energy<T>(kilocalories, EnergyUnit.Kilocalorie);
         }
         /// <summary>
-        ///     Get Energy from KiloelectronVolts.
+        ///     Get <see cref="Energy{T}" /> from KiloelectronVolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKiloelectronVolts(QuantityValue kiloelectronvolts)
+        public static Energy<T> FromKiloelectronVolts(T kiloelectronvolts)
         {
-            double value = (double) kiloelectronvolts;
-            return new Energy(value, EnergyUnit.KiloelectronVolt);
+            return new Energy<T>(kiloelectronvolts, EnergyUnit.KiloelectronVolt);
         }
         /// <summary>
-        ///     Get Energy from Kilojoules.
+        ///     Get <see cref="Energy{T}" /> from Kilojoules.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilojoules(QuantityValue kilojoules)
+        public static Energy<T> FromKilojoules(T kilojoules)
         {
-            double value = (double) kilojoules;
-            return new Energy(value, EnergyUnit.Kilojoule);
+            return new Energy<T>(kilojoules, EnergyUnit.Kilojoule);
         }
         /// <summary>
-        ///     Get Energy from KilowattDays.
+        ///     Get <see cref="Energy{T}" /> from KilowattDays.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilowattDays(QuantityValue kilowattdays)
+        public static Energy<T> FromKilowattDays(T kilowattdays)
         {
-            double value = (double) kilowattdays;
-            return new Energy(value, EnergyUnit.KilowattDay);
+            return new Energy<T>(kilowattdays, EnergyUnit.KilowattDay);
         }
         /// <summary>
-        ///     Get Energy from KilowattHours.
+        ///     Get <see cref="Energy{T}" /> from KilowattHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilowattHours(QuantityValue kilowatthours)
+        public static Energy<T> FromKilowattHours(T kilowatthours)
         {
-            double value = (double) kilowatthours;
-            return new Energy(value, EnergyUnit.KilowattHour);
+            return new Energy<T>(kilowatthours, EnergyUnit.KilowattHour);
         }
         /// <summary>
-        ///     Get Energy from MegabritishThermalUnits.
+        ///     Get <see cref="Energy{T}" /> from MegabritishThermalUnits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegabritishThermalUnits(QuantityValue megabritishthermalunits)
+        public static Energy<T> FromMegabritishThermalUnits(T megabritishthermalunits)
         {
-            double value = (double) megabritishthermalunits;
-            return new Energy(value, EnergyUnit.MegabritishThermalUnit);
+            return new Energy<T>(megabritishthermalunits, EnergyUnit.MegabritishThermalUnit);
         }
         /// <summary>
-        ///     Get Energy from Megacalories.
+        ///     Get <see cref="Energy{T}" /> from Megacalories.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegacalories(QuantityValue megacalories)
+        public static Energy<T> FromMegacalories(T megacalories)
         {
-            double value = (double) megacalories;
-            return new Energy(value, EnergyUnit.Megacalorie);
+            return new Energy<T>(megacalories, EnergyUnit.Megacalorie);
         }
         /// <summary>
-        ///     Get Energy from MegaelectronVolts.
+        ///     Get <see cref="Energy{T}" /> from MegaelectronVolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegaelectronVolts(QuantityValue megaelectronvolts)
+        public static Energy<T> FromMegaelectronVolts(T megaelectronvolts)
         {
-            double value = (double) megaelectronvolts;
-            return new Energy(value, EnergyUnit.MegaelectronVolt);
+            return new Energy<T>(megaelectronvolts, EnergyUnit.MegaelectronVolt);
         }
         /// <summary>
-        ///     Get Energy from Megajoules.
+        ///     Get <see cref="Energy{T}" /> from Megajoules.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegajoules(QuantityValue megajoules)
+        public static Energy<T> FromMegajoules(T megajoules)
         {
-            double value = (double) megajoules;
-            return new Energy(value, EnergyUnit.Megajoule);
+            return new Energy<T>(megajoules, EnergyUnit.Megajoule);
         }
         /// <summary>
-        ///     Get Energy from MegawattDays.
+        ///     Get <see cref="Energy{T}" /> from MegawattDays.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegawattDays(QuantityValue megawattdays)
+        public static Energy<T> FromMegawattDays(T megawattdays)
         {
-            double value = (double) megawattdays;
-            return new Energy(value, EnergyUnit.MegawattDay);
+            return new Energy<T>(megawattdays, EnergyUnit.MegawattDay);
         }
         /// <summary>
-        ///     Get Energy from MegawattHours.
+        ///     Get <see cref="Energy{T}" /> from MegawattHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegawattHours(QuantityValue megawatthours)
+        public static Energy<T> FromMegawattHours(T megawatthours)
         {
-            double value = (double) megawatthours;
-            return new Energy(value, EnergyUnit.MegawattHour);
+            return new Energy<T>(megawatthours, EnergyUnit.MegawattHour);
         }
         /// <summary>
-        ///     Get Energy from Millijoules.
+        ///     Get <see cref="Energy{T}" /> from Millijoules.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMillijoules(QuantityValue millijoules)
+        public static Energy<T> FromMillijoules(T millijoules)
         {
-            double value = (double) millijoules;
-            return new Energy(value, EnergyUnit.Millijoule);
+            return new Energy<T>(millijoules, EnergyUnit.Millijoule);
         }
         /// <summary>
-        ///     Get Energy from TeraelectronVolts.
+        ///     Get <see cref="Energy{T}" /> from TeraelectronVolts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTeraelectronVolts(QuantityValue teraelectronvolts)
+        public static Energy<T> FromTeraelectronVolts(T teraelectronvolts)
         {
-            double value = (double) teraelectronvolts;
-            return new Energy(value, EnergyUnit.TeraelectronVolt);
+            return new Energy<T>(teraelectronvolts, EnergyUnit.TeraelectronVolt);
         }
         /// <summary>
-        ///     Get Energy from TerawattDays.
+        ///     Get <see cref="Energy{T}" /> from TerawattDays.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerawattDays(QuantityValue terawattdays)
+        public static Energy<T> FromTerawattDays(T terawattdays)
         {
-            double value = (double) terawattdays;
-            return new Energy(value, EnergyUnit.TerawattDay);
+            return new Energy<T>(terawattdays, EnergyUnit.TerawattDay);
         }
         /// <summary>
-        ///     Get Energy from TerawattHours.
+        ///     Get <see cref="Energy{T}" /> from TerawattHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerawattHours(QuantityValue terawatthours)
+        public static Energy<T> FromTerawattHours(T terawatthours)
         {
-            double value = (double) terawatthours;
-            return new Energy(value, EnergyUnit.TerawattHour);
+            return new Energy<T>(terawatthours, EnergyUnit.TerawattHour);
         }
         /// <summary>
-        ///     Get Energy from ThermsEc.
+        ///     Get <see cref="Energy{T}" /> from ThermsEc.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsEc(QuantityValue thermsec)
+        public static Energy<T> FromThermsEc(T thermsec)
         {
-            double value = (double) thermsec;
-            return new Energy(value, EnergyUnit.ThermEc);
+            return new Energy<T>(thermsec, EnergyUnit.ThermEc);
         }
         /// <summary>
-        ///     Get Energy from ThermsImperial.
+        ///     Get <see cref="Energy{T}" /> from ThermsImperial.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsImperial(QuantityValue thermsimperial)
+        public static Energy<T> FromThermsImperial(T thermsimperial)
         {
-            double value = (double) thermsimperial;
-            return new Energy(value, EnergyUnit.ThermImperial);
+            return new Energy<T>(thermsimperial, EnergyUnit.ThermImperial);
         }
         /// <summary>
-        ///     Get Energy from ThermsUs.
+        ///     Get <see cref="Energy{T}" /> from ThermsUs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsUs(QuantityValue thermsus)
+        public static Energy<T> FromThermsUs(T thermsus)
         {
-            double value = (double) thermsus;
-            return new Energy(value, EnergyUnit.ThermUs);
+            return new Energy<T>(thermsus, EnergyUnit.ThermUs);
         }
         /// <summary>
-        ///     Get Energy from WattDays.
+        ///     Get <see cref="Energy{T}" /> from WattDays.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromWattDays(QuantityValue wattdays)
+        public static Energy<T> FromWattDays(T wattdays)
         {
-            double value = (double) wattdays;
-            return new Energy(value, EnergyUnit.WattDay);
+            return new Energy<T>(wattdays, EnergyUnit.WattDay);
         }
         /// <summary>
-        ///     Get Energy from WattHours.
+        ///     Get <see cref="Energy{T}" /> from WattHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromWattHours(QuantityValue watthours)
+        public static Energy<T> FromWattHours(T watthours)
         {
-            double value = (double) watthours;
-            return new Energy(value, EnergyUnit.WattHour);
+            return new Energy<T>(watthours, EnergyUnit.WattHour);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="EnergyUnit" /> to <see cref="Energy" />.
+        ///     Dynamically convert from value and unit enum <see cref="EnergyUnit" /> to <see cref="Energy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Energy unit value.</returns>
-        public static Energy From(QuantityValue value, EnergyUnit fromUnit)
+        /// <returns><see cref="Energy{T}" /> unit value.</returns>
+        public static Energy<T> From(T value, EnergyUnit fromUnit)
         {
-            return new Energy((double)value, fromUnit);
+            return new Energy<T>(value, fromUnit);
         }
 
         #endregion
@@ -772,7 +734,7 @@ public static Energy From(QuantityValue value, EnergyUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Energy Parse(string str)
+        public static Energy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -800,9 +762,9 @@ public static Energy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Energy Parse(string str, IFormatProvider? provider)
+        public static Energy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Energy, EnergyUnit>(
+            return QuantityParser.Default.Parse<T, Energy<T>, EnergyUnit>(
                 str,
                 provider,
                 From);
@@ -816,7 +778,7 @@ public static Energy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Energy result)
+        public static bool TryParse(string? str, out Energy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -831,9 +793,9 @@ public static bool TryParse(string? str, out Energy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Energy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Energy<T> result)
         {
-            return QuantityParser.Default.TryParse<Energy, EnergyUnit>(
+            return QuantityParser.Default.TryParse<T, Energy<T>, EnergyUnit>(
                 str,
                 provider,
                 From,
@@ -895,45 +857,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Energ
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Energy operator -(Energy right)
+        public static Energy<T> operator -(Energy<T> right)
         {
-            return new Energy(-right.Value, right.Unit);
+            return new Energy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Energy"/> from adding two <see cref="Energy"/>.</summary>
-        public static Energy operator +(Energy left, Energy right)
+        /// <summary>Get <see cref="Energy{T}"/> from adding two <see cref="Energy{T}"/>.</summary>
+        public static Energy<T> operator +(Energy<T> left, Energy<T> right)
         {
-            return new Energy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Energy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Energy"/> from subtracting two <see cref="Energy"/>.</summary>
-        public static Energy operator -(Energy left, Energy right)
+        /// <summary>Get <see cref="Energy{T}"/> from subtracting two <see cref="Energy{T}"/>.</summary>
+        public static Energy<T> operator -(Energy<T> left, Energy<T> right)
         {
-            return new Energy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Energy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Energy"/> from multiplying value and <see cref="Energy"/>.</summary>
-        public static Energy operator *(double left, Energy right)
+        /// <summary>Get <see cref="Energy{T}"/> from multiplying value and <see cref="Energy{T}"/>.</summary>
+        public static Energy<T> operator *(T left, Energy<T> right)
         {
-            return new Energy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Energy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Energy"/> from multiplying value and <see cref="Energy"/>.</summary>
-        public static Energy operator *(Energy left, double right)
+        /// <summary>Get <see cref="Energy{T}"/> from multiplying value and <see cref="Energy{T}"/>.</summary>
+        public static Energy<T> operator *(Energy<T> left, T right)
         {
-            return new Energy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Energy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Energy"/> from dividing <see cref="Energy"/> by value.</summary>
-        public static Energy operator /(Energy left, double right)
+        /// <summary>Get <see cref="Energy{T}"/> from dividing <see cref="Energy{T}"/> by value.</summary>
+        public static Energy<T> operator /(Energy<T> left, T right)
         {
-            return new Energy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Energy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Energy"/> by <see cref="Energy"/>.</summary>
-        public static double operator /(Energy left, Energy right)
+        /// <summary>Get ratio value from dividing <see cref="Energy{T}"/> by <see cref="Energy{T}"/>.</summary>
+        public static T operator /(Energy<T> left, Energy<T> right)
         {
-            return left.Joules / right.Joules;
+            return CompiledLambdas.Divide(left.Joules, right.Joules);
         }
 
         #endregion
@@ -941,39 +908,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Energ
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Energy left, Energy right)
+        public static bool operator <=(Energy<T> left, Energy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Energy left, Energy right)
+        public static bool operator >=(Energy<T> left, Energy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Energy left, Energy right)
+        public static bool operator <(Energy<T> left, Energy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Energy left, Energy right)
+        public static bool operator >(Energy<T> left, Energy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Energy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Energy left, Energy right)
+        /// <remarks>Consider using <see cref="Equals(Energy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Energy<T> left, Energy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Energy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Energy left, Energy right)
+        /// <remarks>Consider using <see cref="Equals(Energy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Energy<T> left, Energy<T> right)
         {
             return !(left == right);
         }
@@ -982,37 +949,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Energ
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Energy objEnergy)) throw new ArgumentException("Expected type Energy.", nameof(obj));
+            if(!(obj is Energy<T> objEnergy)) throw new ArgumentException("Expected type Energy.", nameof(obj));
 
             return CompareTo(objEnergy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Energy other)
+        public int CompareTo(Energy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Energy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Energy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Energy objEnergy))
+            if(obj is null || !(obj is Energy<T> objEnergy))
                 return false;
 
             return Equals(objEnergy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Energy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Energy other)
+        /// <remarks>Consider using <see cref="Equals(Energy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Energy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Energy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Energy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1050,21 +1017,19 @@ public bool Equals(Energy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Energy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Energy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Energy.</returns>
+        /// <returns>A hash code for the current <see cref="Energy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1078,17 +1043,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(EnergyUnit unit)
+        public T As(EnergyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1108,17 +1073,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is EnergyUnit unitAsEnergyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsEnergyUnit);
+            var asValue = As(unitAsEnergyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<EnergyUnit>.As(EnergyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Energy to another Energy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Energy{T}" /> to another <see cref="Energy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Energy with the specified unit.</returns>
-        public Energy ToUnit(EnergyUnit unit)
+        /// <returns>A <see cref="Energy{T}" /> with the specified unit.</returns>
+        public Energy<T> ToUnit(EnergyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Energy(convertedValue, unit);
+            return new Energy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1131,7 +1101,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Energy ToUnit(UnitSystem unitSystem)
+        public Energy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1151,54 +1121,60 @@ public Energy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<EnergyUnit> IQuantity<EnergyUnit>.ToUnit(EnergyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<EnergyUnit, T> IQuantityT<EnergyUnit, T>.ToUnit(EnergyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<EnergyUnit> IQuantity<EnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<EnergyUnit, T> IQuantityT<EnergyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case EnergyUnit.BritishThermalUnit: return _value*1055.05585262;
-                case EnergyUnit.Calorie: return _value*4.184;
-                case EnergyUnit.DecathermEc: return (_value*1.05505585262e8) * 1e1d;
-                case EnergyUnit.DecathermImperial: return (_value*1.05505585257348e8) * 1e1d;
-                case EnergyUnit.DecathermUs: return (_value*1.054804e8) * 1e1d;
-                case EnergyUnit.ElectronVolt: return _value*1.602176565e-19;
-                case EnergyUnit.Erg: return _value*1e-7;
-                case EnergyUnit.FootPound: return _value*1.355817948;
-                case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d;
-                case EnergyUnit.GigaelectronVolt: return (_value*1.602176565e-19) * 1e9d;
-                case EnergyUnit.Gigajoule: return (_value) * 1e9d;
-                case EnergyUnit.GigawattDay: return (_value*24*3600d) * 1e9d;
-                case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d;
-                case EnergyUnit.HorsepowerHour: return _value*2.6845195377e6;
-                case EnergyUnit.Joule: return _value;
-                case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d;
-                case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d;
-                case EnergyUnit.KiloelectronVolt: return (_value*1.602176565e-19) * 1e3d;
-                case EnergyUnit.Kilojoule: return (_value) * 1e3d;
-                case EnergyUnit.KilowattDay: return (_value*24*3600d) * 1e3d;
-                case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d;
-                case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d;
-                case EnergyUnit.Megacalorie: return (_value*4.184) * 1e6d;
-                case EnergyUnit.MegaelectronVolt: return (_value*1.602176565e-19) * 1e6d;
-                case EnergyUnit.Megajoule: return (_value) * 1e6d;
-                case EnergyUnit.MegawattDay: return (_value*24*3600d) * 1e6d;
-                case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d;
-                case EnergyUnit.Millijoule: return (_value) * 1e-3d;
-                case EnergyUnit.TeraelectronVolt: return (_value*1.602176565e-19) * 1e12d;
-                case EnergyUnit.TerawattDay: return (_value*24*3600d) * 1e12d;
-                case EnergyUnit.TerawattHour: return (_value*3600d) * 1e12d;
-                case EnergyUnit.ThermEc: return _value*1.05505585262e8;
-                case EnergyUnit.ThermImperial: return _value*1.05505585257348e8;
-                case EnergyUnit.ThermUs: return _value*1.054804e8;
-                case EnergyUnit.WattDay: return _value*24*3600d;
-                case EnergyUnit.WattHour: return _value*3600d;
+                case EnergyUnit.BritishThermalUnit: return Value*1055.05585262;
+                case EnergyUnit.Calorie: return Value*4.184;
+                case EnergyUnit.DecathermEc: return (Value*1.05505585262e8) * 1e1d;
+                case EnergyUnit.DecathermImperial: return (Value*1.05505585257348e8) * 1e1d;
+                case EnergyUnit.DecathermUs: return (Value*1.054804e8) * 1e1d;
+                case EnergyUnit.ElectronVolt: return Value*1.602176565e-19;
+                case EnergyUnit.Erg: return Value*1e-7;
+                case EnergyUnit.FootPound: return Value*1.355817948;
+                case EnergyUnit.GigabritishThermalUnit: return (Value*1055.05585262) * 1e9d;
+                case EnergyUnit.GigaelectronVolt: return (Value*1.602176565e-19) * 1e9d;
+                case EnergyUnit.Gigajoule: return (Value) * 1e9d;
+                case EnergyUnit.GigawattDay: return (Value*24*3600d) * 1e9d;
+                case EnergyUnit.GigawattHour: return (Value*3600d) * 1e9d;
+                case EnergyUnit.HorsepowerHour: return Value*2.6845195377e6;
+                case EnergyUnit.Joule: return Value;
+                case EnergyUnit.KilobritishThermalUnit: return (Value*1055.05585262) * 1e3d;
+                case EnergyUnit.Kilocalorie: return (Value*4.184) * 1e3d;
+                case EnergyUnit.KiloelectronVolt: return (Value*1.602176565e-19) * 1e3d;
+                case EnergyUnit.Kilojoule: return (Value) * 1e3d;
+                case EnergyUnit.KilowattDay: return (Value*24*3600d) * 1e3d;
+                case EnergyUnit.KilowattHour: return (Value*3600d) * 1e3d;
+                case EnergyUnit.MegabritishThermalUnit: return (Value*1055.05585262) * 1e6d;
+                case EnergyUnit.Megacalorie: return (Value*4.184) * 1e6d;
+                case EnergyUnit.MegaelectronVolt: return (Value*1.602176565e-19) * 1e6d;
+                case EnergyUnit.Megajoule: return (Value) * 1e6d;
+                case EnergyUnit.MegawattDay: return (Value*24*3600d) * 1e6d;
+                case EnergyUnit.MegawattHour: return (Value*3600d) * 1e6d;
+                case EnergyUnit.Millijoule: return (Value) * 1e-3d;
+                case EnergyUnit.TeraelectronVolt: return (Value*1.602176565e-19) * 1e12d;
+                case EnergyUnit.TerawattDay: return (Value*24*3600d) * 1e12d;
+                case EnergyUnit.TerawattHour: return (Value*3600d) * 1e12d;
+                case EnergyUnit.ThermEc: return Value*1.05505585262e8;
+                case EnergyUnit.ThermImperial: return Value*1.05505585257348e8;
+                case EnergyUnit.ThermUs: return Value*1.054804e8;
+                case EnergyUnit.WattDay: return Value*24*3600d;
+                case EnergyUnit.WattHour: return Value*3600d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1209,16 +1185,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Energy ToBaseUnit()
+        internal Energy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Energy(baseUnitValue, BaseUnit);
+            return new Energy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(EnergyUnit unit)
+        private T GetValueAs(EnergyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1356,57 +1332,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Energy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Energy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Energy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Energy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Energy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Energy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1416,33 +1392,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Energy))
+            if(conversionType == typeof(Energy<T>))
                 return this;
             else if(conversionType == typeof(EnergyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Energy.QuantityType;
+                return Energy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Energy.Info;
+                return Energy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Energy.BaseDimensions;
+                return Energy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Energy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Energy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
index 11da711023..1a341fbd5e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Entropy is an important concept in the branch of science known as thermodynamics. The idea of "irreversibility" is central to the understanding of entropy.  It is often said that entropy is an expression of the disorder, or randomness of a system, or of our lack of information about it. Entropy is an extensive property. It has the dimension of energy divided by temperature, which has a unit of joules per kelvin (J/K) in the International System of Units
     /// </summary>
-    public partial struct Entropy : IQuantity<EntropyUnit>, IEquatable<Entropy>, IComparable, IComparable<Entropy>, IConvertible, IFormattable
+    public partial struct Entropy<T> : IQuantityT<EntropyUnit, T>, IEquatable<Entropy<T>>, IComparable, IComparable<Entropy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -69,12 +65,12 @@ static Entropy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Entropy(double value, EntropyUnit unit)
+        public Entropy(T value, EntropyUnit unit)
         {
             if(unit == EntropyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -86,14 +82,14 @@ public Entropy(double value, EntropyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Entropy(double value, UnitSystem unitSystem)
+        public Entropy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -108,19 +104,19 @@ public Entropy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Entropy, which is JoulePerKelvin. All conversions go via this value.
+        ///     The base unit of <see cref="Entropy{T}" />, which is JoulePerKelvin. All conversions go via this value.
         /// </summary>
         public static EntropyUnit BaseUnit { get; } = EntropyUnit.JoulePerKelvin;
 
         /// <summary>
-        /// Represents the largest possible value of Entropy
+        /// Represents the largest possible value of <see cref="Entropy{T}" />
         /// </summary>
-        public static Entropy MaxValue { get; } = new Entropy(double.MaxValue, BaseUnit);
+        public static Entropy<T> MaxValue { get; } = new Entropy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Entropy
+        /// Represents the smallest possible value of <see cref="Entropy{T}" />
         /// </summary>
-        public static Entropy MinValue { get; } = new Entropy(double.MinValue, BaseUnit);
+        public static Entropy<T> MinValue { get; } = new Entropy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -129,14 +125,14 @@ public Entropy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Entropy;
 
         /// <summary>
-        ///     All units of measurement for the Entropy quantity.
+        ///     All units of measurement for the <see cref="Entropy{T}" /> quantity.
         /// </summary>
         public static EntropyUnit[] Units { get; } = Enum.GetValues(typeof(EntropyUnit)).Cast<EntropyUnit>().Except(new EntropyUnit[]{ EntropyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit JoulePerKelvin.
         /// </summary>
-        public static Entropy Zero { get; } = new Entropy(0, BaseUnit);
+        public static Entropy<T> Zero { get; } = new Entropy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -145,7 +141,9 @@ public Entropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -161,51 +159,51 @@ public Entropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Entropy.QuantityType;
+        public QuantityType Type => Entropy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Entropy.BaseDimensions;
+        public BaseDimensions Dimensions => Entropy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Entropy in CaloriesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> in CaloriesPerKelvin.
         /// </summary>
-        public double CaloriesPerKelvin => As(EntropyUnit.CaloriePerKelvin);
+        public T CaloriesPerKelvin => As(EntropyUnit.CaloriePerKelvin);
 
         /// <summary>
-        ///     Get Entropy in JoulesPerDegreeCelsius.
+        ///     Get <see cref="Entropy{T}" /> in JoulesPerDegreeCelsius.
         /// </summary>
-        public double JoulesPerDegreeCelsius => As(EntropyUnit.JoulePerDegreeCelsius);
+        public T JoulesPerDegreeCelsius => As(EntropyUnit.JoulePerDegreeCelsius);
 
         /// <summary>
-        ///     Get Entropy in JoulesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> in JoulesPerKelvin.
         /// </summary>
-        public double JoulesPerKelvin => As(EntropyUnit.JoulePerKelvin);
+        public T JoulesPerKelvin => As(EntropyUnit.JoulePerKelvin);
 
         /// <summary>
-        ///     Get Entropy in KilocaloriesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> in KilocaloriesPerKelvin.
         /// </summary>
-        public double KilocaloriesPerKelvin => As(EntropyUnit.KilocaloriePerKelvin);
+        public T KilocaloriesPerKelvin => As(EntropyUnit.KilocaloriePerKelvin);
 
         /// <summary>
-        ///     Get Entropy in KilojoulesPerDegreeCelsius.
+        ///     Get <see cref="Entropy{T}" /> in KilojoulesPerDegreeCelsius.
         /// </summary>
-        public double KilojoulesPerDegreeCelsius => As(EntropyUnit.KilojoulePerDegreeCelsius);
+        public T KilojoulesPerDegreeCelsius => As(EntropyUnit.KilojoulePerDegreeCelsius);
 
         /// <summary>
-        ///     Get Entropy in KilojoulesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> in KilojoulesPerKelvin.
         /// </summary>
-        public double KilojoulesPerKelvin => As(EntropyUnit.KilojoulePerKelvin);
+        public T KilojoulesPerKelvin => As(EntropyUnit.KilojoulePerKelvin);
 
         /// <summary>
-        ///     Get Entropy in MegajoulesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> in MegajoulesPerKelvin.
         /// </summary>
-        public double MegajoulesPerKelvin => As(EntropyUnit.MegajoulePerKelvin);
+        public T MegajoulesPerKelvin => As(EntropyUnit.MegajoulePerKelvin);
 
         #endregion
 
@@ -237,78 +235,71 @@ public static string GetAbbreviation(EntropyUnit unit, IFormatProvider? provider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Entropy from CaloriesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> from CaloriesPerKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromCaloriesPerKelvin(QuantityValue caloriesperkelvin)
+        public static Entropy<T> FromCaloriesPerKelvin(T caloriesperkelvin)
         {
-            double value = (double) caloriesperkelvin;
-            return new Entropy(value, EntropyUnit.CaloriePerKelvin);
+            return new Entropy<T>(caloriesperkelvin, EntropyUnit.CaloriePerKelvin);
         }
         /// <summary>
-        ///     Get Entropy from JoulesPerDegreeCelsius.
+        ///     Get <see cref="Entropy{T}" /> from JoulesPerDegreeCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromJoulesPerDegreeCelsius(QuantityValue joulesperdegreecelsius)
+        public static Entropy<T> FromJoulesPerDegreeCelsius(T joulesperdegreecelsius)
         {
-            double value = (double) joulesperdegreecelsius;
-            return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius);
+            return new Entropy<T>(joulesperdegreecelsius, EntropyUnit.JoulePerDegreeCelsius);
         }
         /// <summary>
-        ///     Get Entropy from JoulesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> from JoulesPerKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromJoulesPerKelvin(QuantityValue joulesperkelvin)
+        public static Entropy<T> FromJoulesPerKelvin(T joulesperkelvin)
         {
-            double value = (double) joulesperkelvin;
-            return new Entropy(value, EntropyUnit.JoulePerKelvin);
+            return new Entropy<T>(joulesperkelvin, EntropyUnit.JoulePerKelvin);
         }
         /// <summary>
-        ///     Get Entropy from KilocaloriesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> from KilocaloriesPerKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilocaloriesPerKelvin(QuantityValue kilocaloriesperkelvin)
+        public static Entropy<T> FromKilocaloriesPerKelvin(T kilocaloriesperkelvin)
         {
-            double value = (double) kilocaloriesperkelvin;
-            return new Entropy(value, EntropyUnit.KilocaloriePerKelvin);
+            return new Entropy<T>(kilocaloriesperkelvin, EntropyUnit.KilocaloriePerKelvin);
         }
         /// <summary>
-        ///     Get Entropy from KilojoulesPerDegreeCelsius.
+        ///     Get <see cref="Entropy{T}" /> from KilojoulesPerDegreeCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilojoulesPerDegreeCelsius(QuantityValue kilojoulesperdegreecelsius)
+        public static Entropy<T> FromKilojoulesPerDegreeCelsius(T kilojoulesperdegreecelsius)
         {
-            double value = (double) kilojoulesperdegreecelsius;
-            return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius);
+            return new Entropy<T>(kilojoulesperdegreecelsius, EntropyUnit.KilojoulePerDegreeCelsius);
         }
         /// <summary>
-        ///     Get Entropy from KilojoulesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> from KilojoulesPerKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilojoulesPerKelvin(QuantityValue kilojoulesperkelvin)
+        public static Entropy<T> FromKilojoulesPerKelvin(T kilojoulesperkelvin)
         {
-            double value = (double) kilojoulesperkelvin;
-            return new Entropy(value, EntropyUnit.KilojoulePerKelvin);
+            return new Entropy<T>(kilojoulesperkelvin, EntropyUnit.KilojoulePerKelvin);
         }
         /// <summary>
-        ///     Get Entropy from MegajoulesPerKelvin.
+        ///     Get <see cref="Entropy{T}" /> from MegajoulesPerKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromMegajoulesPerKelvin(QuantityValue megajoulesperkelvin)
+        public static Entropy<T> FromMegajoulesPerKelvin(T megajoulesperkelvin)
         {
-            double value = (double) megajoulesperkelvin;
-            return new Entropy(value, EntropyUnit.MegajoulePerKelvin);
+            return new Entropy<T>(megajoulesperkelvin, EntropyUnit.MegajoulePerKelvin);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="EntropyUnit" /> to <see cref="Entropy" />.
+        ///     Dynamically convert from value and unit enum <see cref="EntropyUnit" /> to <see cref="Entropy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Entropy unit value.</returns>
-        public static Entropy From(QuantityValue value, EntropyUnit fromUnit)
+        /// <returns><see cref="Entropy{T}" /> unit value.</returns>
+        public static Entropy<T> From(T value, EntropyUnit fromUnit)
         {
-            return new Entropy((double)value, fromUnit);
+            return new Entropy<T>(value, fromUnit);
         }
 
         #endregion
@@ -337,7 +328,7 @@ public static Entropy From(QuantityValue value, EntropyUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Entropy Parse(string str)
+        public static Entropy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -365,9 +356,9 @@ public static Entropy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Entropy Parse(string str, IFormatProvider? provider)
+        public static Entropy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Entropy, EntropyUnit>(
+            return QuantityParser.Default.Parse<T, Entropy<T>, EntropyUnit>(
                 str,
                 provider,
                 From);
@@ -381,7 +372,7 @@ public static Entropy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Entropy result)
+        public static bool TryParse(string? str, out Entropy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -396,9 +387,9 @@ public static bool TryParse(string? str, out Entropy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Entropy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Entropy<T> result)
         {
-            return QuantityParser.Default.TryParse<Entropy, EntropyUnit>(
+            return QuantityParser.Default.TryParse<T, Entropy<T>, EntropyUnit>(
                 str,
                 provider,
                 From,
@@ -460,45 +451,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Entro
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Entropy operator -(Entropy right)
+        public static Entropy<T> operator -(Entropy<T> right)
         {
-            return new Entropy(-right.Value, right.Unit);
+            return new Entropy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Entropy"/> from adding two <see cref="Entropy"/>.</summary>
-        public static Entropy operator +(Entropy left, Entropy right)
+        /// <summary>Get <see cref="Entropy{T}"/> from adding two <see cref="Entropy{T}"/>.</summary>
+        public static Entropy<T> operator +(Entropy<T> left, Entropy<T> right)
         {
-            return new Entropy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Entropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Entropy"/> from subtracting two <see cref="Entropy"/>.</summary>
-        public static Entropy operator -(Entropy left, Entropy right)
+        /// <summary>Get <see cref="Entropy{T}"/> from subtracting two <see cref="Entropy{T}"/>.</summary>
+        public static Entropy<T> operator -(Entropy<T> left, Entropy<T> right)
         {
-            return new Entropy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Entropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Entropy"/> from multiplying value and <see cref="Entropy"/>.</summary>
-        public static Entropy operator *(double left, Entropy right)
+        /// <summary>Get <see cref="Entropy{T}"/> from multiplying value and <see cref="Entropy{T}"/>.</summary>
+        public static Entropy<T> operator *(T left, Entropy<T> right)
         {
-            return new Entropy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Entropy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Entropy"/> from multiplying value and <see cref="Entropy"/>.</summary>
-        public static Entropy operator *(Entropy left, double right)
+        /// <summary>Get <see cref="Entropy{T}"/> from multiplying value and <see cref="Entropy{T}"/>.</summary>
+        public static Entropy<T> operator *(Entropy<T> left, T right)
         {
-            return new Entropy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Entropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Entropy"/> from dividing <see cref="Entropy"/> by value.</summary>
-        public static Entropy operator /(Entropy left, double right)
+        /// <summary>Get <see cref="Entropy{T}"/> from dividing <see cref="Entropy{T}"/> by value.</summary>
+        public static Entropy<T> operator /(Entropy<T> left, T right)
         {
-            return new Entropy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Entropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Entropy"/> by <see cref="Entropy"/>.</summary>
-        public static double operator /(Entropy left, Entropy right)
+        /// <summary>Get ratio value from dividing <see cref="Entropy{T}"/> by <see cref="Entropy{T}"/>.</summary>
+        public static T operator /(Entropy<T> left, Entropy<T> right)
         {
-            return left.JoulesPerKelvin / right.JoulesPerKelvin;
+            return CompiledLambdas.Divide(left.JoulesPerKelvin, right.JoulesPerKelvin);
         }
 
         #endregion
@@ -506,39 +502,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Entro
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Entropy left, Entropy right)
+        public static bool operator <=(Entropy<T> left, Entropy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Entropy left, Entropy right)
+        public static bool operator >=(Entropy<T> left, Entropy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Entropy left, Entropy right)
+        public static bool operator <(Entropy<T> left, Entropy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Entropy left, Entropy right)
+        public static bool operator >(Entropy<T> left, Entropy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Entropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Entropy left, Entropy right)
+        /// <remarks>Consider using <see cref="Equals(Entropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Entropy<T> left, Entropy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Entropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Entropy left, Entropy right)
+        /// <remarks>Consider using <see cref="Equals(Entropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Entropy<T> left, Entropy<T> right)
         {
             return !(left == right);
         }
@@ -547,37 +543,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Entro
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Entropy objEntropy)) throw new ArgumentException("Expected type Entropy.", nameof(obj));
+            if(!(obj is Entropy<T> objEntropy)) throw new ArgumentException("Expected type Entropy.", nameof(obj));
 
             return CompareTo(objEntropy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Entropy other)
+        public int CompareTo(Entropy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Entropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Entropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Entropy objEntropy))
+            if(obj is null || !(obj is Entropy<T> objEntropy))
                 return false;
 
             return Equals(objEntropy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Entropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Entropy other)
+        /// <remarks>Consider using <see cref="Equals(Entropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Entropy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Entropy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Entropy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -615,21 +611,19 @@ public bool Equals(Entropy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Entropy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Entropy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Entropy.</returns>
+        /// <returns>A hash code for the current <see cref="Entropy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -643,17 +637,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(EntropyUnit unit)
+        public T As(EntropyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -673,17 +667,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is EntropyUnit unitAsEntropyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EntropyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsEntropyUnit);
+            var asValue = As(unitAsEntropyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<EntropyUnit>.As(EntropyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Entropy to another Entropy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Entropy{T}" /> to another <see cref="Entropy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Entropy with the specified unit.</returns>
-        public Entropy ToUnit(EntropyUnit unit)
+        /// <returns>A <see cref="Entropy{T}" /> with the specified unit.</returns>
+        public Entropy<T> ToUnit(EntropyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Entropy(convertedValue, unit);
+            return new Entropy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -696,7 +695,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Entropy ToUnit(UnitSystem unitSystem)
+        public Entropy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -716,25 +715,31 @@ public Entropy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<EntropyUnit> IQuantity<EntropyUnit>.ToUnit(EntropyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<EntropyUnit, T> IQuantityT<EntropyUnit, T>.ToUnit(EntropyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<EntropyUnit> IQuantity<EntropyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<EntropyUnit, T> IQuantityT<EntropyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case EntropyUnit.CaloriePerKelvin: return _value*4.184;
-                case EntropyUnit.JoulePerDegreeCelsius: return _value;
-                case EntropyUnit.JoulePerKelvin: return _value;
-                case EntropyUnit.KilocaloriePerKelvin: return (_value*4.184) * 1e3d;
-                case EntropyUnit.KilojoulePerDegreeCelsius: return (_value) * 1e3d;
-                case EntropyUnit.KilojoulePerKelvin: return (_value) * 1e3d;
-                case EntropyUnit.MegajoulePerKelvin: return (_value) * 1e6d;
+                case EntropyUnit.CaloriePerKelvin: return Value*4.184;
+                case EntropyUnit.JoulePerDegreeCelsius: return Value;
+                case EntropyUnit.JoulePerKelvin: return Value;
+                case EntropyUnit.KilocaloriePerKelvin: return (Value*4.184) * 1e3d;
+                case EntropyUnit.KilojoulePerDegreeCelsius: return (Value) * 1e3d;
+                case EntropyUnit.KilojoulePerKelvin: return (Value) * 1e3d;
+                case EntropyUnit.MegajoulePerKelvin: return (Value) * 1e6d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -745,16 +750,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Entropy ToBaseUnit()
+        internal Entropy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Entropy(baseUnitValue, BaseUnit);
+            return new Entropy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(EntropyUnit unit)
+        private T GetValueAs(EntropyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -863,57 +868,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Entropy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Entropy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Entropy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Entropy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Entropy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Entropy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -923,33 +928,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Entropy))
+            if(conversionType == typeof(Entropy<T>))
                 return this;
             else if(conversionType == typeof(EntropyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Entropy.QuantityType;
+                return Entropy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Entropy.Info;
+                return Entropy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Entropy.BaseDimensions;
+                return Entropy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Entropy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Entropy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index 78c58aff20..f454ef7a18 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In physics, a force is any influence that causes an object to undergo a certain change, either concerning its movement, direction, or geometrical construction. In other words, a force can cause an object with mass to change its velocity (which includes to begin moving from a state of rest), i.e., to accelerate, or a flexible object to deform, or both. Force can also be described by intuitive concepts such as a push or a pull. A force has both magnitude and direction, making it a vector quantity. It is measured in the SI unit of newtons and represented by the symbol F.
     /// </summary>
-    public partial struct Force : IQuantity<ForceUnit>, IEquatable<Force>, IComparable, IComparable<Force>, IConvertible, IFormattable
+    public partial struct Force<T> : IQuantityT<ForceUnit, T>, IEquatable<Force<T>>, IComparable, IComparable<Force<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -77,12 +73,12 @@ static Force()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Force(double value, ForceUnit unit)
+        public Force(T value, ForceUnit unit)
         {
             if(unit == ForceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -94,14 +90,14 @@ public Force(double value, ForceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Force(double value, UnitSystem unitSystem)
+        public Force(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -116,19 +112,19 @@ public Force(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Force, which is Newton. All conversions go via this value.
+        ///     The base unit of <see cref="Force{T}" />, which is Newton. All conversions go via this value.
         /// </summary>
         public static ForceUnit BaseUnit { get; } = ForceUnit.Newton;
 
         /// <summary>
-        /// Represents the largest possible value of Force
+        /// Represents the largest possible value of <see cref="Force{T}" />
         /// </summary>
-        public static Force MaxValue { get; } = new Force(double.MaxValue, BaseUnit);
+        public static Force<T> MaxValue { get; } = new Force<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Force
+        /// Represents the smallest possible value of <see cref="Force{T}" />
         /// </summary>
-        public static Force MinValue { get; } = new Force(double.MinValue, BaseUnit);
+        public static Force<T> MinValue { get; } = new Force<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -137,14 +133,14 @@ public Force(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Force;
 
         /// <summary>
-        ///     All units of measurement for the Force quantity.
+        ///     All units of measurement for the <see cref="Force{T}" /> quantity.
         /// </summary>
         public static ForceUnit[] Units { get; } = Enum.GetValues(typeof(ForceUnit)).Cast<ForceUnit>().Except(new ForceUnit[]{ ForceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Newton.
         /// </summary>
-        public static Force Zero { get; } = new Force(0, BaseUnit);
+        public static Force<T> Zero { get; } = new Force<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -153,7 +149,9 @@ public Force(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -169,91 +167,91 @@ public Force(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Force.QuantityType;
+        public QuantityType Type => Force<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Force.BaseDimensions;
+        public BaseDimensions Dimensions => Force<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Force in Decanewtons.
+        ///     Get <see cref="Force{T}" /> in Decanewtons.
         /// </summary>
-        public double Decanewtons => As(ForceUnit.Decanewton);
+        public T Decanewtons => As(ForceUnit.Decanewton);
 
         /// <summary>
-        ///     Get Force in Dyne.
+        ///     Get <see cref="Force{T}" /> in Dyne.
         /// </summary>
-        public double Dyne => As(ForceUnit.Dyn);
+        public T Dyne => As(ForceUnit.Dyn);
 
         /// <summary>
-        ///     Get Force in KilogramsForce.
+        ///     Get <see cref="Force{T}" /> in KilogramsForce.
         /// </summary>
-        public double KilogramsForce => As(ForceUnit.KilogramForce);
+        public T KilogramsForce => As(ForceUnit.KilogramForce);
 
         /// <summary>
-        ///     Get Force in Kilonewtons.
+        ///     Get <see cref="Force{T}" /> in Kilonewtons.
         /// </summary>
-        public double Kilonewtons => As(ForceUnit.Kilonewton);
+        public T Kilonewtons => As(ForceUnit.Kilonewton);
 
         /// <summary>
-        ///     Get Force in KiloPonds.
+        ///     Get <see cref="Force{T}" /> in KiloPonds.
         /// </summary>
-        public double KiloPonds => As(ForceUnit.KiloPond);
+        public T KiloPonds => As(ForceUnit.KiloPond);
 
         /// <summary>
-        ///     Get Force in KilopoundsForce.
+        ///     Get <see cref="Force{T}" /> in KilopoundsForce.
         /// </summary>
-        public double KilopoundsForce => As(ForceUnit.KilopoundForce);
+        public T KilopoundsForce => As(ForceUnit.KilopoundForce);
 
         /// <summary>
-        ///     Get Force in Meganewtons.
+        ///     Get <see cref="Force{T}" /> in Meganewtons.
         /// </summary>
-        public double Meganewtons => As(ForceUnit.Meganewton);
+        public T Meganewtons => As(ForceUnit.Meganewton);
 
         /// <summary>
-        ///     Get Force in Micronewtons.
+        ///     Get <see cref="Force{T}" /> in Micronewtons.
         /// </summary>
-        public double Micronewtons => As(ForceUnit.Micronewton);
+        public T Micronewtons => As(ForceUnit.Micronewton);
 
         /// <summary>
-        ///     Get Force in Millinewtons.
+        ///     Get <see cref="Force{T}" /> in Millinewtons.
         /// </summary>
-        public double Millinewtons => As(ForceUnit.Millinewton);
+        public T Millinewtons => As(ForceUnit.Millinewton);
 
         /// <summary>
-        ///     Get Force in Newtons.
+        ///     Get <see cref="Force{T}" /> in Newtons.
         /// </summary>
-        public double Newtons => As(ForceUnit.Newton);
+        public T Newtons => As(ForceUnit.Newton);
 
         /// <summary>
-        ///     Get Force in OunceForce.
+        ///     Get <see cref="Force{T}" /> in OunceForce.
         /// </summary>
-        public double OunceForce => As(ForceUnit.OunceForce);
+        public T OunceForce => As(ForceUnit.OunceForce);
 
         /// <summary>
-        ///     Get Force in Poundals.
+        ///     Get <see cref="Force{T}" /> in Poundals.
         /// </summary>
-        public double Poundals => As(ForceUnit.Poundal);
+        public T Poundals => As(ForceUnit.Poundal);
 
         /// <summary>
-        ///     Get Force in PoundsForce.
+        ///     Get <see cref="Force{T}" /> in PoundsForce.
         /// </summary>
-        public double PoundsForce => As(ForceUnit.PoundForce);
+        public T PoundsForce => As(ForceUnit.PoundForce);
 
         /// <summary>
-        ///     Get Force in ShortTonsForce.
+        ///     Get <see cref="Force{T}" /> in ShortTonsForce.
         /// </summary>
-        public double ShortTonsForce => As(ForceUnit.ShortTonForce);
+        public T ShortTonsForce => As(ForceUnit.ShortTonForce);
 
         /// <summary>
-        ///     Get Force in TonnesForce.
+        ///     Get <see cref="Force{T}" /> in TonnesForce.
         /// </summary>
-        public double TonnesForce => As(ForceUnit.TonneForce);
+        public T TonnesForce => As(ForceUnit.TonneForce);
 
         #endregion
 
@@ -285,150 +283,135 @@ public static string GetAbbreviation(ForceUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Force from Decanewtons.
+        ///     Get <see cref="Force{T}" /> from Decanewtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromDecanewtons(QuantityValue decanewtons)
+        public static Force<T> FromDecanewtons(T decanewtons)
         {
-            double value = (double) decanewtons;
-            return new Force(value, ForceUnit.Decanewton);
+            return new Force<T>(decanewtons, ForceUnit.Decanewton);
         }
         /// <summary>
-        ///     Get Force from Dyne.
+        ///     Get <see cref="Force{T}" /> from Dyne.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromDyne(QuantityValue dyne)
+        public static Force<T> FromDyne(T dyne)
         {
-            double value = (double) dyne;
-            return new Force(value, ForceUnit.Dyn);
+            return new Force<T>(dyne, ForceUnit.Dyn);
         }
         /// <summary>
-        ///     Get Force from KilogramsForce.
+        ///     Get <see cref="Force{T}" /> from KilogramsForce.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilogramsForce(QuantityValue kilogramsforce)
+        public static Force<T> FromKilogramsForce(T kilogramsforce)
         {
-            double value = (double) kilogramsforce;
-            return new Force(value, ForceUnit.KilogramForce);
+            return new Force<T>(kilogramsforce, ForceUnit.KilogramForce);
         }
         /// <summary>
-        ///     Get Force from Kilonewtons.
+        ///     Get <see cref="Force{T}" /> from Kilonewtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilonewtons(QuantityValue kilonewtons)
+        public static Force<T> FromKilonewtons(T kilonewtons)
         {
-            double value = (double) kilonewtons;
-            return new Force(value, ForceUnit.Kilonewton);
+            return new Force<T>(kilonewtons, ForceUnit.Kilonewton);
         }
         /// <summary>
-        ///     Get Force from KiloPonds.
+        ///     Get <see cref="Force{T}" /> from KiloPonds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKiloPonds(QuantityValue kiloponds)
+        public static Force<T> FromKiloPonds(T kiloponds)
         {
-            double value = (double) kiloponds;
-            return new Force(value, ForceUnit.KiloPond);
+            return new Force<T>(kiloponds, ForceUnit.KiloPond);
         }
         /// <summary>
-        ///     Get Force from KilopoundsForce.
+        ///     Get <see cref="Force{T}" /> from KilopoundsForce.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilopoundsForce(QuantityValue kilopoundsforce)
+        public static Force<T> FromKilopoundsForce(T kilopoundsforce)
         {
-            double value = (double) kilopoundsforce;
-            return new Force(value, ForceUnit.KilopoundForce);
+            return new Force<T>(kilopoundsforce, ForceUnit.KilopoundForce);
         }
         /// <summary>
-        ///     Get Force from Meganewtons.
+        ///     Get <see cref="Force{T}" /> from Meganewtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMeganewtons(QuantityValue meganewtons)
+        public static Force<T> FromMeganewtons(T meganewtons)
         {
-            double value = (double) meganewtons;
-            return new Force(value, ForceUnit.Meganewton);
+            return new Force<T>(meganewtons, ForceUnit.Meganewton);
         }
         /// <summary>
-        ///     Get Force from Micronewtons.
+        ///     Get <see cref="Force{T}" /> from Micronewtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMicronewtons(QuantityValue micronewtons)
+        public static Force<T> FromMicronewtons(T micronewtons)
         {
-            double value = (double) micronewtons;
-            return new Force(value, ForceUnit.Micronewton);
+            return new Force<T>(micronewtons, ForceUnit.Micronewton);
         }
         /// <summary>
-        ///     Get Force from Millinewtons.
+        ///     Get <see cref="Force{T}" /> from Millinewtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMillinewtons(QuantityValue millinewtons)
+        public static Force<T> FromMillinewtons(T millinewtons)
         {
-            double value = (double) millinewtons;
-            return new Force(value, ForceUnit.Millinewton);
+            return new Force<T>(millinewtons, ForceUnit.Millinewton);
         }
         /// <summary>
-        ///     Get Force from Newtons.
+        ///     Get <see cref="Force{T}" /> from Newtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromNewtons(QuantityValue newtons)
+        public static Force<T> FromNewtons(T newtons)
         {
-            double value = (double) newtons;
-            return new Force(value, ForceUnit.Newton);
+            return new Force<T>(newtons, ForceUnit.Newton);
         }
         /// <summary>
-        ///     Get Force from OunceForce.
+        ///     Get <see cref="Force{T}" /> from OunceForce.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromOunceForce(QuantityValue ounceforce)
+        public static Force<T> FromOunceForce(T ounceforce)
         {
-            double value = (double) ounceforce;
-            return new Force(value, ForceUnit.OunceForce);
+            return new Force<T>(ounceforce, ForceUnit.OunceForce);
         }
         /// <summary>
-        ///     Get Force from Poundals.
+        ///     Get <see cref="Force{T}" /> from Poundals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromPoundals(QuantityValue poundals)
+        public static Force<T> FromPoundals(T poundals)
         {
-            double value = (double) poundals;
-            return new Force(value, ForceUnit.Poundal);
+            return new Force<T>(poundals, ForceUnit.Poundal);
         }
         /// <summary>
-        ///     Get Force from PoundsForce.
+        ///     Get <see cref="Force{T}" /> from PoundsForce.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromPoundsForce(QuantityValue poundsforce)
+        public static Force<T> FromPoundsForce(T poundsforce)
         {
-            double value = (double) poundsforce;
-            return new Force(value, ForceUnit.PoundForce);
+            return new Force<T>(poundsforce, ForceUnit.PoundForce);
         }
         /// <summary>
-        ///     Get Force from ShortTonsForce.
+        ///     Get <see cref="Force{T}" /> from ShortTonsForce.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromShortTonsForce(QuantityValue shorttonsforce)
+        public static Force<T> FromShortTonsForce(T shorttonsforce)
         {
-            double value = (double) shorttonsforce;
-            return new Force(value, ForceUnit.ShortTonForce);
+            return new Force<T>(shorttonsforce, ForceUnit.ShortTonForce);
         }
         /// <summary>
-        ///     Get Force from TonnesForce.
+        ///     Get <see cref="Force{T}" /> from TonnesForce.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromTonnesForce(QuantityValue tonnesforce)
+        public static Force<T> FromTonnesForce(T tonnesforce)
         {
-            double value = (double) tonnesforce;
-            return new Force(value, ForceUnit.TonneForce);
+            return new Force<T>(tonnesforce, ForceUnit.TonneForce);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ForceUnit" /> to <see cref="Force" />.
+        ///     Dynamically convert from value and unit enum <see cref="ForceUnit" /> to <see cref="Force{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Force unit value.</returns>
-        public static Force From(QuantityValue value, ForceUnit fromUnit)
+        /// <returns><see cref="Force{T}" /> unit value.</returns>
+        public static Force<T> From(T value, ForceUnit fromUnit)
         {
-            return new Force((double)value, fromUnit);
+            return new Force<T>(value, fromUnit);
         }
 
         #endregion
@@ -457,7 +440,7 @@ public static Force From(QuantityValue value, ForceUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Force Parse(string str)
+        public static Force<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -485,9 +468,9 @@ public static Force Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Force Parse(string str, IFormatProvider? provider)
+        public static Force<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Force, ForceUnit>(
+            return QuantityParser.Default.Parse<T, Force<T>, ForceUnit>(
                 str,
                 provider,
                 From);
@@ -501,7 +484,7 @@ public static Force Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Force result)
+        public static bool TryParse(string? str, out Force<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -516,9 +499,9 @@ public static bool TryParse(string? str, out Force result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Force result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Force<T> result)
         {
-            return QuantityParser.Default.TryParse<Force, ForceUnit>(
+            return QuantityParser.Default.TryParse<T, Force<T>, ForceUnit>(
                 str,
                 provider,
                 From,
@@ -580,45 +563,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Force operator -(Force right)
+        public static Force<T> operator -(Force<T> right)
         {
-            return new Force(-right.Value, right.Unit);
+            return new Force<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Force"/> from adding two <see cref="Force"/>.</summary>
-        public static Force operator +(Force left, Force right)
+        /// <summary>Get <see cref="Force{T}"/> from adding two <see cref="Force{T}"/>.</summary>
+        public static Force<T> operator +(Force<T> left, Force<T> right)
         {
-            return new Force(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Force<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Force"/> from subtracting two <see cref="Force"/>.</summary>
-        public static Force operator -(Force left, Force right)
+        /// <summary>Get <see cref="Force{T}"/> from subtracting two <see cref="Force{T}"/>.</summary>
+        public static Force<T> operator -(Force<T> left, Force<T> right)
         {
-            return new Force(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Force<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Force"/> from multiplying value and <see cref="Force"/>.</summary>
-        public static Force operator *(double left, Force right)
+        /// <summary>Get <see cref="Force{T}"/> from multiplying value and <see cref="Force{T}"/>.</summary>
+        public static Force<T> operator *(T left, Force<T> right)
         {
-            return new Force(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Force<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Force"/> from multiplying value and <see cref="Force"/>.</summary>
-        public static Force operator *(Force left, double right)
+        /// <summary>Get <see cref="Force{T}"/> from multiplying value and <see cref="Force{T}"/>.</summary>
+        public static Force<T> operator *(Force<T> left, T right)
         {
-            return new Force(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Force<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Force"/> from dividing <see cref="Force"/> by value.</summary>
-        public static Force operator /(Force left, double right)
+        /// <summary>Get <see cref="Force{T}"/> from dividing <see cref="Force{T}"/> by value.</summary>
+        public static Force<T> operator /(Force<T> left, T right)
         {
-            return new Force(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Force<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Force"/> by <see cref="Force"/>.</summary>
-        public static double operator /(Force left, Force right)
+        /// <summary>Get ratio value from dividing <see cref="Force{T}"/> by <see cref="Force{T}"/>.</summary>
+        public static T operator /(Force<T> left, Force<T> right)
         {
-            return left.Newtons / right.Newtons;
+            return CompiledLambdas.Divide(left.Newtons, right.Newtons);
         }
 
         #endregion
@@ -626,39 +614,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Force left, Force right)
+        public static bool operator <=(Force<T> left, Force<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Force left, Force right)
+        public static bool operator >=(Force<T> left, Force<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Force left, Force right)
+        public static bool operator <(Force<T> left, Force<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Force left, Force right)
+        public static bool operator >(Force<T> left, Force<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Force, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Force left, Force right)
+        /// <remarks>Consider using <see cref="Equals(Force{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Force<T> left, Force<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Force, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Force left, Force right)
+        /// <remarks>Consider using <see cref="Equals(Force{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Force<T> left, Force<T> right)
         {
             return !(left == right);
         }
@@ -667,37 +655,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Force objForce)) throw new ArgumentException("Expected type Force.", nameof(obj));
+            if(!(obj is Force<T> objForce)) throw new ArgumentException("Expected type Force.", nameof(obj));
 
             return CompareTo(objForce);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Force other)
+        public int CompareTo(Force<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Force, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Force{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Force objForce))
+            if(obj is null || !(obj is Force<T> objForce))
                 return false;
 
             return Equals(objForce);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Force, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Force other)
+        /// <remarks>Consider using <see cref="Equals(Force{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Force<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Force within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Force{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -735,21 +723,19 @@ public bool Equals(Force other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Force other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Force<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Force.</returns>
+        /// <returns>A hash code for the current <see cref="Force{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -763,17 +749,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ForceUnit unit)
+        public T As(ForceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -793,17 +779,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ForceUnit unitAsForceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsForceUnit);
+            var asValue = As(unitAsForceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ForceUnit>.As(ForceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Force to another Force with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Force{T}" /> to another <see cref="Force{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Force with the specified unit.</returns>
-        public Force ToUnit(ForceUnit unit)
+        /// <returns>A <see cref="Force{T}" /> with the specified unit.</returns>
+        public Force<T> ToUnit(ForceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Force(convertedValue, unit);
+            return new Force<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -816,7 +807,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Force ToUnit(UnitSystem unitSystem)
+        public Force<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -836,33 +827,39 @@ public Force ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ForceUnit> IQuantity<ForceUnit>.ToUnit(ForceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ForceUnit, T> IQuantityT<ForceUnit, T>.ToUnit(ForceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ForceUnit> IQuantity<ForceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ForceUnit, T> IQuantityT<ForceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ForceUnit.Decanewton: return (_value) * 1e1d;
-                case ForceUnit.Dyn: return _value/1e5;
-                case ForceUnit.KilogramForce: return _value*9.80665002864;
-                case ForceUnit.Kilonewton: return (_value) * 1e3d;
-                case ForceUnit.KiloPond: return _value*9.80665002864;
-                case ForceUnit.KilopoundForce: return _value*4448.2216152605095551842641431421;
-                case ForceUnit.Meganewton: return (_value) * 1e6d;
-                case ForceUnit.Micronewton: return (_value) * 1e-6d;
-                case ForceUnit.Millinewton: return (_value) * 1e-3d;
-                case ForceUnit.Newton: return _value;
-                case ForceUnit.OunceForce: return _value*2.780138509537812e-1;
-                case ForceUnit.Poundal: return _value*0.13825502798973041652092282466083;
-                case ForceUnit.PoundForce: return _value*4.4482216152605095551842641431421;
-                case ForceUnit.ShortTonForce: return _value*8.896443230521e3;
-                case ForceUnit.TonneForce: return _value*9.80665002864e3;
+                case ForceUnit.Decanewton: return (Value) * 1e1d;
+                case ForceUnit.Dyn: return Value/1e5;
+                case ForceUnit.KilogramForce: return Value*9.80665002864;
+                case ForceUnit.Kilonewton: return (Value) * 1e3d;
+                case ForceUnit.KiloPond: return Value*9.80665002864;
+                case ForceUnit.KilopoundForce: return Value*4448.2216152605095551842641431421;
+                case ForceUnit.Meganewton: return (Value) * 1e6d;
+                case ForceUnit.Micronewton: return (Value) * 1e-6d;
+                case ForceUnit.Millinewton: return (Value) * 1e-3d;
+                case ForceUnit.Newton: return Value;
+                case ForceUnit.OunceForce: return Value*2.780138509537812e-1;
+                case ForceUnit.Poundal: return Value*0.13825502798973041652092282466083;
+                case ForceUnit.PoundForce: return Value*4.4482216152605095551842641431421;
+                case ForceUnit.ShortTonForce: return Value*8.896443230521e3;
+                case ForceUnit.TonneForce: return Value*9.80665002864e3;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -873,16 +870,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Force ToBaseUnit()
+        internal Force<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Force(baseUnitValue, BaseUnit);
+            return new Force<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ForceUnit unit)
+        private T GetValueAs(ForceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -999,57 +996,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Force)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Force<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Force)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Force<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Force)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Force<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1059,33 +1056,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Force))
+            if(conversionType == typeof(Force<T>))
                 return this;
             else if(conversionType == typeof(ForceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Force.QuantityType;
+                return Force<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Force.Info;
+                return Force<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Force.BaseDimensions;
+                return Force<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Force)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Force<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
index a43247ae43..51a2648800 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Force change rate is the ratio of the force change to the time during which the change occurred (value of force changes per unit time).
     /// </summary>
-    public partial struct ForceChangeRate : IQuantity<ForceChangeRateUnit>, IEquatable<ForceChangeRate>, IComparable, IComparable<ForceChangeRate>, IConvertible, IFormattable
+    public partial struct ForceChangeRate<T> : IQuantityT<ForceChangeRateUnit, T>, IEquatable<ForceChangeRate<T>>, IComparable, IComparable<ForceChangeRate<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -73,12 +69,12 @@ static ForceChangeRate()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ForceChangeRate(double value, ForceChangeRateUnit unit)
+        public ForceChangeRate(T value, ForceChangeRateUnit unit)
         {
             if(unit == ForceChangeRateUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -90,14 +86,14 @@ public ForceChangeRate(double value, ForceChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ForceChangeRate(double value, UnitSystem unitSystem)
+        public ForceChangeRate(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -112,19 +108,19 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ForceChangeRate, which is NewtonPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="ForceChangeRate{T}" />, which is NewtonPerSecond. All conversions go via this value.
         /// </summary>
         public static ForceChangeRateUnit BaseUnit { get; } = ForceChangeRateUnit.NewtonPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of ForceChangeRate
+        /// Represents the largest possible value of <see cref="ForceChangeRate{T}" />
         /// </summary>
-        public static ForceChangeRate MaxValue { get; } = new ForceChangeRate(double.MaxValue, BaseUnit);
+        public static ForceChangeRate<T> MaxValue { get; } = new ForceChangeRate<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ForceChangeRate
+        /// Represents the smallest possible value of <see cref="ForceChangeRate{T}" />
         /// </summary>
-        public static ForceChangeRate MinValue { get; } = new ForceChangeRate(double.MinValue, BaseUnit);
+        public static ForceChangeRate<T> MinValue { get; } = new ForceChangeRate<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -133,14 +129,14 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ForceChangeRate;
 
         /// <summary>
-        ///     All units of measurement for the ForceChangeRate quantity.
+        ///     All units of measurement for the <see cref="ForceChangeRate{T}" /> quantity.
         /// </summary>
         public static ForceChangeRateUnit[] Units { get; } = Enum.GetValues(typeof(ForceChangeRateUnit)).Cast<ForceChangeRateUnit>().Except(new ForceChangeRateUnit[]{ ForceChangeRateUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonPerSecond.
         /// </summary>
-        public static ForceChangeRate Zero { get; } = new ForceChangeRate(0, BaseUnit);
+        public static ForceChangeRate<T> Zero { get; } = new ForceChangeRate<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -149,7 +145,9 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -165,71 +163,71 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ForceChangeRate.QuantityType;
+        public QuantityType Type => ForceChangeRate<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ForceChangeRate.BaseDimensions;
+        public BaseDimensions Dimensions => ForceChangeRate<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ForceChangeRate in CentinewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in CentinewtonsPerSecond.
         /// </summary>
-        public double CentinewtonsPerSecond => As(ForceChangeRateUnit.CentinewtonPerSecond);
+        public T CentinewtonsPerSecond => As(ForceChangeRateUnit.CentinewtonPerSecond);
 
         /// <summary>
-        ///     Get ForceChangeRate in DecanewtonsPerMinute.
+        ///     Get <see cref="ForceChangeRate{T}" /> in DecanewtonsPerMinute.
         /// </summary>
-        public double DecanewtonsPerMinute => As(ForceChangeRateUnit.DecanewtonPerMinute);
+        public T DecanewtonsPerMinute => As(ForceChangeRateUnit.DecanewtonPerMinute);
 
         /// <summary>
-        ///     Get ForceChangeRate in DecanewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in DecanewtonsPerSecond.
         /// </summary>
-        public double DecanewtonsPerSecond => As(ForceChangeRateUnit.DecanewtonPerSecond);
+        public T DecanewtonsPerSecond => As(ForceChangeRateUnit.DecanewtonPerSecond);
 
         /// <summary>
-        ///     Get ForceChangeRate in DecinewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in DecinewtonsPerSecond.
         /// </summary>
-        public double DecinewtonsPerSecond => As(ForceChangeRateUnit.DecinewtonPerSecond);
+        public T DecinewtonsPerSecond => As(ForceChangeRateUnit.DecinewtonPerSecond);
 
         /// <summary>
-        ///     Get ForceChangeRate in KilonewtonsPerMinute.
+        ///     Get <see cref="ForceChangeRate{T}" /> in KilonewtonsPerMinute.
         /// </summary>
-        public double KilonewtonsPerMinute => As(ForceChangeRateUnit.KilonewtonPerMinute);
+        public T KilonewtonsPerMinute => As(ForceChangeRateUnit.KilonewtonPerMinute);
 
         /// <summary>
-        ///     Get ForceChangeRate in KilonewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in KilonewtonsPerSecond.
         /// </summary>
-        public double KilonewtonsPerSecond => As(ForceChangeRateUnit.KilonewtonPerSecond);
+        public T KilonewtonsPerSecond => As(ForceChangeRateUnit.KilonewtonPerSecond);
 
         /// <summary>
-        ///     Get ForceChangeRate in MicronewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in MicronewtonsPerSecond.
         /// </summary>
-        public double MicronewtonsPerSecond => As(ForceChangeRateUnit.MicronewtonPerSecond);
+        public T MicronewtonsPerSecond => As(ForceChangeRateUnit.MicronewtonPerSecond);
 
         /// <summary>
-        ///     Get ForceChangeRate in MillinewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in MillinewtonsPerSecond.
         /// </summary>
-        public double MillinewtonsPerSecond => As(ForceChangeRateUnit.MillinewtonPerSecond);
+        public T MillinewtonsPerSecond => As(ForceChangeRateUnit.MillinewtonPerSecond);
 
         /// <summary>
-        ///     Get ForceChangeRate in NanonewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in NanonewtonsPerSecond.
         /// </summary>
-        public double NanonewtonsPerSecond => As(ForceChangeRateUnit.NanonewtonPerSecond);
+        public T NanonewtonsPerSecond => As(ForceChangeRateUnit.NanonewtonPerSecond);
 
         /// <summary>
-        ///     Get ForceChangeRate in NewtonsPerMinute.
+        ///     Get <see cref="ForceChangeRate{T}" /> in NewtonsPerMinute.
         /// </summary>
-        public double NewtonsPerMinute => As(ForceChangeRateUnit.NewtonPerMinute);
+        public T NewtonsPerMinute => As(ForceChangeRateUnit.NewtonPerMinute);
 
         /// <summary>
-        ///     Get ForceChangeRate in NewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> in NewtonsPerSecond.
         /// </summary>
-        public double NewtonsPerSecond => As(ForceChangeRateUnit.NewtonPerSecond);
+        public T NewtonsPerSecond => As(ForceChangeRateUnit.NewtonPerSecond);
 
         #endregion
 
@@ -261,114 +259,103 @@ public static string GetAbbreviation(ForceChangeRateUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ForceChangeRate from CentinewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from CentinewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromCentinewtonsPerSecond(QuantityValue centinewtonspersecond)
+        public static ForceChangeRate<T> FromCentinewtonsPerSecond(T centinewtonspersecond)
         {
-            double value = (double) centinewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond);
+            return new ForceChangeRate<T>(centinewtonspersecond, ForceChangeRateUnit.CentinewtonPerSecond);
         }
         /// <summary>
-        ///     Get ForceChangeRate from DecanewtonsPerMinute.
+        ///     Get <see cref="ForceChangeRate{T}" /> from DecanewtonsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecanewtonsPerMinute(QuantityValue decanewtonsperminute)
+        public static ForceChangeRate<T> FromDecanewtonsPerMinute(T decanewtonsperminute)
         {
-            double value = (double) decanewtonsperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute);
+            return new ForceChangeRate<T>(decanewtonsperminute, ForceChangeRateUnit.DecanewtonPerMinute);
         }
         /// <summary>
-        ///     Get ForceChangeRate from DecanewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from DecanewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecanewtonsPerSecond(QuantityValue decanewtonspersecond)
+        public static ForceChangeRate<T> FromDecanewtonsPerSecond(T decanewtonspersecond)
         {
-            double value = (double) decanewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond);
+            return new ForceChangeRate<T>(decanewtonspersecond, ForceChangeRateUnit.DecanewtonPerSecond);
         }
         /// <summary>
-        ///     Get ForceChangeRate from DecinewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from DecinewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecinewtonsPerSecond(QuantityValue decinewtonspersecond)
+        public static ForceChangeRate<T> FromDecinewtonsPerSecond(T decinewtonspersecond)
         {
-            double value = (double) decinewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond);
+            return new ForceChangeRate<T>(decinewtonspersecond, ForceChangeRateUnit.DecinewtonPerSecond);
         }
         /// <summary>
-        ///     Get ForceChangeRate from KilonewtonsPerMinute.
+        ///     Get <see cref="ForceChangeRate{T}" /> from KilonewtonsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilonewtonsPerMinute(QuantityValue kilonewtonsperminute)
+        public static ForceChangeRate<T> FromKilonewtonsPerMinute(T kilonewtonsperminute)
         {
-            double value = (double) kilonewtonsperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute);
+            return new ForceChangeRate<T>(kilonewtonsperminute, ForceChangeRateUnit.KilonewtonPerMinute);
         }
         /// <summary>
-        ///     Get ForceChangeRate from KilonewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from KilonewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilonewtonsPerSecond(QuantityValue kilonewtonspersecond)
+        public static ForceChangeRate<T> FromKilonewtonsPerSecond(T kilonewtonspersecond)
         {
-            double value = (double) kilonewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond);
+            return new ForceChangeRate<T>(kilonewtonspersecond, ForceChangeRateUnit.KilonewtonPerSecond);
         }
         /// <summary>
-        ///     Get ForceChangeRate from MicronewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from MicronewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromMicronewtonsPerSecond(QuantityValue micronewtonspersecond)
+        public static ForceChangeRate<T> FromMicronewtonsPerSecond(T micronewtonspersecond)
         {
-            double value = (double) micronewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond);
+            return new ForceChangeRate<T>(micronewtonspersecond, ForceChangeRateUnit.MicronewtonPerSecond);
         }
         /// <summary>
-        ///     Get ForceChangeRate from MillinewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from MillinewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromMillinewtonsPerSecond(QuantityValue millinewtonspersecond)
+        public static ForceChangeRate<T> FromMillinewtonsPerSecond(T millinewtonspersecond)
         {
-            double value = (double) millinewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond);
+            return new ForceChangeRate<T>(millinewtonspersecond, ForceChangeRateUnit.MillinewtonPerSecond);
         }
         /// <summary>
-        ///     Get ForceChangeRate from NanonewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from NanonewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNanonewtonsPerSecond(QuantityValue nanonewtonspersecond)
+        public static ForceChangeRate<T> FromNanonewtonsPerSecond(T nanonewtonspersecond)
         {
-            double value = (double) nanonewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond);
+            return new ForceChangeRate<T>(nanonewtonspersecond, ForceChangeRateUnit.NanonewtonPerSecond);
         }
         /// <summary>
-        ///     Get ForceChangeRate from NewtonsPerMinute.
+        ///     Get <see cref="ForceChangeRate{T}" /> from NewtonsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNewtonsPerMinute(QuantityValue newtonsperminute)
+        public static ForceChangeRate<T> FromNewtonsPerMinute(T newtonsperminute)
         {
-            double value = (double) newtonsperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute);
+            return new ForceChangeRate<T>(newtonsperminute, ForceChangeRateUnit.NewtonPerMinute);
         }
         /// <summary>
-        ///     Get ForceChangeRate from NewtonsPerSecond.
+        ///     Get <see cref="ForceChangeRate{T}" /> from NewtonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNewtonsPerSecond(QuantityValue newtonspersecond)
+        public static ForceChangeRate<T> FromNewtonsPerSecond(T newtonspersecond)
         {
-            double value = (double) newtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond);
+            return new ForceChangeRate<T>(newtonspersecond, ForceChangeRateUnit.NewtonPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ForceChangeRateUnit" /> to <see cref="ForceChangeRate" />.
+        ///     Dynamically convert from value and unit enum <see cref="ForceChangeRateUnit" /> to <see cref="ForceChangeRate{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ForceChangeRate unit value.</returns>
-        public static ForceChangeRate From(QuantityValue value, ForceChangeRateUnit fromUnit)
+        /// <returns><see cref="ForceChangeRate{T}" /> unit value.</returns>
+        public static ForceChangeRate<T> From(T value, ForceChangeRateUnit fromUnit)
         {
-            return new ForceChangeRate((double)value, fromUnit);
+            return new ForceChangeRate<T>(value, fromUnit);
         }
 
         #endregion
@@ -397,7 +384,7 @@ public static ForceChangeRate From(QuantityValue value, ForceChangeRateUnit from
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ForceChangeRate Parse(string str)
+        public static ForceChangeRate<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -425,9 +412,9 @@ public static ForceChangeRate Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ForceChangeRate Parse(string str, IFormatProvider? provider)
+        public static ForceChangeRate<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ForceChangeRate, ForceChangeRateUnit>(
+            return QuantityParser.Default.Parse<T, ForceChangeRate<T>, ForceChangeRateUnit>(
                 str,
                 provider,
                 From);
@@ -441,7 +428,7 @@ public static ForceChangeRate Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ForceChangeRate result)
+        public static bool TryParse(string? str, out ForceChangeRate<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -456,9 +443,9 @@ public static bool TryParse(string? str, out ForceChangeRate result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ForceChangeRate result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ForceChangeRate<T> result)
         {
-            return QuantityParser.Default.TryParse<ForceChangeRate, ForceChangeRateUnit>(
+            return QuantityParser.Default.TryParse<T, ForceChangeRate<T>, ForceChangeRateUnit>(
                 str,
                 provider,
                 From,
@@ -520,45 +507,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ForceChangeRate operator -(ForceChangeRate right)
+        public static ForceChangeRate<T> operator -(ForceChangeRate<T> right)
         {
-            return new ForceChangeRate(-right.Value, right.Unit);
+            return new ForceChangeRate<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ForceChangeRate"/> from adding two <see cref="ForceChangeRate"/>.</summary>
-        public static ForceChangeRate operator +(ForceChangeRate left, ForceChangeRate right)
+        /// <summary>Get <see cref="ForceChangeRate{T}"/> from adding two <see cref="ForceChangeRate{T}"/>.</summary>
+        public static ForceChangeRate<T> operator +(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
-            return new ForceChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ForceChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ForceChangeRate"/> from subtracting two <see cref="ForceChangeRate"/>.</summary>
-        public static ForceChangeRate operator -(ForceChangeRate left, ForceChangeRate right)
+        /// <summary>Get <see cref="ForceChangeRate{T}"/> from subtracting two <see cref="ForceChangeRate{T}"/>.</summary>
+        public static ForceChangeRate<T> operator -(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
-            return new ForceChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ForceChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ForceChangeRate"/> from multiplying value and <see cref="ForceChangeRate"/>.</summary>
-        public static ForceChangeRate operator *(double left, ForceChangeRate right)
+        /// <summary>Get <see cref="ForceChangeRate{T}"/> from multiplying value and <see cref="ForceChangeRate{T}"/>.</summary>
+        public static ForceChangeRate<T> operator *(T left, ForceChangeRate<T> right)
         {
-            return new ForceChangeRate(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ForceChangeRate<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ForceChangeRate"/> from multiplying value and <see cref="ForceChangeRate"/>.</summary>
-        public static ForceChangeRate operator *(ForceChangeRate left, double right)
+        /// <summary>Get <see cref="ForceChangeRate{T}"/> from multiplying value and <see cref="ForceChangeRate{T}"/>.</summary>
+        public static ForceChangeRate<T> operator *(ForceChangeRate<T> left, T right)
         {
-            return new ForceChangeRate(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ForceChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ForceChangeRate"/> from dividing <see cref="ForceChangeRate"/> by value.</summary>
-        public static ForceChangeRate operator /(ForceChangeRate left, double right)
+        /// <summary>Get <see cref="ForceChangeRate{T}"/> from dividing <see cref="ForceChangeRate{T}"/> by value.</summary>
+        public static ForceChangeRate<T> operator /(ForceChangeRate<T> left, T right)
         {
-            return new ForceChangeRate(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ForceChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ForceChangeRate"/> by <see cref="ForceChangeRate"/>.</summary>
-        public static double operator /(ForceChangeRate left, ForceChangeRate right)
+        /// <summary>Get ratio value from dividing <see cref="ForceChangeRate{T}"/> by <see cref="ForceChangeRate{T}"/>.</summary>
+        public static T operator /(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
-            return left.NewtonsPerSecond / right.NewtonsPerSecond;
+            return CompiledLambdas.Divide(left.NewtonsPerSecond, right.NewtonsPerSecond);
         }
 
         #endregion
@@ -566,39 +558,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ForceChangeRate left, ForceChangeRate right)
+        public static bool operator <=(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ForceChangeRate left, ForceChangeRate right)
+        public static bool operator >=(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ForceChangeRate left, ForceChangeRate right)
+        public static bool operator <(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ForceChangeRate left, ForceChangeRate right)
+        public static bool operator >(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ForceChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ForceChangeRate left, ForceChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(ForceChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ForceChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ForceChangeRate left, ForceChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(ForceChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ForceChangeRate<T> left, ForceChangeRate<T> right)
         {
             return !(left == right);
         }
@@ -607,37 +599,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ForceChangeRate objForceChangeRate)) throw new ArgumentException("Expected type ForceChangeRate.", nameof(obj));
+            if(!(obj is ForceChangeRate<T> objForceChangeRate)) throw new ArgumentException("Expected type ForceChangeRate.", nameof(obj));
 
             return CompareTo(objForceChangeRate);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ForceChangeRate other)
+        public int CompareTo(ForceChangeRate<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ForceChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ForceChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ForceChangeRate objForceChangeRate))
+            if(obj is null || !(obj is ForceChangeRate<T> objForceChangeRate))
                 return false;
 
             return Equals(objForceChangeRate);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ForceChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ForceChangeRate other)
+        /// <remarks>Consider using <see cref="Equals(ForceChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ForceChangeRate<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ForceChangeRate within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ForceChangeRate{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -675,21 +667,19 @@ public bool Equals(ForceChangeRate other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ForceChangeRate other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ForceChangeRate<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ForceChangeRate.</returns>
+        /// <returns>A hash code for the current <see cref="ForceChangeRate{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -703,17 +693,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ForceChangeRateUnit unit)
+        public T As(ForceChangeRateUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -733,17 +723,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ForceChangeRateUnit unitAsForceChangeRateUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceChangeRateUnit)} is supported.", nameof(unit));
 
-            return As(unitAsForceChangeRateUnit);
+            var asValue = As(unitAsForceChangeRateUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ForceChangeRateUnit>.As(ForceChangeRateUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ForceChangeRate to another ForceChangeRate with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ForceChangeRate{T}" /> to another <see cref="ForceChangeRate{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ForceChangeRate with the specified unit.</returns>
-        public ForceChangeRate ToUnit(ForceChangeRateUnit unit)
+        /// <returns>A <see cref="ForceChangeRate{T}" /> with the specified unit.</returns>
+        public ForceChangeRate<T> ToUnit(ForceChangeRateUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ForceChangeRate(convertedValue, unit);
+            return new ForceChangeRate<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -756,7 +751,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ForceChangeRate ToUnit(UnitSystem unitSystem)
+        public ForceChangeRate<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -776,29 +771,35 @@ public ForceChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ForceChangeRateUnit> IQuantity<ForceChangeRateUnit>.ToUnit(ForceChangeRateUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ForceChangeRateUnit, T> IQuantityT<ForceChangeRateUnit, T>.ToUnit(ForceChangeRateUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ForceChangeRateUnit> IQuantity<ForceChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ForceChangeRateUnit, T> IQuantityT<ForceChangeRateUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ForceChangeRateUnit.CentinewtonPerSecond: return (_value) * 1e-2d;
-                case ForceChangeRateUnit.DecanewtonPerMinute: return (_value/60) * 1e1d;
-                case ForceChangeRateUnit.DecanewtonPerSecond: return (_value) * 1e1d;
-                case ForceChangeRateUnit.DecinewtonPerSecond: return (_value) * 1e-1d;
-                case ForceChangeRateUnit.KilonewtonPerMinute: return (_value/60) * 1e3d;
-                case ForceChangeRateUnit.KilonewtonPerSecond: return (_value) * 1e3d;
-                case ForceChangeRateUnit.MicronewtonPerSecond: return (_value) * 1e-6d;
-                case ForceChangeRateUnit.MillinewtonPerSecond: return (_value) * 1e-3d;
-                case ForceChangeRateUnit.NanonewtonPerSecond: return (_value) * 1e-9d;
-                case ForceChangeRateUnit.NewtonPerMinute: return _value/60;
-                case ForceChangeRateUnit.NewtonPerSecond: return _value;
+                case ForceChangeRateUnit.CentinewtonPerSecond: return (Value) * 1e-2d;
+                case ForceChangeRateUnit.DecanewtonPerMinute: return (Value/60) * 1e1d;
+                case ForceChangeRateUnit.DecanewtonPerSecond: return (Value) * 1e1d;
+                case ForceChangeRateUnit.DecinewtonPerSecond: return (Value) * 1e-1d;
+                case ForceChangeRateUnit.KilonewtonPerMinute: return (Value/60) * 1e3d;
+                case ForceChangeRateUnit.KilonewtonPerSecond: return (Value) * 1e3d;
+                case ForceChangeRateUnit.MicronewtonPerSecond: return (Value) * 1e-6d;
+                case ForceChangeRateUnit.MillinewtonPerSecond: return (Value) * 1e-3d;
+                case ForceChangeRateUnit.NanonewtonPerSecond: return (Value) * 1e-9d;
+                case ForceChangeRateUnit.NewtonPerMinute: return Value/60;
+                case ForceChangeRateUnit.NewtonPerSecond: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -809,16 +810,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ForceChangeRate ToBaseUnit()
+        internal ForceChangeRate<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ForceChangeRate(baseUnitValue, BaseUnit);
+            return new ForceChangeRate<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ForceChangeRateUnit unit)
+        private T GetValueAs(ForceChangeRateUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -931,57 +932,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ForceChangeRate)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ForceChangeRate<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ForceChangeRate)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ForceChangeRate<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ForceChangeRate)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ForceChangeRate<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -991,33 +992,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ForceChangeRate))
+            if(conversionType == typeof(ForceChangeRate<T>))
                 return this;
             else if(conversionType == typeof(ForceChangeRateUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ForceChangeRate.QuantityType;
+                return ForceChangeRate<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ForceChangeRate.Info;
+                return ForceChangeRate<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ForceChangeRate.BaseDimensions;
+                return ForceChangeRate<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ForceChangeRate)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ForceChangeRate<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
index 301c8bcc28..e33033d5cd 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The magnitude of force per unit length.
     /// </summary>
-    public partial struct ForcePerLength : IQuantity<ForcePerLengthUnit>, IEquatable<ForcePerLength>, IComparable, IComparable<ForcePerLength>, IConvertible, IFormattable
+    public partial struct ForcePerLength<T> : IQuantityT<ForcePerLengthUnit, T>, IEquatable<ForcePerLength<T>>, IComparable, IComparable<ForcePerLength<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -100,12 +96,12 @@ static ForcePerLength()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ForcePerLength(double value, ForcePerLengthUnit unit)
+        public ForcePerLength(T value, ForcePerLengthUnit unit)
         {
             if(unit == ForcePerLengthUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -117,14 +113,14 @@ public ForcePerLength(double value, ForcePerLengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ForcePerLength(double value, UnitSystem unitSystem)
+        public ForcePerLength(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -139,19 +135,19 @@ public ForcePerLength(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ForcePerLength, which is NewtonPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="ForcePerLength{T}" />, which is NewtonPerMeter. All conversions go via this value.
         /// </summary>
         public static ForcePerLengthUnit BaseUnit { get; } = ForcePerLengthUnit.NewtonPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of ForcePerLength
+        /// Represents the largest possible value of <see cref="ForcePerLength{T}" />
         /// </summary>
-        public static ForcePerLength MaxValue { get; } = new ForcePerLength(double.MaxValue, BaseUnit);
+        public static ForcePerLength<T> MaxValue { get; } = new ForcePerLength<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ForcePerLength
+        /// Represents the smallest possible value of <see cref="ForcePerLength{T}" />
         /// </summary>
-        public static ForcePerLength MinValue { get; } = new ForcePerLength(double.MinValue, BaseUnit);
+        public static ForcePerLength<T> MinValue { get; } = new ForcePerLength<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -160,14 +156,14 @@ public ForcePerLength(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ForcePerLength;
 
         /// <summary>
-        ///     All units of measurement for the ForcePerLength quantity.
+        ///     All units of measurement for the <see cref="ForcePerLength{T}" /> quantity.
         /// </summary>
         public static ForcePerLengthUnit[] Units { get; } = Enum.GetValues(typeof(ForcePerLengthUnit)).Cast<ForcePerLengthUnit>().Except(new ForcePerLengthUnit[]{ ForcePerLengthUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonPerMeter.
         /// </summary>
-        public static ForcePerLength Zero { get; } = new ForcePerLength(0, BaseUnit);
+        public static ForcePerLength<T> Zero { get; } = new ForcePerLength<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -176,7 +172,9 @@ public ForcePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -192,206 +190,206 @@ public ForcePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ForcePerLength.QuantityType;
+        public QuantityType Type => ForcePerLength<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ForcePerLength.BaseDimensions;
+        public BaseDimensions Dimensions => ForcePerLength<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ForcePerLength in CentinewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in CentinewtonsPerCentimeter.
         /// </summary>
-        public double CentinewtonsPerCentimeter => As(ForcePerLengthUnit.CentinewtonPerCentimeter);
+        public T CentinewtonsPerCentimeter => As(ForcePerLengthUnit.CentinewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in CentinewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in CentinewtonsPerMeter.
         /// </summary>
-        public double CentinewtonsPerMeter => As(ForcePerLengthUnit.CentinewtonPerMeter);
+        public T CentinewtonsPerMeter => As(ForcePerLengthUnit.CentinewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in CentinewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in CentinewtonsPerMillimeter.
         /// </summary>
-        public double CentinewtonsPerMillimeter => As(ForcePerLengthUnit.CentinewtonPerMillimeter);
+        public T CentinewtonsPerMillimeter => As(ForcePerLengthUnit.CentinewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in DecanewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in DecanewtonsPerCentimeter.
         /// </summary>
-        public double DecanewtonsPerCentimeter => As(ForcePerLengthUnit.DecanewtonPerCentimeter);
+        public T DecanewtonsPerCentimeter => As(ForcePerLengthUnit.DecanewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in DecanewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in DecanewtonsPerMeter.
         /// </summary>
-        public double DecanewtonsPerMeter => As(ForcePerLengthUnit.DecanewtonPerMeter);
+        public T DecanewtonsPerMeter => As(ForcePerLengthUnit.DecanewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in DecanewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in DecanewtonsPerMillimeter.
         /// </summary>
-        public double DecanewtonsPerMillimeter => As(ForcePerLengthUnit.DecanewtonPerMillimeter);
+        public T DecanewtonsPerMillimeter => As(ForcePerLengthUnit.DecanewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in DecinewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in DecinewtonsPerCentimeter.
         /// </summary>
-        public double DecinewtonsPerCentimeter => As(ForcePerLengthUnit.DecinewtonPerCentimeter);
+        public T DecinewtonsPerCentimeter => As(ForcePerLengthUnit.DecinewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in DecinewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in DecinewtonsPerMeter.
         /// </summary>
-        public double DecinewtonsPerMeter => As(ForcePerLengthUnit.DecinewtonPerMeter);
+        public T DecinewtonsPerMeter => As(ForcePerLengthUnit.DecinewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in DecinewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in DecinewtonsPerMillimeter.
         /// </summary>
-        public double DecinewtonsPerMillimeter => As(ForcePerLengthUnit.DecinewtonPerMillimeter);
+        public T DecinewtonsPerMillimeter => As(ForcePerLengthUnit.DecinewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in KilogramsForcePerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilogramsForcePerCentimeter.
         /// </summary>
-        public double KilogramsForcePerCentimeter => As(ForcePerLengthUnit.KilogramForcePerCentimeter);
+        public T KilogramsForcePerCentimeter => As(ForcePerLengthUnit.KilogramForcePerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in KilogramsForcePerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilogramsForcePerMeter.
         /// </summary>
-        public double KilogramsForcePerMeter => As(ForcePerLengthUnit.KilogramForcePerMeter);
+        public T KilogramsForcePerMeter => As(ForcePerLengthUnit.KilogramForcePerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in KilogramsForcePerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilogramsForcePerMillimeter.
         /// </summary>
-        public double KilogramsForcePerMillimeter => As(ForcePerLengthUnit.KilogramForcePerMillimeter);
+        public T KilogramsForcePerMillimeter => As(ForcePerLengthUnit.KilogramForcePerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in KilonewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilonewtonsPerCentimeter.
         /// </summary>
-        public double KilonewtonsPerCentimeter => As(ForcePerLengthUnit.KilonewtonPerCentimeter);
+        public T KilonewtonsPerCentimeter => As(ForcePerLengthUnit.KilonewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in KilonewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilonewtonsPerMeter.
         /// </summary>
-        public double KilonewtonsPerMeter => As(ForcePerLengthUnit.KilonewtonPerMeter);
+        public T KilonewtonsPerMeter => As(ForcePerLengthUnit.KilonewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in KilonewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilonewtonsPerMillimeter.
         /// </summary>
-        public double KilonewtonsPerMillimeter => As(ForcePerLengthUnit.KilonewtonPerMillimeter);
+        public T KilonewtonsPerMillimeter => As(ForcePerLengthUnit.KilonewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in KilopoundsForcePerFoot.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilopoundsForcePerFoot.
         /// </summary>
-        public double KilopoundsForcePerFoot => As(ForcePerLengthUnit.KilopoundForcePerFoot);
+        public T KilopoundsForcePerFoot => As(ForcePerLengthUnit.KilopoundForcePerFoot);
 
         /// <summary>
-        ///     Get ForcePerLength in KilopoundsForcePerInch.
+        ///     Get <see cref="ForcePerLength{T}" /> in KilopoundsForcePerInch.
         /// </summary>
-        public double KilopoundsForcePerInch => As(ForcePerLengthUnit.KilopoundForcePerInch);
+        public T KilopoundsForcePerInch => As(ForcePerLengthUnit.KilopoundForcePerInch);
 
         /// <summary>
-        ///     Get ForcePerLength in MeganewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MeganewtonsPerCentimeter.
         /// </summary>
-        public double MeganewtonsPerCentimeter => As(ForcePerLengthUnit.MeganewtonPerCentimeter);
+        public T MeganewtonsPerCentimeter => As(ForcePerLengthUnit.MeganewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MeganewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MeganewtonsPerMeter.
         /// </summary>
-        public double MeganewtonsPerMeter => As(ForcePerLengthUnit.MeganewtonPerMeter);
+        public T MeganewtonsPerMeter => As(ForcePerLengthUnit.MeganewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MeganewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MeganewtonsPerMillimeter.
         /// </summary>
-        public double MeganewtonsPerMillimeter => As(ForcePerLengthUnit.MeganewtonPerMillimeter);
+        public T MeganewtonsPerMillimeter => As(ForcePerLengthUnit.MeganewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MicronewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MicronewtonsPerCentimeter.
         /// </summary>
-        public double MicronewtonsPerCentimeter => As(ForcePerLengthUnit.MicronewtonPerCentimeter);
+        public T MicronewtonsPerCentimeter => As(ForcePerLengthUnit.MicronewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MicronewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MicronewtonsPerMeter.
         /// </summary>
-        public double MicronewtonsPerMeter => As(ForcePerLengthUnit.MicronewtonPerMeter);
+        public T MicronewtonsPerMeter => As(ForcePerLengthUnit.MicronewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MicronewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MicronewtonsPerMillimeter.
         /// </summary>
-        public double MicronewtonsPerMillimeter => As(ForcePerLengthUnit.MicronewtonPerMillimeter);
+        public T MicronewtonsPerMillimeter => As(ForcePerLengthUnit.MicronewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MillinewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MillinewtonsPerCentimeter.
         /// </summary>
-        public double MillinewtonsPerCentimeter => As(ForcePerLengthUnit.MillinewtonPerCentimeter);
+        public T MillinewtonsPerCentimeter => As(ForcePerLengthUnit.MillinewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MillinewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MillinewtonsPerMeter.
         /// </summary>
-        public double MillinewtonsPerMeter => As(ForcePerLengthUnit.MillinewtonPerMeter);
+        public T MillinewtonsPerMeter => As(ForcePerLengthUnit.MillinewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in MillinewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in MillinewtonsPerMillimeter.
         /// </summary>
-        public double MillinewtonsPerMillimeter => As(ForcePerLengthUnit.MillinewtonPerMillimeter);
+        public T MillinewtonsPerMillimeter => As(ForcePerLengthUnit.MillinewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in NanonewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in NanonewtonsPerCentimeter.
         /// </summary>
-        public double NanonewtonsPerCentimeter => As(ForcePerLengthUnit.NanonewtonPerCentimeter);
+        public T NanonewtonsPerCentimeter => As(ForcePerLengthUnit.NanonewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in NanonewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in NanonewtonsPerMeter.
         /// </summary>
-        public double NanonewtonsPerMeter => As(ForcePerLengthUnit.NanonewtonPerMeter);
+        public T NanonewtonsPerMeter => As(ForcePerLengthUnit.NanonewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in NanonewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in NanonewtonsPerMillimeter.
         /// </summary>
-        public double NanonewtonsPerMillimeter => As(ForcePerLengthUnit.NanonewtonPerMillimeter);
+        public T NanonewtonsPerMillimeter => As(ForcePerLengthUnit.NanonewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in NewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in NewtonsPerCentimeter.
         /// </summary>
-        public double NewtonsPerCentimeter => As(ForcePerLengthUnit.NewtonPerCentimeter);
+        public T NewtonsPerCentimeter => As(ForcePerLengthUnit.NewtonPerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in NewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in NewtonsPerMeter.
         /// </summary>
-        public double NewtonsPerMeter => As(ForcePerLengthUnit.NewtonPerMeter);
+        public T NewtonsPerMeter => As(ForcePerLengthUnit.NewtonPerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in NewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in NewtonsPerMillimeter.
         /// </summary>
-        public double NewtonsPerMillimeter => As(ForcePerLengthUnit.NewtonPerMillimeter);
+        public T NewtonsPerMillimeter => As(ForcePerLengthUnit.NewtonPerMillimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in PoundsForcePerFoot.
+        ///     Get <see cref="ForcePerLength{T}" /> in PoundsForcePerFoot.
         /// </summary>
-        public double PoundsForcePerFoot => As(ForcePerLengthUnit.PoundForcePerFoot);
+        public T PoundsForcePerFoot => As(ForcePerLengthUnit.PoundForcePerFoot);
 
         /// <summary>
-        ///     Get ForcePerLength in PoundsForcePerInch.
+        ///     Get <see cref="ForcePerLength{T}" /> in PoundsForcePerInch.
         /// </summary>
-        public double PoundsForcePerInch => As(ForcePerLengthUnit.PoundForcePerInch);
+        public T PoundsForcePerInch => As(ForcePerLengthUnit.PoundForcePerInch);
 
         /// <summary>
-        ///     Get ForcePerLength in PoundsForcePerYard.
+        ///     Get <see cref="ForcePerLength{T}" /> in PoundsForcePerYard.
         /// </summary>
-        public double PoundsForcePerYard => As(ForcePerLengthUnit.PoundForcePerYard);
+        public T PoundsForcePerYard => As(ForcePerLengthUnit.PoundForcePerYard);
 
         /// <summary>
-        ///     Get ForcePerLength in TonnesForcePerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in TonnesForcePerCentimeter.
         /// </summary>
-        public double TonnesForcePerCentimeter => As(ForcePerLengthUnit.TonneForcePerCentimeter);
+        public T TonnesForcePerCentimeter => As(ForcePerLengthUnit.TonneForcePerCentimeter);
 
         /// <summary>
-        ///     Get ForcePerLength in TonnesForcePerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in TonnesForcePerMeter.
         /// </summary>
-        public double TonnesForcePerMeter => As(ForcePerLengthUnit.TonneForcePerMeter);
+        public T TonnesForcePerMeter => As(ForcePerLengthUnit.TonneForcePerMeter);
 
         /// <summary>
-        ///     Get ForcePerLength in TonnesForcePerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> in TonnesForcePerMillimeter.
         /// </summary>
-        public double TonnesForcePerMillimeter => As(ForcePerLengthUnit.TonneForcePerMillimeter);
+        public T TonnesForcePerMillimeter => As(ForcePerLengthUnit.TonneForcePerMillimeter);
 
         #endregion
 
@@ -423,357 +421,319 @@ public static string GetAbbreviation(ForcePerLengthUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ForcePerLength from CentinewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from CentinewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerCentimeter(QuantityValue centinewtonspercentimeter)
+        public static ForcePerLength<T> FromCentinewtonsPerCentimeter(T centinewtonspercentimeter)
         {
-            double value = (double) centinewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter);
+            return new ForcePerLength<T>(centinewtonspercentimeter, ForcePerLengthUnit.CentinewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from CentinewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from CentinewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerMeter(QuantityValue centinewtonspermeter)
+        public static ForcePerLength<T> FromCentinewtonsPerMeter(T centinewtonspermeter)
         {
-            double value = (double) centinewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter);
+            return new ForcePerLength<T>(centinewtonspermeter, ForcePerLengthUnit.CentinewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from CentinewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from CentinewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerMillimeter(QuantityValue centinewtonspermillimeter)
+        public static ForcePerLength<T> FromCentinewtonsPerMillimeter(T centinewtonspermillimeter)
         {
-            double value = (double) centinewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter);
+            return new ForcePerLength<T>(centinewtonspermillimeter, ForcePerLengthUnit.CentinewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from DecanewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from DecanewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerCentimeter(QuantityValue decanewtonspercentimeter)
+        public static ForcePerLength<T> FromDecanewtonsPerCentimeter(T decanewtonspercentimeter)
         {
-            double value = (double) decanewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter);
+            return new ForcePerLength<T>(decanewtonspercentimeter, ForcePerLengthUnit.DecanewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from DecanewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from DecanewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerMeter(QuantityValue decanewtonspermeter)
+        public static ForcePerLength<T> FromDecanewtonsPerMeter(T decanewtonspermeter)
         {
-            double value = (double) decanewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter);
+            return new ForcePerLength<T>(decanewtonspermeter, ForcePerLengthUnit.DecanewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from DecanewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from DecanewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerMillimeter(QuantityValue decanewtonspermillimeter)
+        public static ForcePerLength<T> FromDecanewtonsPerMillimeter(T decanewtonspermillimeter)
         {
-            double value = (double) decanewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter);
+            return new ForcePerLength<T>(decanewtonspermillimeter, ForcePerLengthUnit.DecanewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from DecinewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from DecinewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerCentimeter(QuantityValue decinewtonspercentimeter)
+        public static ForcePerLength<T> FromDecinewtonsPerCentimeter(T decinewtonspercentimeter)
         {
-            double value = (double) decinewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter);
+            return new ForcePerLength<T>(decinewtonspercentimeter, ForcePerLengthUnit.DecinewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from DecinewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from DecinewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerMeter(QuantityValue decinewtonspermeter)
+        public static ForcePerLength<T> FromDecinewtonsPerMeter(T decinewtonspermeter)
         {
-            double value = (double) decinewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter);
+            return new ForcePerLength<T>(decinewtonspermeter, ForcePerLengthUnit.DecinewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from DecinewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from DecinewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerMillimeter(QuantityValue decinewtonspermillimeter)
+        public static ForcePerLength<T> FromDecinewtonsPerMillimeter(T decinewtonspermillimeter)
         {
-            double value = (double) decinewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter);
+            return new ForcePerLength<T>(decinewtonspermillimeter, ForcePerLengthUnit.DecinewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilogramsForcePerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilogramsForcePerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerCentimeter(QuantityValue kilogramsforcepercentimeter)
+        public static ForcePerLength<T> FromKilogramsForcePerCentimeter(T kilogramsforcepercentimeter)
         {
-            double value = (double) kilogramsforcepercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter);
+            return new ForcePerLength<T>(kilogramsforcepercentimeter, ForcePerLengthUnit.KilogramForcePerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilogramsForcePerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilogramsForcePerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerMeter(QuantityValue kilogramsforcepermeter)
+        public static ForcePerLength<T> FromKilogramsForcePerMeter(T kilogramsforcepermeter)
         {
-            double value = (double) kilogramsforcepermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter);
+            return new ForcePerLength<T>(kilogramsforcepermeter, ForcePerLengthUnit.KilogramForcePerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilogramsForcePerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilogramsForcePerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerMillimeter(QuantityValue kilogramsforcepermillimeter)
+        public static ForcePerLength<T> FromKilogramsForcePerMillimeter(T kilogramsforcepermillimeter)
         {
-            double value = (double) kilogramsforcepermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter);
+            return new ForcePerLength<T>(kilogramsforcepermillimeter, ForcePerLengthUnit.KilogramForcePerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilonewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilonewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerCentimeter(QuantityValue kilonewtonspercentimeter)
+        public static ForcePerLength<T> FromKilonewtonsPerCentimeter(T kilonewtonspercentimeter)
         {
-            double value = (double) kilonewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter);
+            return new ForcePerLength<T>(kilonewtonspercentimeter, ForcePerLengthUnit.KilonewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilonewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilonewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerMeter(QuantityValue kilonewtonspermeter)
+        public static ForcePerLength<T> FromKilonewtonsPerMeter(T kilonewtonspermeter)
         {
-            double value = (double) kilonewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter);
+            return new ForcePerLength<T>(kilonewtonspermeter, ForcePerLengthUnit.KilonewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilonewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilonewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerMillimeter(QuantityValue kilonewtonspermillimeter)
+        public static ForcePerLength<T> FromKilonewtonsPerMillimeter(T kilonewtonspermillimeter)
         {
-            double value = (double) kilonewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter);
+            return new ForcePerLength<T>(kilonewtonspermillimeter, ForcePerLengthUnit.KilonewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilopoundsForcePerFoot.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilopoundsForcePerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilopoundsForcePerFoot(QuantityValue kilopoundsforceperfoot)
+        public static ForcePerLength<T> FromKilopoundsForcePerFoot(T kilopoundsforceperfoot)
         {
-            double value = (double) kilopoundsforceperfoot;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot);
+            return new ForcePerLength<T>(kilopoundsforceperfoot, ForcePerLengthUnit.KilopoundForcePerFoot);
         }
         /// <summary>
-        ///     Get ForcePerLength from KilopoundsForcePerInch.
+        ///     Get <see cref="ForcePerLength{T}" /> from KilopoundsForcePerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilopoundsForcePerInch(QuantityValue kilopoundsforceperinch)
+        public static ForcePerLength<T> FromKilopoundsForcePerInch(T kilopoundsforceperinch)
         {
-            double value = (double) kilopoundsforceperinch;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch);
+            return new ForcePerLength<T>(kilopoundsforceperinch, ForcePerLengthUnit.KilopoundForcePerInch);
         }
         /// <summary>
-        ///     Get ForcePerLength from MeganewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MeganewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerCentimeter(QuantityValue meganewtonspercentimeter)
+        public static ForcePerLength<T> FromMeganewtonsPerCentimeter(T meganewtonspercentimeter)
         {
-            double value = (double) meganewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter);
+            return new ForcePerLength<T>(meganewtonspercentimeter, ForcePerLengthUnit.MeganewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MeganewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MeganewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerMeter(QuantityValue meganewtonspermeter)
+        public static ForcePerLength<T> FromMeganewtonsPerMeter(T meganewtonspermeter)
         {
-            double value = (double) meganewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter);
+            return new ForcePerLength<T>(meganewtonspermeter, ForcePerLengthUnit.MeganewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MeganewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MeganewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerMillimeter(QuantityValue meganewtonspermillimeter)
+        public static ForcePerLength<T> FromMeganewtonsPerMillimeter(T meganewtonspermillimeter)
         {
-            double value = (double) meganewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter);
+            return new ForcePerLength<T>(meganewtonspermillimeter, ForcePerLengthUnit.MeganewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MicronewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MicronewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerCentimeter(QuantityValue micronewtonspercentimeter)
+        public static ForcePerLength<T> FromMicronewtonsPerCentimeter(T micronewtonspercentimeter)
         {
-            double value = (double) micronewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter);
+            return new ForcePerLength<T>(micronewtonspercentimeter, ForcePerLengthUnit.MicronewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MicronewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MicronewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerMeter(QuantityValue micronewtonspermeter)
+        public static ForcePerLength<T> FromMicronewtonsPerMeter(T micronewtonspermeter)
         {
-            double value = (double) micronewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter);
+            return new ForcePerLength<T>(micronewtonspermeter, ForcePerLengthUnit.MicronewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MicronewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MicronewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerMillimeter(QuantityValue micronewtonspermillimeter)
+        public static ForcePerLength<T> FromMicronewtonsPerMillimeter(T micronewtonspermillimeter)
         {
-            double value = (double) micronewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter);
+            return new ForcePerLength<T>(micronewtonspermillimeter, ForcePerLengthUnit.MicronewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MillinewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MillinewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerCentimeter(QuantityValue millinewtonspercentimeter)
+        public static ForcePerLength<T> FromMillinewtonsPerCentimeter(T millinewtonspercentimeter)
         {
-            double value = (double) millinewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter);
+            return new ForcePerLength<T>(millinewtonspercentimeter, ForcePerLengthUnit.MillinewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MillinewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MillinewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerMeter(QuantityValue millinewtonspermeter)
+        public static ForcePerLength<T> FromMillinewtonsPerMeter(T millinewtonspermeter)
         {
-            double value = (double) millinewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter);
+            return new ForcePerLength<T>(millinewtonspermeter, ForcePerLengthUnit.MillinewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from MillinewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from MillinewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerMillimeter(QuantityValue millinewtonspermillimeter)
+        public static ForcePerLength<T> FromMillinewtonsPerMillimeter(T millinewtonspermillimeter)
         {
-            double value = (double) millinewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter);
+            return new ForcePerLength<T>(millinewtonspermillimeter, ForcePerLengthUnit.MillinewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from NanonewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from NanonewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerCentimeter(QuantityValue nanonewtonspercentimeter)
+        public static ForcePerLength<T> FromNanonewtonsPerCentimeter(T nanonewtonspercentimeter)
         {
-            double value = (double) nanonewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter);
+            return new ForcePerLength<T>(nanonewtonspercentimeter, ForcePerLengthUnit.NanonewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from NanonewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from NanonewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerMeter(QuantityValue nanonewtonspermeter)
+        public static ForcePerLength<T> FromNanonewtonsPerMeter(T nanonewtonspermeter)
         {
-            double value = (double) nanonewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter);
+            return new ForcePerLength<T>(nanonewtonspermeter, ForcePerLengthUnit.NanonewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from NanonewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from NanonewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerMillimeter(QuantityValue nanonewtonspermillimeter)
+        public static ForcePerLength<T> FromNanonewtonsPerMillimeter(T nanonewtonspermillimeter)
         {
-            double value = (double) nanonewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter);
+            return new ForcePerLength<T>(nanonewtonspermillimeter, ForcePerLengthUnit.NanonewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from NewtonsPerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from NewtonsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerCentimeter(QuantityValue newtonspercentimeter)
+        public static ForcePerLength<T> FromNewtonsPerCentimeter(T newtonspercentimeter)
         {
-            double value = (double) newtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter);
+            return new ForcePerLength<T>(newtonspercentimeter, ForcePerLengthUnit.NewtonPerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from NewtonsPerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from NewtonsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerMeter(QuantityValue newtonspermeter)
+        public static ForcePerLength<T> FromNewtonsPerMeter(T newtonspermeter)
         {
-            double value = (double) newtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter);
+            return new ForcePerLength<T>(newtonspermeter, ForcePerLengthUnit.NewtonPerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from NewtonsPerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from NewtonsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerMillimeter(QuantityValue newtonspermillimeter)
+        public static ForcePerLength<T> FromNewtonsPerMillimeter(T newtonspermillimeter)
         {
-            double value = (double) newtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter);
+            return new ForcePerLength<T>(newtonspermillimeter, ForcePerLengthUnit.NewtonPerMillimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from PoundsForcePerFoot.
+        ///     Get <see cref="ForcePerLength{T}" /> from PoundsForcePerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerFoot(QuantityValue poundsforceperfoot)
+        public static ForcePerLength<T> FromPoundsForcePerFoot(T poundsforceperfoot)
         {
-            double value = (double) poundsforceperfoot;
-            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot);
+            return new ForcePerLength<T>(poundsforceperfoot, ForcePerLengthUnit.PoundForcePerFoot);
         }
         /// <summary>
-        ///     Get ForcePerLength from PoundsForcePerInch.
+        ///     Get <see cref="ForcePerLength{T}" /> from PoundsForcePerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerInch(QuantityValue poundsforceperinch)
+        public static ForcePerLength<T> FromPoundsForcePerInch(T poundsforceperinch)
         {
-            double value = (double) poundsforceperinch;
-            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch);
+            return new ForcePerLength<T>(poundsforceperinch, ForcePerLengthUnit.PoundForcePerInch);
         }
         /// <summary>
-        ///     Get ForcePerLength from PoundsForcePerYard.
+        ///     Get <see cref="ForcePerLength{T}" /> from PoundsForcePerYard.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerYard(QuantityValue poundsforceperyard)
+        public static ForcePerLength<T> FromPoundsForcePerYard(T poundsforceperyard)
         {
-            double value = (double) poundsforceperyard;
-            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard);
+            return new ForcePerLength<T>(poundsforceperyard, ForcePerLengthUnit.PoundForcePerYard);
         }
         /// <summary>
-        ///     Get ForcePerLength from TonnesForcePerCentimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from TonnesForcePerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerCentimeter(QuantityValue tonnesforcepercentimeter)
+        public static ForcePerLength<T> FromTonnesForcePerCentimeter(T tonnesforcepercentimeter)
         {
-            double value = (double) tonnesforcepercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter);
+            return new ForcePerLength<T>(tonnesforcepercentimeter, ForcePerLengthUnit.TonneForcePerCentimeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from TonnesForcePerMeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from TonnesForcePerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerMeter(QuantityValue tonnesforcepermeter)
+        public static ForcePerLength<T> FromTonnesForcePerMeter(T tonnesforcepermeter)
         {
-            double value = (double) tonnesforcepermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter);
+            return new ForcePerLength<T>(tonnesforcepermeter, ForcePerLengthUnit.TonneForcePerMeter);
         }
         /// <summary>
-        ///     Get ForcePerLength from TonnesForcePerMillimeter.
+        ///     Get <see cref="ForcePerLength{T}" /> from TonnesForcePerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerMillimeter(QuantityValue tonnesforcepermillimeter)
+        public static ForcePerLength<T> FromTonnesForcePerMillimeter(T tonnesforcepermillimeter)
         {
-            double value = (double) tonnesforcepermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter);
+            return new ForcePerLength<T>(tonnesforcepermillimeter, ForcePerLengthUnit.TonneForcePerMillimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ForcePerLengthUnit" /> to <see cref="ForcePerLength" />.
+        ///     Dynamically convert from value and unit enum <see cref="ForcePerLengthUnit" /> to <see cref="ForcePerLength{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ForcePerLength unit value.</returns>
-        public static ForcePerLength From(QuantityValue value, ForcePerLengthUnit fromUnit)
+        /// <returns><see cref="ForcePerLength{T}" /> unit value.</returns>
+        public static ForcePerLength<T> From(T value, ForcePerLengthUnit fromUnit)
         {
-            return new ForcePerLength((double)value, fromUnit);
+            return new ForcePerLength<T>(value, fromUnit);
         }
 
         #endregion
@@ -802,7 +762,7 @@ public static ForcePerLength From(QuantityValue value, ForcePerLengthUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ForcePerLength Parse(string str)
+        public static ForcePerLength<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -830,9 +790,9 @@ public static ForcePerLength Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ForcePerLength Parse(string str, IFormatProvider? provider)
+        public static ForcePerLength<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ForcePerLength, ForcePerLengthUnit>(
+            return QuantityParser.Default.Parse<T, ForcePerLength<T>, ForcePerLengthUnit>(
                 str,
                 provider,
                 From);
@@ -846,7 +806,7 @@ public static ForcePerLength Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ForcePerLength result)
+        public static bool TryParse(string? str, out ForcePerLength<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -861,9 +821,9 @@ public static bool TryParse(string? str, out ForcePerLength result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ForcePerLength result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ForcePerLength<T> result)
         {
-            return QuantityParser.Default.TryParse<ForcePerLength, ForcePerLengthUnit>(
+            return QuantityParser.Default.TryParse<T, ForcePerLength<T>, ForcePerLengthUnit>(
                 str,
                 provider,
                 From,
@@ -925,45 +885,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ForcePerLength operator -(ForcePerLength right)
+        public static ForcePerLength<T> operator -(ForcePerLength<T> right)
         {
-            return new ForcePerLength(-right.Value, right.Unit);
+            return new ForcePerLength<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from adding two <see cref="ForcePerLength"/>.</summary>
-        public static ForcePerLength operator +(ForcePerLength left, ForcePerLength right)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from adding two <see cref="ForcePerLength{T}"/>.</summary>
+        public static ForcePerLength<T> operator +(ForcePerLength<T> left, ForcePerLength<T> right)
         {
-            return new ForcePerLength(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ForcePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from subtracting two <see cref="ForcePerLength"/>.</summary>
-        public static ForcePerLength operator -(ForcePerLength left, ForcePerLength right)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from subtracting two <see cref="ForcePerLength{T}"/>.</summary>
+        public static ForcePerLength<T> operator -(ForcePerLength<T> left, ForcePerLength<T> right)
         {
-            return new ForcePerLength(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ForcePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from multiplying value and <see cref="ForcePerLength"/>.</summary>
-        public static ForcePerLength operator *(double left, ForcePerLength right)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from multiplying value and <see cref="ForcePerLength{T}"/>.</summary>
+        public static ForcePerLength<T> operator *(T left, ForcePerLength<T> right)
         {
-            return new ForcePerLength(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ForcePerLength<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from multiplying value and <see cref="ForcePerLength"/>.</summary>
-        public static ForcePerLength operator *(ForcePerLength left, double right)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from multiplying value and <see cref="ForcePerLength{T}"/>.</summary>
+        public static ForcePerLength<T> operator *(ForcePerLength<T> left, T right)
         {
-            return new ForcePerLength(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ForcePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ForcePerLength"/> from dividing <see cref="ForcePerLength"/> by value.</summary>
-        public static ForcePerLength operator /(ForcePerLength left, double right)
+        /// <summary>Get <see cref="ForcePerLength{T}"/> from dividing <see cref="ForcePerLength{T}"/> by value.</summary>
+        public static ForcePerLength<T> operator /(ForcePerLength<T> left, T right)
         {
-            return new ForcePerLength(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ForcePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ForcePerLength"/> by <see cref="ForcePerLength"/>.</summary>
-        public static double operator /(ForcePerLength left, ForcePerLength right)
+        /// <summary>Get ratio value from dividing <see cref="ForcePerLength{T}"/> by <see cref="ForcePerLength{T}"/>.</summary>
+        public static T operator /(ForcePerLength<T> left, ForcePerLength<T> right)
         {
-            return left.NewtonsPerMeter / right.NewtonsPerMeter;
+            return CompiledLambdas.Divide(left.NewtonsPerMeter, right.NewtonsPerMeter);
         }
 
         #endregion
@@ -971,39 +936,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ForcePerLength left, ForcePerLength right)
+        public static bool operator <=(ForcePerLength<T> left, ForcePerLength<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ForcePerLength left, ForcePerLength right)
+        public static bool operator >=(ForcePerLength<T> left, ForcePerLength<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ForcePerLength left, ForcePerLength right)
+        public static bool operator <(ForcePerLength<T> left, ForcePerLength<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ForcePerLength left, ForcePerLength right)
+        public static bool operator >(ForcePerLength<T> left, ForcePerLength<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ForcePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ForcePerLength left, ForcePerLength right)
+        /// <remarks>Consider using <see cref="Equals(ForcePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ForcePerLength<T> left, ForcePerLength<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ForcePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ForcePerLength left, ForcePerLength right)
+        /// <remarks>Consider using <see cref="Equals(ForcePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ForcePerLength<T> left, ForcePerLength<T> right)
         {
             return !(left == right);
         }
@@ -1012,37 +977,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Force
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ForcePerLength objForcePerLength)) throw new ArgumentException("Expected type ForcePerLength.", nameof(obj));
+            if(!(obj is ForcePerLength<T> objForcePerLength)) throw new ArgumentException("Expected type ForcePerLength.", nameof(obj));
 
             return CompareTo(objForcePerLength);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ForcePerLength other)
+        public int CompareTo(ForcePerLength<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ForcePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ForcePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ForcePerLength objForcePerLength))
+            if(obj is null || !(obj is ForcePerLength<T> objForcePerLength))
                 return false;
 
             return Equals(objForcePerLength);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ForcePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ForcePerLength other)
+        /// <remarks>Consider using <see cref="Equals(ForcePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ForcePerLength<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ForcePerLength within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ForcePerLength{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1080,21 +1045,19 @@ public bool Equals(ForcePerLength other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ForcePerLength other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ForcePerLength<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ForcePerLength.</returns>
+        /// <returns>A hash code for the current <see cref="ForcePerLength{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1108,17 +1071,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ForcePerLengthUnit unit)
+        public T As(ForcePerLengthUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1138,17 +1101,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ForcePerLengthUnit unitAsForcePerLengthUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForcePerLengthUnit)} is supported.", nameof(unit));
 
-            return As(unitAsForcePerLengthUnit);
+            var asValue = As(unitAsForcePerLengthUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ForcePerLengthUnit>.As(ForcePerLengthUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ForcePerLength to another ForcePerLength with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ForcePerLength{T}" /> to another <see cref="ForcePerLength{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ForcePerLength with the specified unit.</returns>
-        public ForcePerLength ToUnit(ForcePerLengthUnit unit)
+        /// <returns>A <see cref="ForcePerLength{T}" /> with the specified unit.</returns>
+        public ForcePerLength<T> ToUnit(ForcePerLengthUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ForcePerLength(convertedValue, unit);
+            return new ForcePerLength<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1161,7 +1129,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ForcePerLength ToUnit(UnitSystem unitSystem)
+        public ForcePerLength<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1181,56 +1149,62 @@ public ForcePerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ForcePerLengthUnit> IQuantity<ForcePerLengthUnit>.ToUnit(ForcePerLengthUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ForcePerLengthUnit, T> IQuantityT<ForcePerLengthUnit, T>.ToUnit(ForcePerLengthUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ForcePerLengthUnit> IQuantity<ForcePerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ForcePerLengthUnit, T> IQuantityT<ForcePerLengthUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ForcePerLengthUnit.CentinewtonPerCentimeter: return (_value*1e2) * 1e-2d;
-                case ForcePerLengthUnit.CentinewtonPerMeter: return (_value) * 1e-2d;
-                case ForcePerLengthUnit.CentinewtonPerMillimeter: return (_value*1e3) * 1e-2d;
-                case ForcePerLengthUnit.DecanewtonPerCentimeter: return (_value*1e2) * 1e1d;
-                case ForcePerLengthUnit.DecanewtonPerMeter: return (_value) * 1e1d;
-                case ForcePerLengthUnit.DecanewtonPerMillimeter: return (_value*1e3) * 1e1d;
-                case ForcePerLengthUnit.DecinewtonPerCentimeter: return (_value*1e2) * 1e-1d;
-                case ForcePerLengthUnit.DecinewtonPerMeter: return (_value) * 1e-1d;
-                case ForcePerLengthUnit.DecinewtonPerMillimeter: return (_value*1e3) * 1e-1d;
-                case ForcePerLengthUnit.KilogramForcePerCentimeter: return _value*980.665002864;
-                case ForcePerLengthUnit.KilogramForcePerMeter: return _value*9.80665002864;
-                case ForcePerLengthUnit.KilogramForcePerMillimeter: return _value*9.80665002864e3;
-                case ForcePerLengthUnit.KilonewtonPerCentimeter: return (_value*1e2) * 1e3d;
-                case ForcePerLengthUnit.KilonewtonPerMeter: return (_value) * 1e3d;
-                case ForcePerLengthUnit.KilonewtonPerMillimeter: return (_value*1e3) * 1e3d;
-                case ForcePerLengthUnit.KilopoundForcePerFoot: return _value*14593.90292;
-                case ForcePerLengthUnit.KilopoundForcePerInch: return _value*1.75126835e5;
-                case ForcePerLengthUnit.MeganewtonPerCentimeter: return (_value*1e2) * 1e6d;
-                case ForcePerLengthUnit.MeganewtonPerMeter: return (_value) * 1e6d;
-                case ForcePerLengthUnit.MeganewtonPerMillimeter: return (_value*1e3) * 1e6d;
-                case ForcePerLengthUnit.MicronewtonPerCentimeter: return (_value*1e2) * 1e-6d;
-                case ForcePerLengthUnit.MicronewtonPerMeter: return (_value) * 1e-6d;
-                case ForcePerLengthUnit.MicronewtonPerMillimeter: return (_value*1e3) * 1e-6d;
-                case ForcePerLengthUnit.MillinewtonPerCentimeter: return (_value*1e2) * 1e-3d;
-                case ForcePerLengthUnit.MillinewtonPerMeter: return (_value) * 1e-3d;
-                case ForcePerLengthUnit.MillinewtonPerMillimeter: return (_value*1e3) * 1e-3d;
-                case ForcePerLengthUnit.NanonewtonPerCentimeter: return (_value*1e2) * 1e-9d;
-                case ForcePerLengthUnit.NanonewtonPerMeter: return (_value) * 1e-9d;
-                case ForcePerLengthUnit.NanonewtonPerMillimeter: return (_value*1e3) * 1e-9d;
-                case ForcePerLengthUnit.NewtonPerCentimeter: return _value*1e2;
-                case ForcePerLengthUnit.NewtonPerMeter: return _value;
-                case ForcePerLengthUnit.NewtonPerMillimeter: return _value*1e3;
-                case ForcePerLengthUnit.PoundForcePerFoot: return _value*14.59390292;
-                case ForcePerLengthUnit.PoundForcePerInch: return _value*1.75126835e2;
-                case ForcePerLengthUnit.PoundForcePerYard: return _value*4.864634307;
-                case ForcePerLengthUnit.TonneForcePerCentimeter: return _value*9.80665002864e5;
-                case ForcePerLengthUnit.TonneForcePerMeter: return _value*9.80665002864e3;
-                case ForcePerLengthUnit.TonneForcePerMillimeter: return _value*9.80665002864e6;
+                case ForcePerLengthUnit.CentinewtonPerCentimeter: return (Value*1e2) * 1e-2d;
+                case ForcePerLengthUnit.CentinewtonPerMeter: return (Value) * 1e-2d;
+                case ForcePerLengthUnit.CentinewtonPerMillimeter: return (Value*1e3) * 1e-2d;
+                case ForcePerLengthUnit.DecanewtonPerCentimeter: return (Value*1e2) * 1e1d;
+                case ForcePerLengthUnit.DecanewtonPerMeter: return (Value) * 1e1d;
+                case ForcePerLengthUnit.DecanewtonPerMillimeter: return (Value*1e3) * 1e1d;
+                case ForcePerLengthUnit.DecinewtonPerCentimeter: return (Value*1e2) * 1e-1d;
+                case ForcePerLengthUnit.DecinewtonPerMeter: return (Value) * 1e-1d;
+                case ForcePerLengthUnit.DecinewtonPerMillimeter: return (Value*1e3) * 1e-1d;
+                case ForcePerLengthUnit.KilogramForcePerCentimeter: return Value*980.665002864;
+                case ForcePerLengthUnit.KilogramForcePerMeter: return Value*9.80665002864;
+                case ForcePerLengthUnit.KilogramForcePerMillimeter: return Value*9.80665002864e3;
+                case ForcePerLengthUnit.KilonewtonPerCentimeter: return (Value*1e2) * 1e3d;
+                case ForcePerLengthUnit.KilonewtonPerMeter: return (Value) * 1e3d;
+                case ForcePerLengthUnit.KilonewtonPerMillimeter: return (Value*1e3) * 1e3d;
+                case ForcePerLengthUnit.KilopoundForcePerFoot: return Value*14593.90292;
+                case ForcePerLengthUnit.KilopoundForcePerInch: return Value*1.75126835e5;
+                case ForcePerLengthUnit.MeganewtonPerCentimeter: return (Value*1e2) * 1e6d;
+                case ForcePerLengthUnit.MeganewtonPerMeter: return (Value) * 1e6d;
+                case ForcePerLengthUnit.MeganewtonPerMillimeter: return (Value*1e3) * 1e6d;
+                case ForcePerLengthUnit.MicronewtonPerCentimeter: return (Value*1e2) * 1e-6d;
+                case ForcePerLengthUnit.MicronewtonPerMeter: return (Value) * 1e-6d;
+                case ForcePerLengthUnit.MicronewtonPerMillimeter: return (Value*1e3) * 1e-6d;
+                case ForcePerLengthUnit.MillinewtonPerCentimeter: return (Value*1e2) * 1e-3d;
+                case ForcePerLengthUnit.MillinewtonPerMeter: return (Value) * 1e-3d;
+                case ForcePerLengthUnit.MillinewtonPerMillimeter: return (Value*1e3) * 1e-3d;
+                case ForcePerLengthUnit.NanonewtonPerCentimeter: return (Value*1e2) * 1e-9d;
+                case ForcePerLengthUnit.NanonewtonPerMeter: return (Value) * 1e-9d;
+                case ForcePerLengthUnit.NanonewtonPerMillimeter: return (Value*1e3) * 1e-9d;
+                case ForcePerLengthUnit.NewtonPerCentimeter: return Value*1e2;
+                case ForcePerLengthUnit.NewtonPerMeter: return Value;
+                case ForcePerLengthUnit.NewtonPerMillimeter: return Value*1e3;
+                case ForcePerLengthUnit.PoundForcePerFoot: return Value*14.59390292;
+                case ForcePerLengthUnit.PoundForcePerInch: return Value*1.75126835e2;
+                case ForcePerLengthUnit.PoundForcePerYard: return Value*4.864634307;
+                case ForcePerLengthUnit.TonneForcePerCentimeter: return Value*9.80665002864e5;
+                case ForcePerLengthUnit.TonneForcePerMeter: return Value*9.80665002864e3;
+                case ForcePerLengthUnit.TonneForcePerMillimeter: return Value*9.80665002864e6;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1241,16 +1215,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ForcePerLength ToBaseUnit()
+        internal ForcePerLength<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ForcePerLength(baseUnitValue, BaseUnit);
+            return new ForcePerLength<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ForcePerLengthUnit unit)
+        private T GetValueAs(ForcePerLengthUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1390,57 +1364,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ForcePerLength)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ForcePerLength<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ForcePerLength)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ForcePerLength<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ForcePerLength)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ForcePerLength<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1450,33 +1424,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ForcePerLength))
+            if(conversionType == typeof(ForcePerLength<T>))
                 return this;
             else if(conversionType == typeof(ForcePerLengthUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ForcePerLength.QuantityType;
+                return ForcePerLength<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ForcePerLength.Info;
+                return ForcePerLength<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ForcePerLength.BaseDimensions;
+                return ForcePerLength<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ForcePerLength)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ForcePerLength<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
index a93b883e77..89f35f7caf 100644
--- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The number of occurrences of a repeating event per unit time.
     /// </summary>
-    public partial struct Frequency : IQuantity<FrequencyUnit>, IEquatable<Frequency>, IComparable, IComparable<Frequency>, IConvertible, IFormattable
+    public partial struct Frequency<T> : IQuantityT<FrequencyUnit, T>, IEquatable<Frequency<T>>, IComparable, IComparable<Frequency<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -72,12 +68,12 @@ static Frequency()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Frequency(double value, FrequencyUnit unit)
+        public Frequency(T value, FrequencyUnit unit)
         {
             if(unit == FrequencyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -89,14 +85,14 @@ public Frequency(double value, FrequencyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Frequency(double value, UnitSystem unitSystem)
+        public Frequency(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -111,19 +107,19 @@ public Frequency(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Frequency, which is Hertz. All conversions go via this value.
+        ///     The base unit of <see cref="Frequency{T}" />, which is Hertz. All conversions go via this value.
         /// </summary>
         public static FrequencyUnit BaseUnit { get; } = FrequencyUnit.Hertz;
 
         /// <summary>
-        /// Represents the largest possible value of Frequency
+        /// Represents the largest possible value of <see cref="Frequency{T}" />
         /// </summary>
-        public static Frequency MaxValue { get; } = new Frequency(double.MaxValue, BaseUnit);
+        public static Frequency<T> MaxValue { get; } = new Frequency<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Frequency
+        /// Represents the smallest possible value of <see cref="Frequency{T}" />
         /// </summary>
-        public static Frequency MinValue { get; } = new Frequency(double.MinValue, BaseUnit);
+        public static Frequency<T> MinValue { get; } = new Frequency<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -132,14 +128,14 @@ public Frequency(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Frequency;
 
         /// <summary>
-        ///     All units of measurement for the Frequency quantity.
+        ///     All units of measurement for the <see cref="Frequency{T}" /> quantity.
         /// </summary>
         public static FrequencyUnit[] Units { get; } = Enum.GetValues(typeof(FrequencyUnit)).Cast<FrequencyUnit>().Except(new FrequencyUnit[]{ FrequencyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Hertz.
         /// </summary>
-        public static Frequency Zero { get; } = new Frequency(0, BaseUnit);
+        public static Frequency<T> Zero { get; } = new Frequency<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -148,7 +144,9 @@ public Frequency(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -164,66 +162,66 @@ public Frequency(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Frequency.QuantityType;
+        public QuantityType Type => Frequency<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Frequency.BaseDimensions;
+        public BaseDimensions Dimensions => Frequency<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Frequency in BeatsPerMinute.
+        ///     Get <see cref="Frequency{T}" /> in BeatsPerMinute.
         /// </summary>
-        public double BeatsPerMinute => As(FrequencyUnit.BeatPerMinute);
+        public T BeatsPerMinute => As(FrequencyUnit.BeatPerMinute);
 
         /// <summary>
-        ///     Get Frequency in CyclesPerHour.
+        ///     Get <see cref="Frequency{T}" /> in CyclesPerHour.
         /// </summary>
-        public double CyclesPerHour => As(FrequencyUnit.CyclePerHour);
+        public T CyclesPerHour => As(FrequencyUnit.CyclePerHour);
 
         /// <summary>
-        ///     Get Frequency in CyclesPerMinute.
+        ///     Get <see cref="Frequency{T}" /> in CyclesPerMinute.
         /// </summary>
-        public double CyclesPerMinute => As(FrequencyUnit.CyclePerMinute);
+        public T CyclesPerMinute => As(FrequencyUnit.CyclePerMinute);
 
         /// <summary>
-        ///     Get Frequency in Gigahertz.
+        ///     Get <see cref="Frequency{T}" /> in Gigahertz.
         /// </summary>
-        public double Gigahertz => As(FrequencyUnit.Gigahertz);
+        public T Gigahertz => As(FrequencyUnit.Gigahertz);
 
         /// <summary>
-        ///     Get Frequency in Hertz.
+        ///     Get <see cref="Frequency{T}" /> in Hertz.
         /// </summary>
-        public double Hertz => As(FrequencyUnit.Hertz);
+        public T Hertz => As(FrequencyUnit.Hertz);
 
         /// <summary>
-        ///     Get Frequency in Kilohertz.
+        ///     Get <see cref="Frequency{T}" /> in Kilohertz.
         /// </summary>
-        public double Kilohertz => As(FrequencyUnit.Kilohertz);
+        public T Kilohertz => As(FrequencyUnit.Kilohertz);
 
         /// <summary>
-        ///     Get Frequency in Megahertz.
+        ///     Get <see cref="Frequency{T}" /> in Megahertz.
         /// </summary>
-        public double Megahertz => As(FrequencyUnit.Megahertz);
+        public T Megahertz => As(FrequencyUnit.Megahertz);
 
         /// <summary>
-        ///     Get Frequency in PerSecond.
+        ///     Get <see cref="Frequency{T}" /> in PerSecond.
         /// </summary>
-        public double PerSecond => As(FrequencyUnit.PerSecond);
+        public T PerSecond => As(FrequencyUnit.PerSecond);
 
         /// <summary>
-        ///     Get Frequency in RadiansPerSecond.
+        ///     Get <see cref="Frequency{T}" /> in RadiansPerSecond.
         /// </summary>
-        public double RadiansPerSecond => As(FrequencyUnit.RadianPerSecond);
+        public T RadiansPerSecond => As(FrequencyUnit.RadianPerSecond);
 
         /// <summary>
-        ///     Get Frequency in Terahertz.
+        ///     Get <see cref="Frequency{T}" /> in Terahertz.
         /// </summary>
-        public double Terahertz => As(FrequencyUnit.Terahertz);
+        public T Terahertz => As(FrequencyUnit.Terahertz);
 
         #endregion
 
@@ -255,105 +253,95 @@ public static string GetAbbreviation(FrequencyUnit unit, IFormatProvider? provid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Frequency from BeatsPerMinute.
+        ///     Get <see cref="Frequency{T}" /> from BeatsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromBeatsPerMinute(QuantityValue beatsperminute)
+        public static Frequency<T> FromBeatsPerMinute(T beatsperminute)
         {
-            double value = (double) beatsperminute;
-            return new Frequency(value, FrequencyUnit.BeatPerMinute);
+            return new Frequency<T>(beatsperminute, FrequencyUnit.BeatPerMinute);
         }
         /// <summary>
-        ///     Get Frequency from CyclesPerHour.
+        ///     Get <see cref="Frequency{T}" /> from CyclesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromCyclesPerHour(QuantityValue cyclesperhour)
+        public static Frequency<T> FromCyclesPerHour(T cyclesperhour)
         {
-            double value = (double) cyclesperhour;
-            return new Frequency(value, FrequencyUnit.CyclePerHour);
+            return new Frequency<T>(cyclesperhour, FrequencyUnit.CyclePerHour);
         }
         /// <summary>
-        ///     Get Frequency from CyclesPerMinute.
+        ///     Get <see cref="Frequency{T}" /> from CyclesPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromCyclesPerMinute(QuantityValue cyclesperminute)
+        public static Frequency<T> FromCyclesPerMinute(T cyclesperminute)
         {
-            double value = (double) cyclesperminute;
-            return new Frequency(value, FrequencyUnit.CyclePerMinute);
+            return new Frequency<T>(cyclesperminute, FrequencyUnit.CyclePerMinute);
         }
         /// <summary>
-        ///     Get Frequency from Gigahertz.
+        ///     Get <see cref="Frequency{T}" /> from Gigahertz.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromGigahertz(QuantityValue gigahertz)
+        public static Frequency<T> FromGigahertz(T gigahertz)
         {
-            double value = (double) gigahertz;
-            return new Frequency(value, FrequencyUnit.Gigahertz);
+            return new Frequency<T>(gigahertz, FrequencyUnit.Gigahertz);
         }
         /// <summary>
-        ///     Get Frequency from Hertz.
+        ///     Get <see cref="Frequency{T}" /> from Hertz.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromHertz(QuantityValue hertz)
+        public static Frequency<T> FromHertz(T hertz)
         {
-            double value = (double) hertz;
-            return new Frequency(value, FrequencyUnit.Hertz);
+            return new Frequency<T>(hertz, FrequencyUnit.Hertz);
         }
         /// <summary>
-        ///     Get Frequency from Kilohertz.
+        ///     Get <see cref="Frequency{T}" /> from Kilohertz.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromKilohertz(QuantityValue kilohertz)
+        public static Frequency<T> FromKilohertz(T kilohertz)
         {
-            double value = (double) kilohertz;
-            return new Frequency(value, FrequencyUnit.Kilohertz);
+            return new Frequency<T>(kilohertz, FrequencyUnit.Kilohertz);
         }
         /// <summary>
-        ///     Get Frequency from Megahertz.
+        ///     Get <see cref="Frequency{T}" /> from Megahertz.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromMegahertz(QuantityValue megahertz)
+        public static Frequency<T> FromMegahertz(T megahertz)
         {
-            double value = (double) megahertz;
-            return new Frequency(value, FrequencyUnit.Megahertz);
+            return new Frequency<T>(megahertz, FrequencyUnit.Megahertz);
         }
         /// <summary>
-        ///     Get Frequency from PerSecond.
+        ///     Get <see cref="Frequency{T}" /> from PerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromPerSecond(QuantityValue persecond)
+        public static Frequency<T> FromPerSecond(T persecond)
         {
-            double value = (double) persecond;
-            return new Frequency(value, FrequencyUnit.PerSecond);
+            return new Frequency<T>(persecond, FrequencyUnit.PerSecond);
         }
         /// <summary>
-        ///     Get Frequency from RadiansPerSecond.
+        ///     Get <see cref="Frequency{T}" /> from RadiansPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromRadiansPerSecond(QuantityValue radianspersecond)
+        public static Frequency<T> FromRadiansPerSecond(T radianspersecond)
         {
-            double value = (double) radianspersecond;
-            return new Frequency(value, FrequencyUnit.RadianPerSecond);
+            return new Frequency<T>(radianspersecond, FrequencyUnit.RadianPerSecond);
         }
         /// <summary>
-        ///     Get Frequency from Terahertz.
+        ///     Get <see cref="Frequency{T}" /> from Terahertz.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromTerahertz(QuantityValue terahertz)
+        public static Frequency<T> FromTerahertz(T terahertz)
         {
-            double value = (double) terahertz;
-            return new Frequency(value, FrequencyUnit.Terahertz);
+            return new Frequency<T>(terahertz, FrequencyUnit.Terahertz);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="FrequencyUnit" /> to <see cref="Frequency" />.
+        ///     Dynamically convert from value and unit enum <see cref="FrequencyUnit" /> to <see cref="Frequency{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Frequency unit value.</returns>
-        public static Frequency From(QuantityValue value, FrequencyUnit fromUnit)
+        /// <returns><see cref="Frequency{T}" /> unit value.</returns>
+        public static Frequency<T> From(T value, FrequencyUnit fromUnit)
         {
-            return new Frequency((double)value, fromUnit);
+            return new Frequency<T>(value, fromUnit);
         }
 
         #endregion
@@ -382,7 +370,7 @@ public static Frequency From(QuantityValue value, FrequencyUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Frequency Parse(string str)
+        public static Frequency<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -410,9 +398,9 @@ public static Frequency Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Frequency Parse(string str, IFormatProvider? provider)
+        public static Frequency<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Frequency, FrequencyUnit>(
+            return QuantityParser.Default.Parse<T, Frequency<T>, FrequencyUnit>(
                 str,
                 provider,
                 From);
@@ -426,7 +414,7 @@ public static Frequency Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Frequency result)
+        public static bool TryParse(string? str, out Frequency<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -441,9 +429,9 @@ public static bool TryParse(string? str, out Frequency result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Frequency result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Frequency<T> result)
         {
-            return QuantityParser.Default.TryParse<Frequency, FrequencyUnit>(
+            return QuantityParser.Default.TryParse<T, Frequency<T>, FrequencyUnit>(
                 str,
                 provider,
                 From,
@@ -505,45 +493,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Frequ
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Frequency operator -(Frequency right)
+        public static Frequency<T> operator -(Frequency<T> right)
         {
-            return new Frequency(-right.Value, right.Unit);
+            return new Frequency<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Frequency"/> from adding two <see cref="Frequency"/>.</summary>
-        public static Frequency operator +(Frequency left, Frequency right)
+        /// <summary>Get <see cref="Frequency{T}"/> from adding two <see cref="Frequency{T}"/>.</summary>
+        public static Frequency<T> operator +(Frequency<T> left, Frequency<T> right)
         {
-            return new Frequency(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Frequency<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Frequency"/> from subtracting two <see cref="Frequency"/>.</summary>
-        public static Frequency operator -(Frequency left, Frequency right)
+        /// <summary>Get <see cref="Frequency{T}"/> from subtracting two <see cref="Frequency{T}"/>.</summary>
+        public static Frequency<T> operator -(Frequency<T> left, Frequency<T> right)
         {
-            return new Frequency(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Frequency<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Frequency"/> from multiplying value and <see cref="Frequency"/>.</summary>
-        public static Frequency operator *(double left, Frequency right)
+        /// <summary>Get <see cref="Frequency{T}"/> from multiplying value and <see cref="Frequency{T}"/>.</summary>
+        public static Frequency<T> operator *(T left, Frequency<T> right)
         {
-            return new Frequency(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Frequency<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Frequency"/> from multiplying value and <see cref="Frequency"/>.</summary>
-        public static Frequency operator *(Frequency left, double right)
+        /// <summary>Get <see cref="Frequency{T}"/> from multiplying value and <see cref="Frequency{T}"/>.</summary>
+        public static Frequency<T> operator *(Frequency<T> left, T right)
         {
-            return new Frequency(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Frequency<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Frequency"/> from dividing <see cref="Frequency"/> by value.</summary>
-        public static Frequency operator /(Frequency left, double right)
+        /// <summary>Get <see cref="Frequency{T}"/> from dividing <see cref="Frequency{T}"/> by value.</summary>
+        public static Frequency<T> operator /(Frequency<T> left, T right)
         {
-            return new Frequency(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Frequency<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Frequency"/> by <see cref="Frequency"/>.</summary>
-        public static double operator /(Frequency left, Frequency right)
+        /// <summary>Get ratio value from dividing <see cref="Frequency{T}"/> by <see cref="Frequency{T}"/>.</summary>
+        public static T operator /(Frequency<T> left, Frequency<T> right)
         {
-            return left.Hertz / right.Hertz;
+            return CompiledLambdas.Divide(left.Hertz, right.Hertz);
         }
 
         #endregion
@@ -551,39 +544,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Frequ
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Frequency left, Frequency right)
+        public static bool operator <=(Frequency<T> left, Frequency<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Frequency left, Frequency right)
+        public static bool operator >=(Frequency<T> left, Frequency<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Frequency left, Frequency right)
+        public static bool operator <(Frequency<T> left, Frequency<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Frequency left, Frequency right)
+        public static bool operator >(Frequency<T> left, Frequency<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Frequency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Frequency left, Frequency right)
+        /// <remarks>Consider using <see cref="Equals(Frequency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Frequency<T> left, Frequency<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Frequency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Frequency left, Frequency right)
+        /// <remarks>Consider using <see cref="Equals(Frequency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Frequency<T> left, Frequency<T> right)
         {
             return !(left == right);
         }
@@ -592,37 +585,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Frequ
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Frequency objFrequency)) throw new ArgumentException("Expected type Frequency.", nameof(obj));
+            if(!(obj is Frequency<T> objFrequency)) throw new ArgumentException("Expected type Frequency.", nameof(obj));
 
             return CompareTo(objFrequency);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Frequency other)
+        public int CompareTo(Frequency<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Frequency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Frequency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Frequency objFrequency))
+            if(obj is null || !(obj is Frequency<T> objFrequency))
                 return false;
 
             return Equals(objFrequency);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Frequency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Frequency other)
+        /// <remarks>Consider using <see cref="Equals(Frequency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Frequency<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Frequency within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Frequency{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -660,21 +653,19 @@ public bool Equals(Frequency other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Frequency other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Frequency<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Frequency.</returns>
+        /// <returns>A hash code for the current <see cref="Frequency{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -688,17 +679,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(FrequencyUnit unit)
+        public T As(FrequencyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -718,17 +709,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is FrequencyUnit unitAsFrequencyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FrequencyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsFrequencyUnit);
+            var asValue = As(unitAsFrequencyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<FrequencyUnit>.As(FrequencyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Frequency to another Frequency with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Frequency{T}" /> to another <see cref="Frequency{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Frequency with the specified unit.</returns>
-        public Frequency ToUnit(FrequencyUnit unit)
+        /// <returns>A <see cref="Frequency{T}" /> with the specified unit.</returns>
+        public Frequency<T> ToUnit(FrequencyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Frequency(convertedValue, unit);
+            return new Frequency<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -741,7 +737,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Frequency ToUnit(UnitSystem unitSystem)
+        public Frequency<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -761,28 +757,34 @@ public Frequency ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<FrequencyUnit> IQuantity<FrequencyUnit>.ToUnit(FrequencyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<FrequencyUnit, T> IQuantityT<FrequencyUnit, T>.ToUnit(FrequencyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<FrequencyUnit> IQuantity<FrequencyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<FrequencyUnit, T> IQuantityT<FrequencyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case FrequencyUnit.BeatPerMinute: return _value/60;
-                case FrequencyUnit.CyclePerHour: return _value/3600;
-                case FrequencyUnit.CyclePerMinute: return _value/60;
-                case FrequencyUnit.Gigahertz: return (_value) * 1e9d;
-                case FrequencyUnit.Hertz: return _value;
-                case FrequencyUnit.Kilohertz: return (_value) * 1e3d;
-                case FrequencyUnit.Megahertz: return (_value) * 1e6d;
-                case FrequencyUnit.PerSecond: return _value;
-                case FrequencyUnit.RadianPerSecond: return _value/6.2831853072;
-                case FrequencyUnit.Terahertz: return (_value) * 1e12d;
+                case FrequencyUnit.BeatPerMinute: return Value/60;
+                case FrequencyUnit.CyclePerHour: return Value/3600;
+                case FrequencyUnit.CyclePerMinute: return Value/60;
+                case FrequencyUnit.Gigahertz: return (Value) * 1e9d;
+                case FrequencyUnit.Hertz: return Value;
+                case FrequencyUnit.Kilohertz: return (Value) * 1e3d;
+                case FrequencyUnit.Megahertz: return (Value) * 1e6d;
+                case FrequencyUnit.PerSecond: return Value;
+                case FrequencyUnit.RadianPerSecond: return Value/6.2831853072;
+                case FrequencyUnit.Terahertz: return (Value) * 1e12d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -793,16 +795,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Frequency ToBaseUnit()
+        internal Frequency<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Frequency(baseUnitValue, BaseUnit);
+            return new Frequency<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(FrequencyUnit unit)
+        private T GetValueAs(FrequencyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -914,57 +916,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Frequency)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Frequency<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Frequency)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Frequency<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Frequency)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Frequency<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -974,33 +976,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Frequency))
+            if(conversionType == typeof(Frequency<T>))
                 return this;
             else if(conversionType == typeof(FrequencyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Frequency.QuantityType;
+                return Frequency<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Frequency.Info;
+                return Frequency<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Frequency.BaseDimensions;
+                return Frequency<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Frequency)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Frequency<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
index 509c0ed70b..400abd8649 100644
--- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Fuel_efficiency
     /// </remarks>
-    public partial struct FuelEfficiency : IQuantity<FuelEfficiencyUnit>, IEquatable<FuelEfficiency>, IComparable, IComparable<FuelEfficiency>, IConvertible, IFormattable
+    public partial struct FuelEfficiency<T> : IQuantityT<FuelEfficiencyUnit, T>, IEquatable<FuelEfficiency<T>>, IComparable, IComparable<FuelEfficiency<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -69,12 +65,12 @@ static FuelEfficiency()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public FuelEfficiency(double value, FuelEfficiencyUnit unit)
+        public FuelEfficiency(T value, FuelEfficiencyUnit unit)
         {
             if(unit == FuelEfficiencyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -86,14 +82,14 @@ public FuelEfficiency(double value, FuelEfficiencyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public FuelEfficiency(double value, UnitSystem unitSystem)
+        public FuelEfficiency(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -108,19 +104,19 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of FuelEfficiency, which is LiterPer100Kilometers. All conversions go via this value.
+        ///     The base unit of <see cref="FuelEfficiency{T}" />, which is LiterPer100Kilometers. All conversions go via this value.
         /// </summary>
         public static FuelEfficiencyUnit BaseUnit { get; } = FuelEfficiencyUnit.LiterPer100Kilometers;
 
         /// <summary>
-        /// Represents the largest possible value of FuelEfficiency
+        /// Represents the largest possible value of <see cref="FuelEfficiency{T}" />
         /// </summary>
-        public static FuelEfficiency MaxValue { get; } = new FuelEfficiency(double.MaxValue, BaseUnit);
+        public static FuelEfficiency<T> MaxValue { get; } = new FuelEfficiency<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of FuelEfficiency
+        /// Represents the smallest possible value of <see cref="FuelEfficiency{T}" />
         /// </summary>
-        public static FuelEfficiency MinValue { get; } = new FuelEfficiency(double.MinValue, BaseUnit);
+        public static FuelEfficiency<T> MinValue { get; } = new FuelEfficiency<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -129,14 +125,14 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.FuelEfficiency;
 
         /// <summary>
-        ///     All units of measurement for the FuelEfficiency quantity.
+        ///     All units of measurement for the <see cref="FuelEfficiency{T}" /> quantity.
         /// </summary>
         public static FuelEfficiencyUnit[] Units { get; } = Enum.GetValues(typeof(FuelEfficiencyUnit)).Cast<FuelEfficiencyUnit>().Except(new FuelEfficiencyUnit[]{ FuelEfficiencyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit LiterPer100Kilometers.
         /// </summary>
-        public static FuelEfficiency Zero { get; } = new FuelEfficiency(0, BaseUnit);
+        public static FuelEfficiency<T> Zero { get; } = new FuelEfficiency<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -145,7 +141,9 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -161,36 +159,36 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => FuelEfficiency.QuantityType;
+        public QuantityType Type => FuelEfficiency<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => FuelEfficiency.BaseDimensions;
+        public BaseDimensions Dimensions => FuelEfficiency<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get FuelEfficiency in KilometersPerLiters.
+        ///     Get <see cref="FuelEfficiency{T}" /> in KilometersPerLiters.
         /// </summary>
-        public double KilometersPerLiters => As(FuelEfficiencyUnit.KilometerPerLiter);
+        public T KilometersPerLiters => As(FuelEfficiencyUnit.KilometerPerLiter);
 
         /// <summary>
-        ///     Get FuelEfficiency in LitersPer100Kilometers.
+        ///     Get <see cref="FuelEfficiency{T}" /> in LitersPer100Kilometers.
         /// </summary>
-        public double LitersPer100Kilometers => As(FuelEfficiencyUnit.LiterPer100Kilometers);
+        public T LitersPer100Kilometers => As(FuelEfficiencyUnit.LiterPer100Kilometers);
 
         /// <summary>
-        ///     Get FuelEfficiency in MilesPerUkGallon.
+        ///     Get <see cref="FuelEfficiency{T}" /> in MilesPerUkGallon.
         /// </summary>
-        public double MilesPerUkGallon => As(FuelEfficiencyUnit.MilePerUkGallon);
+        public T MilesPerUkGallon => As(FuelEfficiencyUnit.MilePerUkGallon);
 
         /// <summary>
-        ///     Get FuelEfficiency in MilesPerUsGallon.
+        ///     Get <see cref="FuelEfficiency{T}" /> in MilesPerUsGallon.
         /// </summary>
-        public double MilesPerUsGallon => As(FuelEfficiencyUnit.MilePerUsGallon);
+        public T MilesPerUsGallon => As(FuelEfficiencyUnit.MilePerUsGallon);
 
         #endregion
 
@@ -222,51 +220,47 @@ public static string GetAbbreviation(FuelEfficiencyUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get FuelEfficiency from KilometersPerLiters.
+        ///     Get <see cref="FuelEfficiency{T}" /> from KilometersPerLiters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromKilometersPerLiters(QuantityValue kilometersperliters)
+        public static FuelEfficiency<T> FromKilometersPerLiters(T kilometersperliters)
         {
-            double value = (double) kilometersperliters;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter);
+            return new FuelEfficiency<T>(kilometersperliters, FuelEfficiencyUnit.KilometerPerLiter);
         }
         /// <summary>
-        ///     Get FuelEfficiency from LitersPer100Kilometers.
+        ///     Get <see cref="FuelEfficiency{T}" /> from LitersPer100Kilometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromLitersPer100Kilometers(QuantityValue litersper100kilometers)
+        public static FuelEfficiency<T> FromLitersPer100Kilometers(T litersper100kilometers)
         {
-            double value = (double) litersper100kilometers;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers);
+            return new FuelEfficiency<T>(litersper100kilometers, FuelEfficiencyUnit.LiterPer100Kilometers);
         }
         /// <summary>
-        ///     Get FuelEfficiency from MilesPerUkGallon.
+        ///     Get <see cref="FuelEfficiency{T}" /> from MilesPerUkGallon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromMilesPerUkGallon(QuantityValue milesperukgallon)
+        public static FuelEfficiency<T> FromMilesPerUkGallon(T milesperukgallon)
         {
-            double value = (double) milesperukgallon;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon);
+            return new FuelEfficiency<T>(milesperukgallon, FuelEfficiencyUnit.MilePerUkGallon);
         }
         /// <summary>
-        ///     Get FuelEfficiency from MilesPerUsGallon.
+        ///     Get <see cref="FuelEfficiency{T}" /> from MilesPerUsGallon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromMilesPerUsGallon(QuantityValue milesperusgallon)
+        public static FuelEfficiency<T> FromMilesPerUsGallon(T milesperusgallon)
         {
-            double value = (double) milesperusgallon;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon);
+            return new FuelEfficiency<T>(milesperusgallon, FuelEfficiencyUnit.MilePerUsGallon);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="FuelEfficiencyUnit" /> to <see cref="FuelEfficiency" />.
+        ///     Dynamically convert from value and unit enum <see cref="FuelEfficiencyUnit" /> to <see cref="FuelEfficiency{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>FuelEfficiency unit value.</returns>
-        public static FuelEfficiency From(QuantityValue value, FuelEfficiencyUnit fromUnit)
+        /// <returns><see cref="FuelEfficiency{T}" /> unit value.</returns>
+        public static FuelEfficiency<T> From(T value, FuelEfficiencyUnit fromUnit)
         {
-            return new FuelEfficiency((double)value, fromUnit);
+            return new FuelEfficiency<T>(value, fromUnit);
         }
 
         #endregion
@@ -295,7 +289,7 @@ public static FuelEfficiency From(QuantityValue value, FuelEfficiencyUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static FuelEfficiency Parse(string str)
+        public static FuelEfficiency<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -323,9 +317,9 @@ public static FuelEfficiency Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static FuelEfficiency Parse(string str, IFormatProvider? provider)
+        public static FuelEfficiency<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<FuelEfficiency, FuelEfficiencyUnit>(
+            return QuantityParser.Default.Parse<T, FuelEfficiency<T>, FuelEfficiencyUnit>(
                 str,
                 provider,
                 From);
@@ -339,7 +333,7 @@ public static FuelEfficiency Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out FuelEfficiency result)
+        public static bool TryParse(string? str, out FuelEfficiency<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -354,9 +348,9 @@ public static bool TryParse(string? str, out FuelEfficiency result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out FuelEfficiency result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out FuelEfficiency<T> result)
         {
-            return QuantityParser.Default.TryParse<FuelEfficiency, FuelEfficiencyUnit>(
+            return QuantityParser.Default.TryParse<T, FuelEfficiency<T>, FuelEfficiencyUnit>(
                 str,
                 provider,
                 From,
@@ -418,45 +412,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out FuelE
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static FuelEfficiency operator -(FuelEfficiency right)
+        public static FuelEfficiency<T> operator -(FuelEfficiency<T> right)
         {
-            return new FuelEfficiency(-right.Value, right.Unit);
+            return new FuelEfficiency<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="FuelEfficiency"/> from adding two <see cref="FuelEfficiency"/>.</summary>
-        public static FuelEfficiency operator +(FuelEfficiency left, FuelEfficiency right)
+        /// <summary>Get <see cref="FuelEfficiency{T}"/> from adding two <see cref="FuelEfficiency{T}"/>.</summary>
+        public static FuelEfficiency<T> operator +(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
-            return new FuelEfficiency(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new FuelEfficiency<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="FuelEfficiency"/> from subtracting two <see cref="FuelEfficiency"/>.</summary>
-        public static FuelEfficiency operator -(FuelEfficiency left, FuelEfficiency right)
+        /// <summary>Get <see cref="FuelEfficiency{T}"/> from subtracting two <see cref="FuelEfficiency{T}"/>.</summary>
+        public static FuelEfficiency<T> operator -(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
-            return new FuelEfficiency(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new FuelEfficiency<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="FuelEfficiency"/> from multiplying value and <see cref="FuelEfficiency"/>.</summary>
-        public static FuelEfficiency operator *(double left, FuelEfficiency right)
+        /// <summary>Get <see cref="FuelEfficiency{T}"/> from multiplying value and <see cref="FuelEfficiency{T}"/>.</summary>
+        public static FuelEfficiency<T> operator *(T left, FuelEfficiency<T> right)
         {
-            return new FuelEfficiency(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new FuelEfficiency<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="FuelEfficiency"/> from multiplying value and <see cref="FuelEfficiency"/>.</summary>
-        public static FuelEfficiency operator *(FuelEfficiency left, double right)
+        /// <summary>Get <see cref="FuelEfficiency{T}"/> from multiplying value and <see cref="FuelEfficiency{T}"/>.</summary>
+        public static FuelEfficiency<T> operator *(FuelEfficiency<T> left, T right)
         {
-            return new FuelEfficiency(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new FuelEfficiency<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="FuelEfficiency"/> from dividing <see cref="FuelEfficiency"/> by value.</summary>
-        public static FuelEfficiency operator /(FuelEfficiency left, double right)
+        /// <summary>Get <see cref="FuelEfficiency{T}"/> from dividing <see cref="FuelEfficiency{T}"/> by value.</summary>
+        public static FuelEfficiency<T> operator /(FuelEfficiency<T> left, T right)
         {
-            return new FuelEfficiency(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new FuelEfficiency<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="FuelEfficiency"/> by <see cref="FuelEfficiency"/>.</summary>
-        public static double operator /(FuelEfficiency left, FuelEfficiency right)
+        /// <summary>Get ratio value from dividing <see cref="FuelEfficiency{T}"/> by <see cref="FuelEfficiency{T}"/>.</summary>
+        public static T operator /(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
-            return left.LitersPer100Kilometers / right.LitersPer100Kilometers;
+            return CompiledLambdas.Divide(left.LitersPer100Kilometers, right.LitersPer100Kilometers);
         }
 
         #endregion
@@ -464,39 +463,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out FuelE
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(FuelEfficiency left, FuelEfficiency right)
+        public static bool operator <=(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(FuelEfficiency left, FuelEfficiency right)
+        public static bool operator >=(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(FuelEfficiency left, FuelEfficiency right)
+        public static bool operator <(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(FuelEfficiency left, FuelEfficiency right)
+        public static bool operator >(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(FuelEfficiency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(FuelEfficiency left, FuelEfficiency right)
+        /// <remarks>Consider using <see cref="Equals(FuelEfficiency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(FuelEfficiency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(FuelEfficiency left, FuelEfficiency right)
+        /// <remarks>Consider using <see cref="Equals(FuelEfficiency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(FuelEfficiency<T> left, FuelEfficiency<T> right)
         {
             return !(left == right);
         }
@@ -505,37 +504,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out FuelE
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is FuelEfficiency objFuelEfficiency)) throw new ArgumentException("Expected type FuelEfficiency.", nameof(obj));
+            if(!(obj is FuelEfficiency<T> objFuelEfficiency)) throw new ArgumentException("Expected type FuelEfficiency.", nameof(obj));
 
             return CompareTo(objFuelEfficiency);
         }
 
         /// <inheritdoc />
-        public int CompareTo(FuelEfficiency other)
+        public int CompareTo(FuelEfficiency<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(FuelEfficiency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(FuelEfficiency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is FuelEfficiency objFuelEfficiency))
+            if(obj is null || !(obj is FuelEfficiency<T> objFuelEfficiency))
                 return false;
 
             return Equals(objFuelEfficiency);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(FuelEfficiency, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(FuelEfficiency other)
+        /// <remarks>Consider using <see cref="Equals(FuelEfficiency{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(FuelEfficiency<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another FuelEfficiency within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="FuelEfficiency{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -573,21 +572,19 @@ public bool Equals(FuelEfficiency other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(FuelEfficiency other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(FuelEfficiency<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current FuelEfficiency.</returns>
+        /// <returns>A hash code for the current <see cref="FuelEfficiency{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -601,17 +598,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(FuelEfficiencyUnit unit)
+        public T As(FuelEfficiencyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -631,17 +628,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is FuelEfficiencyUnit unitAsFuelEfficiencyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FuelEfficiencyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsFuelEfficiencyUnit);
+            var asValue = As(unitAsFuelEfficiencyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<FuelEfficiencyUnit>.As(FuelEfficiencyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this FuelEfficiency to another FuelEfficiency with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="FuelEfficiency{T}" /> to another <see cref="FuelEfficiency{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A FuelEfficiency with the specified unit.</returns>
-        public FuelEfficiency ToUnit(FuelEfficiencyUnit unit)
+        /// <returns>A <see cref="FuelEfficiency{T}" /> with the specified unit.</returns>
+        public FuelEfficiency<T> ToUnit(FuelEfficiencyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new FuelEfficiency(convertedValue, unit);
+            return new FuelEfficiency<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -654,7 +656,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public FuelEfficiency ToUnit(UnitSystem unitSystem)
+        public FuelEfficiency<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -674,22 +676,28 @@ public FuelEfficiency ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<FuelEfficiencyUnit> IQuantity<FuelEfficiencyUnit>.ToUnit(FuelEfficiencyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<FuelEfficiencyUnit, T> IQuantityT<FuelEfficiencyUnit, T>.ToUnit(FuelEfficiencyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<FuelEfficiencyUnit> IQuantity<FuelEfficiencyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<FuelEfficiencyUnit, T> IQuantityT<FuelEfficiencyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case FuelEfficiencyUnit.KilometerPerLiter: return 100/_value;
-                case FuelEfficiencyUnit.LiterPer100Kilometers: return _value;
-                case FuelEfficiencyUnit.MilePerUkGallon: return (100*4.54609188)/(1.609344*_value);
-                case FuelEfficiencyUnit.MilePerUsGallon: return (100*3.785411784)/(1.609344*_value);
+                case FuelEfficiencyUnit.KilometerPerLiter: return 100/Value;
+                case FuelEfficiencyUnit.LiterPer100Kilometers: return Value;
+                case FuelEfficiencyUnit.MilePerUkGallon: return (100*4.54609188)/(1.609344*Value);
+                case FuelEfficiencyUnit.MilePerUsGallon: return (100*3.785411784)/(1.609344*Value);
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -700,16 +708,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal FuelEfficiency ToBaseUnit()
+        internal FuelEfficiency<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new FuelEfficiency(baseUnitValue, BaseUnit);
+            return new FuelEfficiency<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(FuelEfficiencyUnit unit)
+        private T GetValueAs(FuelEfficiencyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -815,57 +823,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(FuelEfficiency)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(FuelEfficiency<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(FuelEfficiency)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(FuelEfficiency<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(FuelEfficiency)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(FuelEfficiency<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -875,33 +883,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(FuelEfficiency))
+            if(conversionType == typeof(FuelEfficiency<T>))
                 return this;
             else if(conversionType == typeof(FuelEfficiencyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return FuelEfficiency.QuantityType;
+                return FuelEfficiency<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return FuelEfficiency.Info;
+                return FuelEfficiency<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return FuelEfficiency.BaseDimensions;
+                return FuelEfficiency<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(FuelEfficiency)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(FuelEfficiency<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
index 0b8bca97b9..aa1c0d7d34 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Heat flux is the flow of energy per unit of area per unit of time
     /// </summary>
-    public partial struct HeatFlux : IQuantity<HeatFluxUnit>, IEquatable<HeatFlux>, IComparable, IComparable<HeatFlux>, IConvertible, IFormattable
+    public partial struct HeatFlux<T> : IQuantityT<HeatFluxUnit, T>, IEquatable<HeatFlux<T>>, IComparable, IComparable<HeatFlux<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -80,12 +76,12 @@ static HeatFlux()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public HeatFlux(double value, HeatFluxUnit unit)
+        public HeatFlux(T value, HeatFluxUnit unit)
         {
             if(unit == HeatFluxUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -97,14 +93,14 @@ public HeatFlux(double value, HeatFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public HeatFlux(double value, UnitSystem unitSystem)
+        public HeatFlux(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -119,19 +115,19 @@ public HeatFlux(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of HeatFlux, which is WattPerSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="HeatFlux{T}" />, which is WattPerSquareMeter. All conversions go via this value.
         /// </summary>
         public static HeatFluxUnit BaseUnit { get; } = HeatFluxUnit.WattPerSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of HeatFlux
+        /// Represents the largest possible value of <see cref="HeatFlux{T}" />
         /// </summary>
-        public static HeatFlux MaxValue { get; } = new HeatFlux(double.MaxValue, BaseUnit);
+        public static HeatFlux<T> MaxValue { get; } = new HeatFlux<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of HeatFlux
+        /// Represents the smallest possible value of <see cref="HeatFlux{T}" />
         /// </summary>
-        public static HeatFlux MinValue { get; } = new HeatFlux(double.MinValue, BaseUnit);
+        public static HeatFlux<T> MinValue { get; } = new HeatFlux<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -140,14 +136,14 @@ public HeatFlux(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.HeatFlux;
 
         /// <summary>
-        ///     All units of measurement for the HeatFlux quantity.
+        ///     All units of measurement for the <see cref="HeatFlux{T}" /> quantity.
         /// </summary>
         public static HeatFluxUnit[] Units { get; } = Enum.GetValues(typeof(HeatFluxUnit)).Cast<HeatFluxUnit>().Except(new HeatFluxUnit[]{ HeatFluxUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit WattPerSquareMeter.
         /// </summary>
-        public static HeatFlux Zero { get; } = new HeatFlux(0, BaseUnit);
+        public static HeatFlux<T> Zero { get; } = new HeatFlux<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -156,7 +152,9 @@ public HeatFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -172,106 +170,106 @@ public HeatFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => HeatFlux.QuantityType;
+        public QuantityType Type => HeatFlux<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => HeatFlux.BaseDimensions;
+        public BaseDimensions Dimensions => HeatFlux<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get HeatFlux in BtusPerHourSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> in BtusPerHourSquareFoot.
         /// </summary>
-        public double BtusPerHourSquareFoot => As(HeatFluxUnit.BtuPerHourSquareFoot);
+        public T BtusPerHourSquareFoot => As(HeatFluxUnit.BtuPerHourSquareFoot);
 
         /// <summary>
-        ///     Get HeatFlux in BtusPerMinuteSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> in BtusPerMinuteSquareFoot.
         /// </summary>
-        public double BtusPerMinuteSquareFoot => As(HeatFluxUnit.BtuPerMinuteSquareFoot);
+        public T BtusPerMinuteSquareFoot => As(HeatFluxUnit.BtuPerMinuteSquareFoot);
 
         /// <summary>
-        ///     Get HeatFlux in BtusPerSecondSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> in BtusPerSecondSquareFoot.
         /// </summary>
-        public double BtusPerSecondSquareFoot => As(HeatFluxUnit.BtuPerSecondSquareFoot);
+        public T BtusPerSecondSquareFoot => As(HeatFluxUnit.BtuPerSecondSquareFoot);
 
         /// <summary>
-        ///     Get HeatFlux in BtusPerSecondSquareInch.
+        ///     Get <see cref="HeatFlux{T}" /> in BtusPerSecondSquareInch.
         /// </summary>
-        public double BtusPerSecondSquareInch => As(HeatFluxUnit.BtuPerSecondSquareInch);
+        public T BtusPerSecondSquareInch => As(HeatFluxUnit.BtuPerSecondSquareInch);
 
         /// <summary>
-        ///     Get HeatFlux in CaloriesPerSecondSquareCentimeter.
+        ///     Get <see cref="HeatFlux{T}" /> in CaloriesPerSecondSquareCentimeter.
         /// </summary>
-        public double CaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.CaloriePerSecondSquareCentimeter);
+        public T CaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.CaloriePerSecondSquareCentimeter);
 
         /// <summary>
-        ///     Get HeatFlux in CentiwattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in CentiwattsPerSquareMeter.
         /// </summary>
-        public double CentiwattsPerSquareMeter => As(HeatFluxUnit.CentiwattPerSquareMeter);
+        public T CentiwattsPerSquareMeter => As(HeatFluxUnit.CentiwattPerSquareMeter);
 
         /// <summary>
-        ///     Get HeatFlux in DeciwattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in DeciwattsPerSquareMeter.
         /// </summary>
-        public double DeciwattsPerSquareMeter => As(HeatFluxUnit.DeciwattPerSquareMeter);
+        public T DeciwattsPerSquareMeter => As(HeatFluxUnit.DeciwattPerSquareMeter);
 
         /// <summary>
-        ///     Get HeatFlux in KilocaloriesPerHourSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in KilocaloriesPerHourSquareMeter.
         /// </summary>
-        public double KilocaloriesPerHourSquareMeter => As(HeatFluxUnit.KilocaloriePerHourSquareMeter);
+        public T KilocaloriesPerHourSquareMeter => As(HeatFluxUnit.KilocaloriePerHourSquareMeter);
 
         /// <summary>
-        ///     Get HeatFlux in KilocaloriesPerSecondSquareCentimeter.
+        ///     Get <see cref="HeatFlux{T}" /> in KilocaloriesPerSecondSquareCentimeter.
         /// </summary>
-        public double KilocaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
+        public T KilocaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
 
         /// <summary>
-        ///     Get HeatFlux in KilowattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in KilowattsPerSquareMeter.
         /// </summary>
-        public double KilowattsPerSquareMeter => As(HeatFluxUnit.KilowattPerSquareMeter);
+        public T KilowattsPerSquareMeter => As(HeatFluxUnit.KilowattPerSquareMeter);
 
         /// <summary>
-        ///     Get HeatFlux in MicrowattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in MicrowattsPerSquareMeter.
         /// </summary>
-        public double MicrowattsPerSquareMeter => As(HeatFluxUnit.MicrowattPerSquareMeter);
+        public T MicrowattsPerSquareMeter => As(HeatFluxUnit.MicrowattPerSquareMeter);
 
         /// <summary>
-        ///     Get HeatFlux in MilliwattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in MilliwattsPerSquareMeter.
         /// </summary>
-        public double MilliwattsPerSquareMeter => As(HeatFluxUnit.MilliwattPerSquareMeter);
+        public T MilliwattsPerSquareMeter => As(HeatFluxUnit.MilliwattPerSquareMeter);
 
         /// <summary>
-        ///     Get HeatFlux in NanowattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in NanowattsPerSquareMeter.
         /// </summary>
-        public double NanowattsPerSquareMeter => As(HeatFluxUnit.NanowattPerSquareMeter);
+        public T NanowattsPerSquareMeter => As(HeatFluxUnit.NanowattPerSquareMeter);
 
         /// <summary>
-        ///     Get HeatFlux in PoundsForcePerFootSecond.
+        ///     Get <see cref="HeatFlux{T}" /> in PoundsForcePerFootSecond.
         /// </summary>
-        public double PoundsForcePerFootSecond => As(HeatFluxUnit.PoundForcePerFootSecond);
+        public T PoundsForcePerFootSecond => As(HeatFluxUnit.PoundForcePerFootSecond);
 
         /// <summary>
-        ///     Get HeatFlux in PoundsPerSecondCubed.
+        ///     Get <see cref="HeatFlux{T}" /> in PoundsPerSecondCubed.
         /// </summary>
-        public double PoundsPerSecondCubed => As(HeatFluxUnit.PoundPerSecondCubed);
+        public T PoundsPerSecondCubed => As(HeatFluxUnit.PoundPerSecondCubed);
 
         /// <summary>
-        ///     Get HeatFlux in WattsPerSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> in WattsPerSquareFoot.
         /// </summary>
-        public double WattsPerSquareFoot => As(HeatFluxUnit.WattPerSquareFoot);
+        public T WattsPerSquareFoot => As(HeatFluxUnit.WattPerSquareFoot);
 
         /// <summary>
-        ///     Get HeatFlux in WattsPerSquareInch.
+        ///     Get <see cref="HeatFlux{T}" /> in WattsPerSquareInch.
         /// </summary>
-        public double WattsPerSquareInch => As(HeatFluxUnit.WattPerSquareInch);
+        public T WattsPerSquareInch => As(HeatFluxUnit.WattPerSquareInch);
 
         /// <summary>
-        ///     Get HeatFlux in WattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> in WattsPerSquareMeter.
         /// </summary>
-        public double WattsPerSquareMeter => As(HeatFluxUnit.WattPerSquareMeter);
+        public T WattsPerSquareMeter => As(HeatFluxUnit.WattPerSquareMeter);
 
         #endregion
 
@@ -303,177 +301,159 @@ public static string GetAbbreviation(HeatFluxUnit unit, IFormatProvider? provide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get HeatFlux from BtusPerHourSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> from BtusPerHourSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerHourSquareFoot(QuantityValue btusperhoursquarefoot)
+        public static HeatFlux<T> FromBtusPerHourSquareFoot(T btusperhoursquarefoot)
         {
-            double value = (double) btusperhoursquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot);
+            return new HeatFlux<T>(btusperhoursquarefoot, HeatFluxUnit.BtuPerHourSquareFoot);
         }
         /// <summary>
-        ///     Get HeatFlux from BtusPerMinuteSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> from BtusPerMinuteSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerMinuteSquareFoot(QuantityValue btusperminutesquarefoot)
+        public static HeatFlux<T> FromBtusPerMinuteSquareFoot(T btusperminutesquarefoot)
         {
-            double value = (double) btusperminutesquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot);
+            return new HeatFlux<T>(btusperminutesquarefoot, HeatFluxUnit.BtuPerMinuteSquareFoot);
         }
         /// <summary>
-        ///     Get HeatFlux from BtusPerSecondSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> from BtusPerSecondSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerSecondSquareFoot(QuantityValue btuspersecondsquarefoot)
+        public static HeatFlux<T> FromBtusPerSecondSquareFoot(T btuspersecondsquarefoot)
         {
-            double value = (double) btuspersecondsquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot);
+            return new HeatFlux<T>(btuspersecondsquarefoot, HeatFluxUnit.BtuPerSecondSquareFoot);
         }
         /// <summary>
-        ///     Get HeatFlux from BtusPerSecondSquareInch.
+        ///     Get <see cref="HeatFlux{T}" /> from BtusPerSecondSquareInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerSecondSquareInch(QuantityValue btuspersecondsquareinch)
+        public static HeatFlux<T> FromBtusPerSecondSquareInch(T btuspersecondsquareinch)
         {
-            double value = (double) btuspersecondsquareinch;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch);
+            return new HeatFlux<T>(btuspersecondsquareinch, HeatFluxUnit.BtuPerSecondSquareInch);
         }
         /// <summary>
-        ///     Get HeatFlux from CaloriesPerSecondSquareCentimeter.
+        ///     Get <see cref="HeatFlux{T}" /> from CaloriesPerSecondSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(QuantityValue caloriespersecondsquarecentimeter)
+        public static HeatFlux<T> FromCaloriesPerSecondSquareCentimeter(T caloriespersecondsquarecentimeter)
         {
-            double value = (double) caloriespersecondsquarecentimeter;
-            return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
+            return new HeatFlux<T>(caloriespersecondsquarecentimeter, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
         }
         /// <summary>
-        ///     Get HeatFlux from CentiwattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from CentiwattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromCentiwattsPerSquareMeter(QuantityValue centiwattspersquaremeter)
+        public static HeatFlux<T> FromCentiwattsPerSquareMeter(T centiwattspersquaremeter)
         {
-            double value = (double) centiwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter);
+            return new HeatFlux<T>(centiwattspersquaremeter, HeatFluxUnit.CentiwattPerSquareMeter);
         }
         /// <summary>
-        ///     Get HeatFlux from DeciwattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from DeciwattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromDeciwattsPerSquareMeter(QuantityValue deciwattspersquaremeter)
+        public static HeatFlux<T> FromDeciwattsPerSquareMeter(T deciwattspersquaremeter)
         {
-            double value = (double) deciwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter);
+            return new HeatFlux<T>(deciwattspersquaremeter, HeatFluxUnit.DeciwattPerSquareMeter);
         }
         /// <summary>
-        ///     Get HeatFlux from KilocaloriesPerHourSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from KilocaloriesPerHourSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilocaloriesPerHourSquareMeter(QuantityValue kilocaloriesperhoursquaremeter)
+        public static HeatFlux<T> FromKilocaloriesPerHourSquareMeter(T kilocaloriesperhoursquaremeter)
         {
-            double value = (double) kilocaloriesperhoursquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter);
+            return new HeatFlux<T>(kilocaloriesperhoursquaremeter, HeatFluxUnit.KilocaloriePerHourSquareMeter);
         }
         /// <summary>
-        ///     Get HeatFlux from KilocaloriesPerSecondSquareCentimeter.
+        ///     Get <see cref="HeatFlux{T}" /> from KilocaloriesPerSecondSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(QuantityValue kilocaloriespersecondsquarecentimeter)
+        public static HeatFlux<T> FromKilocaloriesPerSecondSquareCentimeter(T kilocaloriespersecondsquarecentimeter)
         {
-            double value = (double) kilocaloriespersecondsquarecentimeter;
-            return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
+            return new HeatFlux<T>(kilocaloriespersecondsquarecentimeter, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
         }
         /// <summary>
-        ///     Get HeatFlux from KilowattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from KilowattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilowattsPerSquareMeter(QuantityValue kilowattspersquaremeter)
+        public static HeatFlux<T> FromKilowattsPerSquareMeter(T kilowattspersquaremeter)
         {
-            double value = (double) kilowattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter);
+            return new HeatFlux<T>(kilowattspersquaremeter, HeatFluxUnit.KilowattPerSquareMeter);
         }
         /// <summary>
-        ///     Get HeatFlux from MicrowattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from MicrowattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromMicrowattsPerSquareMeter(QuantityValue microwattspersquaremeter)
+        public static HeatFlux<T> FromMicrowattsPerSquareMeter(T microwattspersquaremeter)
         {
-            double value = (double) microwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter);
+            return new HeatFlux<T>(microwattspersquaremeter, HeatFluxUnit.MicrowattPerSquareMeter);
         }
         /// <summary>
-        ///     Get HeatFlux from MilliwattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from MilliwattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromMilliwattsPerSquareMeter(QuantityValue milliwattspersquaremeter)
+        public static HeatFlux<T> FromMilliwattsPerSquareMeter(T milliwattspersquaremeter)
         {
-            double value = (double) milliwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter);
+            return new HeatFlux<T>(milliwattspersquaremeter, HeatFluxUnit.MilliwattPerSquareMeter);
         }
         /// <summary>
-        ///     Get HeatFlux from NanowattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from NanowattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromNanowattsPerSquareMeter(QuantityValue nanowattspersquaremeter)
+        public static HeatFlux<T> FromNanowattsPerSquareMeter(T nanowattspersquaremeter)
         {
-            double value = (double) nanowattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter);
+            return new HeatFlux<T>(nanowattspersquaremeter, HeatFluxUnit.NanowattPerSquareMeter);
         }
         /// <summary>
-        ///     Get HeatFlux from PoundsForcePerFootSecond.
+        ///     Get <see cref="HeatFlux{T}" /> from PoundsForcePerFootSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromPoundsForcePerFootSecond(QuantityValue poundsforceperfootsecond)
+        public static HeatFlux<T> FromPoundsForcePerFootSecond(T poundsforceperfootsecond)
         {
-            double value = (double) poundsforceperfootsecond;
-            return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond);
+            return new HeatFlux<T>(poundsforceperfootsecond, HeatFluxUnit.PoundForcePerFootSecond);
         }
         /// <summary>
-        ///     Get HeatFlux from PoundsPerSecondCubed.
+        ///     Get <see cref="HeatFlux{T}" /> from PoundsPerSecondCubed.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromPoundsPerSecondCubed(QuantityValue poundspersecondcubed)
+        public static HeatFlux<T> FromPoundsPerSecondCubed(T poundspersecondcubed)
         {
-            double value = (double) poundspersecondcubed;
-            return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed);
+            return new HeatFlux<T>(poundspersecondcubed, HeatFluxUnit.PoundPerSecondCubed);
         }
         /// <summary>
-        ///     Get HeatFlux from WattsPerSquareFoot.
+        ///     Get <see cref="HeatFlux{T}" /> from WattsPerSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareFoot(QuantityValue wattspersquarefoot)
+        public static HeatFlux<T> FromWattsPerSquareFoot(T wattspersquarefoot)
         {
-            double value = (double) wattspersquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot);
+            return new HeatFlux<T>(wattspersquarefoot, HeatFluxUnit.WattPerSquareFoot);
         }
         /// <summary>
-        ///     Get HeatFlux from WattsPerSquareInch.
+        ///     Get <see cref="HeatFlux{T}" /> from WattsPerSquareInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareInch(QuantityValue wattspersquareinch)
+        public static HeatFlux<T> FromWattsPerSquareInch(T wattspersquareinch)
         {
-            double value = (double) wattspersquareinch;
-            return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch);
+            return new HeatFlux<T>(wattspersquareinch, HeatFluxUnit.WattPerSquareInch);
         }
         /// <summary>
-        ///     Get HeatFlux from WattsPerSquareMeter.
+        ///     Get <see cref="HeatFlux{T}" /> from WattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareMeter(QuantityValue wattspersquaremeter)
+        public static HeatFlux<T> FromWattsPerSquareMeter(T wattspersquaremeter)
         {
-            double value = (double) wattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter);
+            return new HeatFlux<T>(wattspersquaremeter, HeatFluxUnit.WattPerSquareMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="HeatFluxUnit" /> to <see cref="HeatFlux" />.
+        ///     Dynamically convert from value and unit enum <see cref="HeatFluxUnit" /> to <see cref="HeatFlux{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>HeatFlux unit value.</returns>
-        public static HeatFlux From(QuantityValue value, HeatFluxUnit fromUnit)
+        /// <returns><see cref="HeatFlux{T}" /> unit value.</returns>
+        public static HeatFlux<T> From(T value, HeatFluxUnit fromUnit)
         {
-            return new HeatFlux((double)value, fromUnit);
+            return new HeatFlux<T>(value, fromUnit);
         }
 
         #endregion
@@ -502,7 +482,7 @@ public static HeatFlux From(QuantityValue value, HeatFluxUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static HeatFlux Parse(string str)
+        public static HeatFlux<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -530,9 +510,9 @@ public static HeatFlux Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static HeatFlux Parse(string str, IFormatProvider? provider)
+        public static HeatFlux<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<HeatFlux, HeatFluxUnit>(
+            return QuantityParser.Default.Parse<T, HeatFlux<T>, HeatFluxUnit>(
                 str,
                 provider,
                 From);
@@ -546,7 +526,7 @@ public static HeatFlux Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out HeatFlux result)
+        public static bool TryParse(string? str, out HeatFlux<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -561,9 +541,9 @@ public static bool TryParse(string? str, out HeatFlux result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out HeatFlux result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out HeatFlux<T> result)
         {
-            return QuantityParser.Default.TryParse<HeatFlux, HeatFluxUnit>(
+            return QuantityParser.Default.TryParse<T, HeatFlux<T>, HeatFluxUnit>(
                 str,
                 provider,
                 From,
@@ -625,45 +605,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out HeatF
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static HeatFlux operator -(HeatFlux right)
+        public static HeatFlux<T> operator -(HeatFlux<T> right)
         {
-            return new HeatFlux(-right.Value, right.Unit);
+            return new HeatFlux<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="HeatFlux"/> from adding two <see cref="HeatFlux"/>.</summary>
-        public static HeatFlux operator +(HeatFlux left, HeatFlux right)
+        /// <summary>Get <see cref="HeatFlux{T}"/> from adding two <see cref="HeatFlux{T}"/>.</summary>
+        public static HeatFlux<T> operator +(HeatFlux<T> left, HeatFlux<T> right)
         {
-            return new HeatFlux(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new HeatFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="HeatFlux"/> from subtracting two <see cref="HeatFlux"/>.</summary>
-        public static HeatFlux operator -(HeatFlux left, HeatFlux right)
+        /// <summary>Get <see cref="HeatFlux{T}"/> from subtracting two <see cref="HeatFlux{T}"/>.</summary>
+        public static HeatFlux<T> operator -(HeatFlux<T> left, HeatFlux<T> right)
         {
-            return new HeatFlux(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new HeatFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="HeatFlux"/> from multiplying value and <see cref="HeatFlux"/>.</summary>
-        public static HeatFlux operator *(double left, HeatFlux right)
+        /// <summary>Get <see cref="HeatFlux{T}"/> from multiplying value and <see cref="HeatFlux{T}"/>.</summary>
+        public static HeatFlux<T> operator *(T left, HeatFlux<T> right)
         {
-            return new HeatFlux(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new HeatFlux<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="HeatFlux"/> from multiplying value and <see cref="HeatFlux"/>.</summary>
-        public static HeatFlux operator *(HeatFlux left, double right)
+        /// <summary>Get <see cref="HeatFlux{T}"/> from multiplying value and <see cref="HeatFlux{T}"/>.</summary>
+        public static HeatFlux<T> operator *(HeatFlux<T> left, T right)
         {
-            return new HeatFlux(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new HeatFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="HeatFlux"/> from dividing <see cref="HeatFlux"/> by value.</summary>
-        public static HeatFlux operator /(HeatFlux left, double right)
+        /// <summary>Get <see cref="HeatFlux{T}"/> from dividing <see cref="HeatFlux{T}"/> by value.</summary>
+        public static HeatFlux<T> operator /(HeatFlux<T> left, T right)
         {
-            return new HeatFlux(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new HeatFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="HeatFlux"/> by <see cref="HeatFlux"/>.</summary>
-        public static double operator /(HeatFlux left, HeatFlux right)
+        /// <summary>Get ratio value from dividing <see cref="HeatFlux{T}"/> by <see cref="HeatFlux{T}"/>.</summary>
+        public static T operator /(HeatFlux<T> left, HeatFlux<T> right)
         {
-            return left.WattsPerSquareMeter / right.WattsPerSquareMeter;
+            return CompiledLambdas.Divide(left.WattsPerSquareMeter, right.WattsPerSquareMeter);
         }
 
         #endregion
@@ -671,39 +656,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out HeatF
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(HeatFlux left, HeatFlux right)
+        public static bool operator <=(HeatFlux<T> left, HeatFlux<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(HeatFlux left, HeatFlux right)
+        public static bool operator >=(HeatFlux<T> left, HeatFlux<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(HeatFlux left, HeatFlux right)
+        public static bool operator <(HeatFlux<T> left, HeatFlux<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(HeatFlux left, HeatFlux right)
+        public static bool operator >(HeatFlux<T> left, HeatFlux<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(HeatFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(HeatFlux left, HeatFlux right)
+        /// <remarks>Consider using <see cref="Equals(HeatFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(HeatFlux<T> left, HeatFlux<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(HeatFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(HeatFlux left, HeatFlux right)
+        /// <remarks>Consider using <see cref="Equals(HeatFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(HeatFlux<T> left, HeatFlux<T> right)
         {
             return !(left == right);
         }
@@ -712,37 +697,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out HeatF
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is HeatFlux objHeatFlux)) throw new ArgumentException("Expected type HeatFlux.", nameof(obj));
+            if(!(obj is HeatFlux<T> objHeatFlux)) throw new ArgumentException("Expected type HeatFlux.", nameof(obj));
 
             return CompareTo(objHeatFlux);
         }
 
         /// <inheritdoc />
-        public int CompareTo(HeatFlux other)
+        public int CompareTo(HeatFlux<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(HeatFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(HeatFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is HeatFlux objHeatFlux))
+            if(obj is null || !(obj is HeatFlux<T> objHeatFlux))
                 return false;
 
             return Equals(objHeatFlux);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(HeatFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(HeatFlux other)
+        /// <remarks>Consider using <see cref="Equals(HeatFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(HeatFlux<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another HeatFlux within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="HeatFlux{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -780,21 +765,19 @@ public bool Equals(HeatFlux other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(HeatFlux other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(HeatFlux<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current HeatFlux.</returns>
+        /// <returns>A hash code for the current <see cref="HeatFlux{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -808,17 +791,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(HeatFluxUnit unit)
+        public T As(HeatFluxUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -838,17 +821,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is HeatFluxUnit unitAsHeatFluxUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatFluxUnit)} is supported.", nameof(unit));
 
-            return As(unitAsHeatFluxUnit);
+            var asValue = As(unitAsHeatFluxUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<HeatFluxUnit>.As(HeatFluxUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this HeatFlux to another HeatFlux with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="HeatFlux{T}" /> to another <see cref="HeatFlux{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A HeatFlux with the specified unit.</returns>
-        public HeatFlux ToUnit(HeatFluxUnit unit)
+        /// <returns>A <see cref="HeatFlux{T}" /> with the specified unit.</returns>
+        public HeatFlux<T> ToUnit(HeatFluxUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new HeatFlux(convertedValue, unit);
+            return new HeatFlux<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -861,7 +849,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public HeatFlux ToUnit(UnitSystem unitSystem)
+        public HeatFlux<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -881,36 +869,42 @@ public HeatFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<HeatFluxUnit> IQuantity<HeatFluxUnit>.ToUnit(HeatFluxUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<HeatFluxUnit, T> IQuantityT<HeatFluxUnit, T>.ToUnit(HeatFluxUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<HeatFluxUnit> IQuantity<HeatFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<HeatFluxUnit, T> IQuantityT<HeatFluxUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case HeatFluxUnit.BtuPerHourSquareFoot: return _value*3.15459075;
-                case HeatFluxUnit.BtuPerMinuteSquareFoot: return _value*1.89275445e2;
-                case HeatFluxUnit.BtuPerSecondSquareFoot: return _value*1.13565267e4;
-                case HeatFluxUnit.BtuPerSecondSquareInch: return _value*1.63533984e6;
-                case HeatFluxUnit.CaloriePerSecondSquareCentimeter: return _value*4.1868e4;
-                case HeatFluxUnit.CentiwattPerSquareMeter: return (_value) * 1e-2d;
-                case HeatFluxUnit.DeciwattPerSquareMeter: return (_value) * 1e-1d;
-                case HeatFluxUnit.KilocaloriePerHourSquareMeter: return _value*1.163;
-                case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: return (_value*4.1868e4) * 1e3d;
-                case HeatFluxUnit.KilowattPerSquareMeter: return (_value) * 1e3d;
-                case HeatFluxUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d;
-                case HeatFluxUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d;
-                case HeatFluxUnit.NanowattPerSquareMeter: return (_value) * 1e-9d;
-                case HeatFluxUnit.PoundForcePerFootSecond: return _value*1.459390293720636e1;
-                case HeatFluxUnit.PoundPerSecondCubed: return _value*4.5359237e-1;
-                case HeatFluxUnit.WattPerSquareFoot: return _value*1.07639e1;
-                case HeatFluxUnit.WattPerSquareInch: return _value*1.5500031e3;
-                case HeatFluxUnit.WattPerSquareMeter: return _value;
+                case HeatFluxUnit.BtuPerHourSquareFoot: return Value*3.15459075;
+                case HeatFluxUnit.BtuPerMinuteSquareFoot: return Value*1.89275445e2;
+                case HeatFluxUnit.BtuPerSecondSquareFoot: return Value*1.13565267e4;
+                case HeatFluxUnit.BtuPerSecondSquareInch: return Value*1.63533984e6;
+                case HeatFluxUnit.CaloriePerSecondSquareCentimeter: return Value*4.1868e4;
+                case HeatFluxUnit.CentiwattPerSquareMeter: return (Value) * 1e-2d;
+                case HeatFluxUnit.DeciwattPerSquareMeter: return (Value) * 1e-1d;
+                case HeatFluxUnit.KilocaloriePerHourSquareMeter: return Value*1.163;
+                case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: return (Value*4.1868e4) * 1e3d;
+                case HeatFluxUnit.KilowattPerSquareMeter: return (Value) * 1e3d;
+                case HeatFluxUnit.MicrowattPerSquareMeter: return (Value) * 1e-6d;
+                case HeatFluxUnit.MilliwattPerSquareMeter: return (Value) * 1e-3d;
+                case HeatFluxUnit.NanowattPerSquareMeter: return (Value) * 1e-9d;
+                case HeatFluxUnit.PoundForcePerFootSecond: return Value*1.459390293720636e1;
+                case HeatFluxUnit.PoundPerSecondCubed: return Value*4.5359237e-1;
+                case HeatFluxUnit.WattPerSquareFoot: return Value*1.07639e1;
+                case HeatFluxUnit.WattPerSquareInch: return Value*1.5500031e3;
+                case HeatFluxUnit.WattPerSquareMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -921,16 +915,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal HeatFlux ToBaseUnit()
+        internal HeatFlux<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new HeatFlux(baseUnitValue, BaseUnit);
+            return new HeatFlux<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(HeatFluxUnit unit)
+        private T GetValueAs(HeatFluxUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1050,57 +1044,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(HeatFlux)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(HeatFlux<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(HeatFlux)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(HeatFlux<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(HeatFlux)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(HeatFlux<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1110,33 +1104,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(HeatFlux))
+            if(conversionType == typeof(HeatFlux<T>))
                 return this;
             else if(conversionType == typeof(HeatFluxUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return HeatFlux.QuantityType;
+                return HeatFlux<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return HeatFlux.Info;
+                return HeatFlux<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return HeatFlux.BaseDimensions;
+                return HeatFlux<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(HeatFlux)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(HeatFlux<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
index fab206d466..82b2a9167c 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The heat transfer coefficient or film coefficient, or film effectiveness, in thermodynamics and in mechanics is the proportionality constant between the heat flux and the thermodynamic driving force for the flow of heat (i.e., the temperature difference, ΔT)
     /// </summary>
-    public partial struct HeatTransferCoefficient : IQuantity<HeatTransferCoefficientUnit>, IEquatable<HeatTransferCoefficient>, IComparable, IComparable<HeatTransferCoefficient>, IConvertible, IFormattable
+    public partial struct HeatTransferCoefficient<T> : IQuantityT<HeatTransferCoefficientUnit, T>, IEquatable<HeatTransferCoefficient<T>>, IComparable, IComparable<HeatTransferCoefficient<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static HeatTransferCoefficient()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public HeatTransferCoefficient(double value, HeatTransferCoefficientUnit unit)
+        public HeatTransferCoefficient(T value, HeatTransferCoefficientUnit unit)
         {
             if(unit == HeatTransferCoefficientUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public HeatTransferCoefficient(double value, HeatTransferCoefficientUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public HeatTransferCoefficient(double value, UnitSystem unitSystem)
+        public HeatTransferCoefficient(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of HeatTransferCoefficient, which is WattPerSquareMeterKelvin. All conversions go via this value.
+        ///     The base unit of <see cref="HeatTransferCoefficient{T}" />, which is WattPerSquareMeterKelvin. All conversions go via this value.
         /// </summary>
         public static HeatTransferCoefficientUnit BaseUnit { get; } = HeatTransferCoefficientUnit.WattPerSquareMeterKelvin;
 
         /// <summary>
-        /// Represents the largest possible value of HeatTransferCoefficient
+        /// Represents the largest possible value of <see cref="HeatTransferCoefficient{T}" />
         /// </summary>
-        public static HeatTransferCoefficient MaxValue { get; } = new HeatTransferCoefficient(double.MaxValue, BaseUnit);
+        public static HeatTransferCoefficient<T> MaxValue { get; } = new HeatTransferCoefficient<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of HeatTransferCoefficient
+        /// Represents the smallest possible value of <see cref="HeatTransferCoefficient{T}" />
         /// </summary>
-        public static HeatTransferCoefficient MinValue { get; } = new HeatTransferCoefficient(double.MinValue, BaseUnit);
+        public static HeatTransferCoefficient<T> MinValue { get; } = new HeatTransferCoefficient<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.HeatTransferCoefficient;
 
         /// <summary>
-        ///     All units of measurement for the HeatTransferCoefficient quantity.
+        ///     All units of measurement for the <see cref="HeatTransferCoefficient{T}" /> quantity.
         /// </summary>
         public static HeatTransferCoefficientUnit[] Units { get; } = Enum.GetValues(typeof(HeatTransferCoefficientUnit)).Cast<HeatTransferCoefficientUnit>().Except(new HeatTransferCoefficientUnit[]{ HeatTransferCoefficientUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit WattPerSquareMeterKelvin.
         /// </summary>
-        public static HeatTransferCoefficient Zero { get; } = new HeatTransferCoefficient(0, BaseUnit);
+        public static HeatTransferCoefficient<T> Zero { get; } = new HeatTransferCoefficient<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => HeatTransferCoefficient.QuantityType;
+        public QuantityType Type => HeatTransferCoefficient<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => HeatTransferCoefficient.BaseDimensions;
+        public BaseDimensions Dimensions => HeatTransferCoefficient<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get HeatTransferCoefficient in BtusPerSquareFootDegreeFahrenheit.
+        ///     Get <see cref="HeatTransferCoefficient{T}" /> in BtusPerSquareFootDegreeFahrenheit.
         /// </summary>
-        public double BtusPerSquareFootDegreeFahrenheit => As(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
+        public T BtusPerSquareFootDegreeFahrenheit => As(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
 
         /// <summary>
-        ///     Get HeatTransferCoefficient in WattsPerSquareMeterCelsius.
+        ///     Get <see cref="HeatTransferCoefficient{T}" /> in WattsPerSquareMeterCelsius.
         /// </summary>
-        public double WattsPerSquareMeterCelsius => As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
+        public T WattsPerSquareMeterCelsius => As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
 
         /// <summary>
-        ///     Get HeatTransferCoefficient in WattsPerSquareMeterKelvin.
+        ///     Get <see cref="HeatTransferCoefficient{T}" /> in WattsPerSquareMeterKelvin.
         /// </summary>
-        public double WattsPerSquareMeterKelvin => As(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
+        public T WattsPerSquareMeterKelvin => As(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(HeatTransferCoefficientUnit unit, IFormatPr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get HeatTransferCoefficient from BtusPerSquareFootDegreeFahrenheit.
+        ///     Get <see cref="HeatTransferCoefficient{T}" /> from BtusPerSquareFootDegreeFahrenheit.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(QuantityValue btuspersquarefootdegreefahrenheit)
+        public static HeatTransferCoefficient<T> FromBtusPerSquareFootDegreeFahrenheit(T btuspersquarefootdegreefahrenheit)
         {
-            double value = (double) btuspersquarefootdegreefahrenheit;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
+            return new HeatTransferCoefficient<T>(btuspersquarefootdegreefahrenheit, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
         }
         /// <summary>
-        ///     Get HeatTransferCoefficient from WattsPerSquareMeterCelsius.
+        ///     Get <see cref="HeatTransferCoefficient{T}" /> from WattsPerSquareMeterCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(QuantityValue wattspersquaremetercelsius)
+        public static HeatTransferCoefficient<T> FromWattsPerSquareMeterCelsius(T wattspersquaremetercelsius)
         {
-            double value = (double) wattspersquaremetercelsius;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
+            return new HeatTransferCoefficient<T>(wattspersquaremetercelsius, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
         }
         /// <summary>
-        ///     Get HeatTransferCoefficient from WattsPerSquareMeterKelvin.
+        ///     Get <see cref="HeatTransferCoefficient{T}" /> from WattsPerSquareMeterKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(QuantityValue wattspersquaremeterkelvin)
+        public static HeatTransferCoefficient<T> FromWattsPerSquareMeterKelvin(T wattspersquaremeterkelvin)
         {
-            double value = (double) wattspersquaremeterkelvin;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
+            return new HeatTransferCoefficient<T>(wattspersquaremeterkelvin, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="HeatTransferCoefficientUnit" /> to <see cref="HeatTransferCoefficient" />.
+        ///     Dynamically convert from value and unit enum <see cref="HeatTransferCoefficientUnit" /> to <see cref="HeatTransferCoefficient{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>HeatTransferCoefficient unit value.</returns>
-        public static HeatTransferCoefficient From(QuantityValue value, HeatTransferCoefficientUnit fromUnit)
+        /// <returns><see cref="HeatTransferCoefficient{T}" /> unit value.</returns>
+        public static HeatTransferCoefficient<T> From(T value, HeatTransferCoefficientUnit fromUnit)
         {
-            return new HeatTransferCoefficient((double)value, fromUnit);
+            return new HeatTransferCoefficient<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static HeatTransferCoefficient From(QuantityValue value, HeatTransferCoef
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static HeatTransferCoefficient Parse(string str)
+        public static HeatTransferCoefficient<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static HeatTransferCoefficient Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static HeatTransferCoefficient Parse(string str, IFormatProvider? provider)
+        public static HeatTransferCoefficient<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<HeatTransferCoefficient, HeatTransferCoefficientUnit>(
+            return QuantityParser.Default.Parse<T, HeatTransferCoefficient<T>, HeatTransferCoefficientUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static HeatTransferCoefficient Parse(string str, IFormatProvider? provide
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out HeatTransferCoefficient result)
+        public static bool TryParse(string? str, out HeatTransferCoefficient<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out HeatTransferCoefficient result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out HeatTransferCoefficient result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out HeatTransferCoefficient<T> result)
         {
-            return QuantityParser.Default.TryParse<HeatTransferCoefficient, HeatTransferCoefficientUnit>(
+            return QuantityParser.Default.TryParse<T, HeatTransferCoefficient<T>, HeatTransferCoefficientUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out HeatT
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static HeatTransferCoefficient operator -(HeatTransferCoefficient right)
+        public static HeatTransferCoefficient<T> operator -(HeatTransferCoefficient<T> right)
         {
-            return new HeatTransferCoefficient(-right.Value, right.Unit);
+            return new HeatTransferCoefficient<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="HeatTransferCoefficient"/> from adding two <see cref="HeatTransferCoefficient"/>.</summary>
-        public static HeatTransferCoefficient operator +(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        /// <summary>Get <see cref="HeatTransferCoefficient{T}"/> from adding two <see cref="HeatTransferCoefficient{T}"/>.</summary>
+        public static HeatTransferCoefficient<T> operator +(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
-            return new HeatTransferCoefficient(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new HeatTransferCoefficient<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="HeatTransferCoefficient"/> from subtracting two <see cref="HeatTransferCoefficient"/>.</summary>
-        public static HeatTransferCoefficient operator -(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        /// <summary>Get <see cref="HeatTransferCoefficient{T}"/> from subtracting two <see cref="HeatTransferCoefficient{T}"/>.</summary>
+        public static HeatTransferCoefficient<T> operator -(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
-            return new HeatTransferCoefficient(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new HeatTransferCoefficient<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="HeatTransferCoefficient"/> from multiplying value and <see cref="HeatTransferCoefficient"/>.</summary>
-        public static HeatTransferCoefficient operator *(double left, HeatTransferCoefficient right)
+        /// <summary>Get <see cref="HeatTransferCoefficient{T}"/> from multiplying value and <see cref="HeatTransferCoefficient{T}"/>.</summary>
+        public static HeatTransferCoefficient<T> operator *(T left, HeatTransferCoefficient<T> right)
         {
-            return new HeatTransferCoefficient(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new HeatTransferCoefficient<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="HeatTransferCoefficient"/> from multiplying value and <see cref="HeatTransferCoefficient"/>.</summary>
-        public static HeatTransferCoefficient operator *(HeatTransferCoefficient left, double right)
+        /// <summary>Get <see cref="HeatTransferCoefficient{T}"/> from multiplying value and <see cref="HeatTransferCoefficient{T}"/>.</summary>
+        public static HeatTransferCoefficient<T> operator *(HeatTransferCoefficient<T> left, T right)
         {
-            return new HeatTransferCoefficient(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new HeatTransferCoefficient<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="HeatTransferCoefficient"/> from dividing <see cref="HeatTransferCoefficient"/> by value.</summary>
-        public static HeatTransferCoefficient operator /(HeatTransferCoefficient left, double right)
+        /// <summary>Get <see cref="HeatTransferCoefficient{T}"/> from dividing <see cref="HeatTransferCoefficient{T}"/> by value.</summary>
+        public static HeatTransferCoefficient<T> operator /(HeatTransferCoefficient<T> left, T right)
         {
-            return new HeatTransferCoefficient(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new HeatTransferCoefficient<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="HeatTransferCoefficient"/> by <see cref="HeatTransferCoefficient"/>.</summary>
-        public static double operator /(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        /// <summary>Get ratio value from dividing <see cref="HeatTransferCoefficient{T}"/> by <see cref="HeatTransferCoefficient{T}"/>.</summary>
+        public static T operator /(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
-            return left.WattsPerSquareMeterKelvin / right.WattsPerSquareMeterKelvin;
+            return CompiledLambdas.Divide(left.WattsPerSquareMeterKelvin, right.WattsPerSquareMeterKelvin);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out HeatT
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        public static bool operator <=(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        public static bool operator >=(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        public static bool operator <(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        public static bool operator >(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out HeatT
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is HeatTransferCoefficient objHeatTransferCoefficient)) throw new ArgumentException("Expected type HeatTransferCoefficient.", nameof(obj));
+            if(!(obj is HeatTransferCoefficient<T> objHeatTransferCoefficient)) throw new ArgumentException("Expected type HeatTransferCoefficient.", nameof(obj));
 
             return CompareTo(objHeatTransferCoefficient);
         }
 
         /// <inheritdoc />
-        public int CompareTo(HeatTransferCoefficient other)
+        public int CompareTo(HeatTransferCoefficient<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is HeatTransferCoefficient objHeatTransferCoefficient))
+            if(obj is null || !(obj is HeatTransferCoefficient<T> objHeatTransferCoefficient))
                 return false;
 
             return Equals(objHeatTransferCoefficient);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(HeatTransferCoefficient other)
+        /// <remarks>Consider using <see cref="Equals(HeatTransferCoefficient{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(HeatTransferCoefficient<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another HeatTransferCoefficient within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="HeatTransferCoefficient{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(HeatTransferCoefficient other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(HeatTransferCoefficient other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(HeatTransferCoefficient<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current HeatTransferCoefficient.</returns>
+        /// <returns>A hash code for the current <see cref="HeatTransferCoefficient{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(HeatTransferCoefficientUnit unit)
+        public T As(HeatTransferCoefficientUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is HeatTransferCoefficientUnit unitAsHeatTransferCoefficientUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatTransferCoefficientUnit)} is supported.", nameof(unit));
 
-            return As(unitAsHeatTransferCoefficientUnit);
+            var asValue = As(unitAsHeatTransferCoefficientUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<HeatTransferCoefficientUnit>.As(HeatTransferCoefficientUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this HeatTransferCoefficient to another HeatTransferCoefficient with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="HeatTransferCoefficient{T}" /> to another <see cref="HeatTransferCoefficient{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A HeatTransferCoefficient with the specified unit.</returns>
-        public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit)
+        /// <returns>A <see cref="HeatTransferCoefficient{T}" /> with the specified unit.</returns>
+        public HeatTransferCoefficient<T> ToUnit(HeatTransferCoefficientUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new HeatTransferCoefficient(convertedValue, unit);
+            return new HeatTransferCoefficient<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public HeatTransferCoefficient ToUnit(UnitSystem unitSystem)
+        public HeatTransferCoefficient<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public HeatTransferCoefficient ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<HeatTransferCoefficientUnit> IQuantity<HeatTransferCoefficientUnit>.ToUnit(HeatTransferCoefficientUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<HeatTransferCoefficientUnit, T> IQuantityT<HeatTransferCoefficientUnit, T>.ToUnit(HeatTransferCoefficientUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<HeatTransferCoefficientUnit> IQuantity<HeatTransferCoefficientUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<HeatTransferCoefficientUnit, T> IQuantityT<HeatTransferCoefficientUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit: return _value * 5.6782633411134878;
-                case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: return _value;
-                case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: return _value;
+                case HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit: return Value * 5.6782633411134878;
+                case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: return Value;
+                case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal HeatTransferCoefficient ToBaseUnit()
+        internal HeatTransferCoefficient<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new HeatTransferCoefficient(baseUnitValue, BaseUnit);
+            return new HeatTransferCoefficient<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(HeatTransferCoefficientUnit unit)
+        private T GetValueAs(HeatTransferCoefficientUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(HeatTransferCoefficient))
+            if(conversionType == typeof(HeatTransferCoefficient<T>))
                 return this;
             else if(conversionType == typeof(HeatTransferCoefficientUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return HeatTransferCoefficient.QuantityType;
+                return HeatTransferCoefficient<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return HeatTransferCoefficient.Info;
+                return HeatTransferCoefficient<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return HeatTransferCoefficient.BaseDimensions;
+                return HeatTransferCoefficient<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(HeatTransferCoefficient<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
index ef3e205cfd..173ce2d00e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Illuminance
     /// </remarks>
-    public partial struct Illuminance : IQuantity<IlluminanceUnit>, IEquatable<Illuminance>, IComparable, IComparable<Illuminance>, IConvertible, IFormattable
+    public partial struct Illuminance<T> : IQuantityT<IlluminanceUnit, T>, IEquatable<Illuminance<T>>, IComparable, IComparable<Illuminance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -69,12 +65,12 @@ static Illuminance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Illuminance(double value, IlluminanceUnit unit)
+        public Illuminance(T value, IlluminanceUnit unit)
         {
             if(unit == IlluminanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -86,14 +82,14 @@ public Illuminance(double value, IlluminanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Illuminance(double value, UnitSystem unitSystem)
+        public Illuminance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -108,19 +104,19 @@ public Illuminance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Illuminance, which is Lux. All conversions go via this value.
+        ///     The base unit of <see cref="Illuminance{T}" />, which is Lux. All conversions go via this value.
         /// </summary>
         public static IlluminanceUnit BaseUnit { get; } = IlluminanceUnit.Lux;
 
         /// <summary>
-        /// Represents the largest possible value of Illuminance
+        /// Represents the largest possible value of <see cref="Illuminance{T}" />
         /// </summary>
-        public static Illuminance MaxValue { get; } = new Illuminance(double.MaxValue, BaseUnit);
+        public static Illuminance<T> MaxValue { get; } = new Illuminance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Illuminance
+        /// Represents the smallest possible value of <see cref="Illuminance{T}" />
         /// </summary>
-        public static Illuminance MinValue { get; } = new Illuminance(double.MinValue, BaseUnit);
+        public static Illuminance<T> MinValue { get; } = new Illuminance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -129,14 +125,14 @@ public Illuminance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Illuminance;
 
         /// <summary>
-        ///     All units of measurement for the Illuminance quantity.
+        ///     All units of measurement for the <see cref="Illuminance{T}" /> quantity.
         /// </summary>
         public static IlluminanceUnit[] Units { get; } = Enum.GetValues(typeof(IlluminanceUnit)).Cast<IlluminanceUnit>().Except(new IlluminanceUnit[]{ IlluminanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Lux.
         /// </summary>
-        public static Illuminance Zero { get; } = new Illuminance(0, BaseUnit);
+        public static Illuminance<T> Zero { get; } = new Illuminance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -145,7 +141,9 @@ public Illuminance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -161,36 +159,36 @@ public Illuminance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Illuminance.QuantityType;
+        public QuantityType Type => Illuminance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Illuminance.BaseDimensions;
+        public BaseDimensions Dimensions => Illuminance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Illuminance in Kilolux.
+        ///     Get <see cref="Illuminance{T}" /> in Kilolux.
         /// </summary>
-        public double Kilolux => As(IlluminanceUnit.Kilolux);
+        public T Kilolux => As(IlluminanceUnit.Kilolux);
 
         /// <summary>
-        ///     Get Illuminance in Lux.
+        ///     Get <see cref="Illuminance{T}" /> in Lux.
         /// </summary>
-        public double Lux => As(IlluminanceUnit.Lux);
+        public T Lux => As(IlluminanceUnit.Lux);
 
         /// <summary>
-        ///     Get Illuminance in Megalux.
+        ///     Get <see cref="Illuminance{T}" /> in Megalux.
         /// </summary>
-        public double Megalux => As(IlluminanceUnit.Megalux);
+        public T Megalux => As(IlluminanceUnit.Megalux);
 
         /// <summary>
-        ///     Get Illuminance in Millilux.
+        ///     Get <see cref="Illuminance{T}" /> in Millilux.
         /// </summary>
-        public double Millilux => As(IlluminanceUnit.Millilux);
+        public T Millilux => As(IlluminanceUnit.Millilux);
 
         #endregion
 
@@ -222,51 +220,47 @@ public static string GetAbbreviation(IlluminanceUnit unit, IFormatProvider? prov
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Illuminance from Kilolux.
+        ///     Get <see cref="Illuminance{T}" /> from Kilolux.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromKilolux(QuantityValue kilolux)
+        public static Illuminance<T> FromKilolux(T kilolux)
         {
-            double value = (double) kilolux;
-            return new Illuminance(value, IlluminanceUnit.Kilolux);
+            return new Illuminance<T>(kilolux, IlluminanceUnit.Kilolux);
         }
         /// <summary>
-        ///     Get Illuminance from Lux.
+        ///     Get <see cref="Illuminance{T}" /> from Lux.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromLux(QuantityValue lux)
+        public static Illuminance<T> FromLux(T lux)
         {
-            double value = (double) lux;
-            return new Illuminance(value, IlluminanceUnit.Lux);
+            return new Illuminance<T>(lux, IlluminanceUnit.Lux);
         }
         /// <summary>
-        ///     Get Illuminance from Megalux.
+        ///     Get <see cref="Illuminance{T}" /> from Megalux.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromMegalux(QuantityValue megalux)
+        public static Illuminance<T> FromMegalux(T megalux)
         {
-            double value = (double) megalux;
-            return new Illuminance(value, IlluminanceUnit.Megalux);
+            return new Illuminance<T>(megalux, IlluminanceUnit.Megalux);
         }
         /// <summary>
-        ///     Get Illuminance from Millilux.
+        ///     Get <see cref="Illuminance{T}" /> from Millilux.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromMillilux(QuantityValue millilux)
+        public static Illuminance<T> FromMillilux(T millilux)
         {
-            double value = (double) millilux;
-            return new Illuminance(value, IlluminanceUnit.Millilux);
+            return new Illuminance<T>(millilux, IlluminanceUnit.Millilux);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="IlluminanceUnit" /> to <see cref="Illuminance" />.
+        ///     Dynamically convert from value and unit enum <see cref="IlluminanceUnit" /> to <see cref="Illuminance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Illuminance unit value.</returns>
-        public static Illuminance From(QuantityValue value, IlluminanceUnit fromUnit)
+        /// <returns><see cref="Illuminance{T}" /> unit value.</returns>
+        public static Illuminance<T> From(T value, IlluminanceUnit fromUnit)
         {
-            return new Illuminance((double)value, fromUnit);
+            return new Illuminance<T>(value, fromUnit);
         }
 
         #endregion
@@ -295,7 +289,7 @@ public static Illuminance From(QuantityValue value, IlluminanceUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Illuminance Parse(string str)
+        public static Illuminance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -323,9 +317,9 @@ public static Illuminance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Illuminance Parse(string str, IFormatProvider? provider)
+        public static Illuminance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Illuminance, IlluminanceUnit>(
+            return QuantityParser.Default.Parse<T, Illuminance<T>, IlluminanceUnit>(
                 str,
                 provider,
                 From);
@@ -339,7 +333,7 @@ public static Illuminance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Illuminance result)
+        public static bool TryParse(string? str, out Illuminance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -354,9 +348,9 @@ public static bool TryParse(string? str, out Illuminance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Illuminance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Illuminance<T> result)
         {
-            return QuantityParser.Default.TryParse<Illuminance, IlluminanceUnit>(
+            return QuantityParser.Default.TryParse<T, Illuminance<T>, IlluminanceUnit>(
                 str,
                 provider,
                 From,
@@ -418,45 +412,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Illum
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Illuminance operator -(Illuminance right)
+        public static Illuminance<T> operator -(Illuminance<T> right)
         {
-            return new Illuminance(-right.Value, right.Unit);
+            return new Illuminance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Illuminance"/> from adding two <see cref="Illuminance"/>.</summary>
-        public static Illuminance operator +(Illuminance left, Illuminance right)
+        /// <summary>Get <see cref="Illuminance{T}"/> from adding two <see cref="Illuminance{T}"/>.</summary>
+        public static Illuminance<T> operator +(Illuminance<T> left, Illuminance<T> right)
         {
-            return new Illuminance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Illuminance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Illuminance"/> from subtracting two <see cref="Illuminance"/>.</summary>
-        public static Illuminance operator -(Illuminance left, Illuminance right)
+        /// <summary>Get <see cref="Illuminance{T}"/> from subtracting two <see cref="Illuminance{T}"/>.</summary>
+        public static Illuminance<T> operator -(Illuminance<T> left, Illuminance<T> right)
         {
-            return new Illuminance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Illuminance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Illuminance"/> from multiplying value and <see cref="Illuminance"/>.</summary>
-        public static Illuminance operator *(double left, Illuminance right)
+        /// <summary>Get <see cref="Illuminance{T}"/> from multiplying value and <see cref="Illuminance{T}"/>.</summary>
+        public static Illuminance<T> operator *(T left, Illuminance<T> right)
         {
-            return new Illuminance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Illuminance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Illuminance"/> from multiplying value and <see cref="Illuminance"/>.</summary>
-        public static Illuminance operator *(Illuminance left, double right)
+        /// <summary>Get <see cref="Illuminance{T}"/> from multiplying value and <see cref="Illuminance{T}"/>.</summary>
+        public static Illuminance<T> operator *(Illuminance<T> left, T right)
         {
-            return new Illuminance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Illuminance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Illuminance"/> from dividing <see cref="Illuminance"/> by value.</summary>
-        public static Illuminance operator /(Illuminance left, double right)
+        /// <summary>Get <see cref="Illuminance{T}"/> from dividing <see cref="Illuminance{T}"/> by value.</summary>
+        public static Illuminance<T> operator /(Illuminance<T> left, T right)
         {
-            return new Illuminance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Illuminance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Illuminance"/> by <see cref="Illuminance"/>.</summary>
-        public static double operator /(Illuminance left, Illuminance right)
+        /// <summary>Get ratio value from dividing <see cref="Illuminance{T}"/> by <see cref="Illuminance{T}"/>.</summary>
+        public static T operator /(Illuminance<T> left, Illuminance<T> right)
         {
-            return left.Lux / right.Lux;
+            return CompiledLambdas.Divide(left.Lux, right.Lux);
         }
 
         #endregion
@@ -464,39 +463,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Illum
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Illuminance left, Illuminance right)
+        public static bool operator <=(Illuminance<T> left, Illuminance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Illuminance left, Illuminance right)
+        public static bool operator >=(Illuminance<T> left, Illuminance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Illuminance left, Illuminance right)
+        public static bool operator <(Illuminance<T> left, Illuminance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Illuminance left, Illuminance right)
+        public static bool operator >(Illuminance<T> left, Illuminance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Illuminance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Illuminance left, Illuminance right)
+        /// <remarks>Consider using <see cref="Equals(Illuminance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Illuminance<T> left, Illuminance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Illuminance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Illuminance left, Illuminance right)
+        /// <remarks>Consider using <see cref="Equals(Illuminance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Illuminance<T> left, Illuminance<T> right)
         {
             return !(left == right);
         }
@@ -505,37 +504,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Illum
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Illuminance objIlluminance)) throw new ArgumentException("Expected type Illuminance.", nameof(obj));
+            if(!(obj is Illuminance<T> objIlluminance)) throw new ArgumentException("Expected type Illuminance.", nameof(obj));
 
             return CompareTo(objIlluminance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Illuminance other)
+        public int CompareTo(Illuminance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Illuminance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Illuminance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Illuminance objIlluminance))
+            if(obj is null || !(obj is Illuminance<T> objIlluminance))
                 return false;
 
             return Equals(objIlluminance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Illuminance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Illuminance other)
+        /// <remarks>Consider using <see cref="Equals(Illuminance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Illuminance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Illuminance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Illuminance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -573,21 +572,19 @@ public bool Equals(Illuminance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Illuminance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Illuminance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Illuminance.</returns>
+        /// <returns>A hash code for the current <see cref="Illuminance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -601,17 +598,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(IlluminanceUnit unit)
+        public T As(IlluminanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -631,17 +628,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is IlluminanceUnit unitAsIlluminanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IlluminanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsIlluminanceUnit);
+            var asValue = As(unitAsIlluminanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<IlluminanceUnit>.As(IlluminanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Illuminance to another Illuminance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Illuminance{T}" /> to another <see cref="Illuminance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Illuminance with the specified unit.</returns>
-        public Illuminance ToUnit(IlluminanceUnit unit)
+        /// <returns>A <see cref="Illuminance{T}" /> with the specified unit.</returns>
+        public Illuminance<T> ToUnit(IlluminanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Illuminance(convertedValue, unit);
+            return new Illuminance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -654,7 +656,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Illuminance ToUnit(UnitSystem unitSystem)
+        public Illuminance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -674,22 +676,28 @@ public Illuminance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<IlluminanceUnit> IQuantity<IlluminanceUnit>.ToUnit(IlluminanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<IlluminanceUnit, T> IQuantityT<IlluminanceUnit, T>.ToUnit(IlluminanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<IlluminanceUnit> IQuantity<IlluminanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<IlluminanceUnit, T> IQuantityT<IlluminanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case IlluminanceUnit.Kilolux: return (_value) * 1e3d;
-                case IlluminanceUnit.Lux: return _value;
-                case IlluminanceUnit.Megalux: return (_value) * 1e6d;
-                case IlluminanceUnit.Millilux: return (_value) * 1e-3d;
+                case IlluminanceUnit.Kilolux: return (Value) * 1e3d;
+                case IlluminanceUnit.Lux: return Value;
+                case IlluminanceUnit.Megalux: return (Value) * 1e6d;
+                case IlluminanceUnit.Millilux: return (Value) * 1e-3d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -700,16 +708,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Illuminance ToBaseUnit()
+        internal Illuminance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Illuminance(baseUnitValue, BaseUnit);
+            return new Illuminance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(IlluminanceUnit unit)
+        private T GetValueAs(IlluminanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -815,57 +823,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Illuminance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Illuminance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Illuminance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Illuminance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Illuminance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Illuminance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -875,33 +883,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Illuminance))
+            if(conversionType == typeof(Illuminance<T>))
                 return this;
             else if(conversionType == typeof(IlluminanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Illuminance.QuantityType;
+                return Illuminance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Illuminance.Info;
+                return Illuminance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Illuminance.BaseDimensions;
+                return Illuminance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Illuminance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Illuminance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
index b94d6a26be..ed36442f96 100644
--- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In computing and telecommunications, a unit of information is the capacity of some standard data storage system or communication channel, used to measure the capacities of other systems and channels. In information theory, units of information are also used to measure the information contents or entropy of random variables.
     /// </summary>
-    public partial struct Information : IQuantity<InformationUnit>, IDecimalQuantity, IEquatable<Information>, IComparable, IComparable<Information>, IConvertible, IFormattable
+    public partial struct Information<T> : IQuantityT<InformationUnit, T>, IDecimalQuantity, IEquatable<Information<T>>, IComparable, IComparable<Information<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly decimal _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -88,12 +84,12 @@ static Information()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Information(decimal value, InformationUnit unit)
+        public Information(T value, InformationUnit unit)
         {
             if(unit == InformationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = value;
+            Value = value;
             _unit = unit;
         }
 
@@ -105,14 +101,14 @@ public Information(decimal value, InformationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Information(decimal value, UnitSystem unitSystem)
+        public Information(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = value;
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -127,19 +123,19 @@ public Information(decimal value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Information, which is Bit. All conversions go via this value.
+        ///     The base unit of <see cref="Information{T}" />, which is Bit. All conversions go via this value.
         /// </summary>
         public static InformationUnit BaseUnit { get; } = InformationUnit.Bit;
 
         /// <summary>
-        /// Represents the largest possible value of Information
+        /// Represents the largest possible value of <see cref="Information{T}" />
         /// </summary>
-        public static Information MaxValue { get; } = new Information(decimal.MaxValue, BaseUnit);
+        public static Information<T> MaxValue { get; } = new Information<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Information
+        /// Represents the smallest possible value of <see cref="Information{T}" />
         /// </summary>
-        public static Information MinValue { get; } = new Information(decimal.MinValue, BaseUnit);
+        public static Information<T> MinValue { get; } = new Information<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -148,14 +144,14 @@ public Information(decimal value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Information;
 
         /// <summary>
-        ///     All units of measurement for the Information quantity.
+        ///     All units of measurement for the <see cref="Information{T}" /> quantity.
         /// </summary>
         public static InformationUnit[] Units { get; } = Enum.GetValues(typeof(InformationUnit)).Cast<InformationUnit>().Except(new InformationUnit[]{ InformationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Bit.
         /// </summary>
-        public static Information Zero { get; } = new Information(0, BaseUnit);
+        public static Information<T> Zero { get; } = new Information<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -164,9 +160,9 @@ public Information(decimal value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public decimal Value => _value;
+        public T Value{ get; }
 
-        double IQuantity.Value => (double) _value;
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         /// <inheritdoc cref="IDecimalQuantity.Value"/>
         decimal IDecimalQuantity.Value => _value;
@@ -185,146 +181,146 @@ public Information(decimal value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Information.QuantityType;
+        public QuantityType Type => Information<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Information.BaseDimensions;
+        public BaseDimensions Dimensions => Information<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Information in Bits.
+        ///     Get <see cref="Information{T}" /> in Bits.
         /// </summary>
-        public double Bits => As(InformationUnit.Bit);
+        public T Bits => As(InformationUnit.Bit);
 
         /// <summary>
-        ///     Get Information in Bytes.
+        ///     Get <see cref="Information{T}" /> in Bytes.
         /// </summary>
-        public double Bytes => As(InformationUnit.Byte);
+        public T Bytes => As(InformationUnit.Byte);
 
         /// <summary>
-        ///     Get Information in Exabits.
+        ///     Get <see cref="Information{T}" /> in Exabits.
         /// </summary>
-        public double Exabits => As(InformationUnit.Exabit);
+        public T Exabits => As(InformationUnit.Exabit);
 
         /// <summary>
-        ///     Get Information in Exabytes.
+        ///     Get <see cref="Information{T}" /> in Exabytes.
         /// </summary>
-        public double Exabytes => As(InformationUnit.Exabyte);
+        public T Exabytes => As(InformationUnit.Exabyte);
 
         /// <summary>
-        ///     Get Information in Exbibits.
+        ///     Get <see cref="Information{T}" /> in Exbibits.
         /// </summary>
-        public double Exbibits => As(InformationUnit.Exbibit);
+        public T Exbibits => As(InformationUnit.Exbibit);
 
         /// <summary>
-        ///     Get Information in Exbibytes.
+        ///     Get <see cref="Information{T}" /> in Exbibytes.
         /// </summary>
-        public double Exbibytes => As(InformationUnit.Exbibyte);
+        public T Exbibytes => As(InformationUnit.Exbibyte);
 
         /// <summary>
-        ///     Get Information in Gibibits.
+        ///     Get <see cref="Information{T}" /> in Gibibits.
         /// </summary>
-        public double Gibibits => As(InformationUnit.Gibibit);
+        public T Gibibits => As(InformationUnit.Gibibit);
 
         /// <summary>
-        ///     Get Information in Gibibytes.
+        ///     Get <see cref="Information{T}" /> in Gibibytes.
         /// </summary>
-        public double Gibibytes => As(InformationUnit.Gibibyte);
+        public T Gibibytes => As(InformationUnit.Gibibyte);
 
         /// <summary>
-        ///     Get Information in Gigabits.
+        ///     Get <see cref="Information{T}" /> in Gigabits.
         /// </summary>
-        public double Gigabits => As(InformationUnit.Gigabit);
+        public T Gigabits => As(InformationUnit.Gigabit);
 
         /// <summary>
-        ///     Get Information in Gigabytes.
+        ///     Get <see cref="Information{T}" /> in Gigabytes.
         /// </summary>
-        public double Gigabytes => As(InformationUnit.Gigabyte);
+        public T Gigabytes => As(InformationUnit.Gigabyte);
 
         /// <summary>
-        ///     Get Information in Kibibits.
+        ///     Get <see cref="Information{T}" /> in Kibibits.
         /// </summary>
-        public double Kibibits => As(InformationUnit.Kibibit);
+        public T Kibibits => As(InformationUnit.Kibibit);
 
         /// <summary>
-        ///     Get Information in Kibibytes.
+        ///     Get <see cref="Information{T}" /> in Kibibytes.
         /// </summary>
-        public double Kibibytes => As(InformationUnit.Kibibyte);
+        public T Kibibytes => As(InformationUnit.Kibibyte);
 
         /// <summary>
-        ///     Get Information in Kilobits.
+        ///     Get <see cref="Information{T}" /> in Kilobits.
         /// </summary>
-        public double Kilobits => As(InformationUnit.Kilobit);
+        public T Kilobits => As(InformationUnit.Kilobit);
 
         /// <summary>
-        ///     Get Information in Kilobytes.
+        ///     Get <see cref="Information{T}" /> in Kilobytes.
         /// </summary>
-        public double Kilobytes => As(InformationUnit.Kilobyte);
+        public T Kilobytes => As(InformationUnit.Kilobyte);
 
         /// <summary>
-        ///     Get Information in Mebibits.
+        ///     Get <see cref="Information{T}" /> in Mebibits.
         /// </summary>
-        public double Mebibits => As(InformationUnit.Mebibit);
+        public T Mebibits => As(InformationUnit.Mebibit);
 
         /// <summary>
-        ///     Get Information in Mebibytes.
+        ///     Get <see cref="Information{T}" /> in Mebibytes.
         /// </summary>
-        public double Mebibytes => As(InformationUnit.Mebibyte);
+        public T Mebibytes => As(InformationUnit.Mebibyte);
 
         /// <summary>
-        ///     Get Information in Megabits.
+        ///     Get <see cref="Information{T}" /> in Megabits.
         /// </summary>
-        public double Megabits => As(InformationUnit.Megabit);
+        public T Megabits => As(InformationUnit.Megabit);
 
         /// <summary>
-        ///     Get Information in Megabytes.
+        ///     Get <see cref="Information{T}" /> in Megabytes.
         /// </summary>
-        public double Megabytes => As(InformationUnit.Megabyte);
+        public T Megabytes => As(InformationUnit.Megabyte);
 
         /// <summary>
-        ///     Get Information in Pebibits.
+        ///     Get <see cref="Information{T}" /> in Pebibits.
         /// </summary>
-        public double Pebibits => As(InformationUnit.Pebibit);
+        public T Pebibits => As(InformationUnit.Pebibit);
 
         /// <summary>
-        ///     Get Information in Pebibytes.
+        ///     Get <see cref="Information{T}" /> in Pebibytes.
         /// </summary>
-        public double Pebibytes => As(InformationUnit.Pebibyte);
+        public T Pebibytes => As(InformationUnit.Pebibyte);
 
         /// <summary>
-        ///     Get Information in Petabits.
+        ///     Get <see cref="Information{T}" /> in Petabits.
         /// </summary>
-        public double Petabits => As(InformationUnit.Petabit);
+        public T Petabits => As(InformationUnit.Petabit);
 
         /// <summary>
-        ///     Get Information in Petabytes.
+        ///     Get <see cref="Information{T}" /> in Petabytes.
         /// </summary>
-        public double Petabytes => As(InformationUnit.Petabyte);
+        public T Petabytes => As(InformationUnit.Petabyte);
 
         /// <summary>
-        ///     Get Information in Tebibits.
+        ///     Get <see cref="Information{T}" /> in Tebibits.
         /// </summary>
-        public double Tebibits => As(InformationUnit.Tebibit);
+        public T Tebibits => As(InformationUnit.Tebibit);
 
         /// <summary>
-        ///     Get Information in Tebibytes.
+        ///     Get <see cref="Information{T}" /> in Tebibytes.
         /// </summary>
-        public double Tebibytes => As(InformationUnit.Tebibyte);
+        public T Tebibytes => As(InformationUnit.Tebibyte);
 
         /// <summary>
-        ///     Get Information in Terabits.
+        ///     Get <see cref="Information{T}" /> in Terabits.
         /// </summary>
-        public double Terabits => As(InformationUnit.Terabit);
+        public T Terabits => As(InformationUnit.Terabit);
 
         /// <summary>
-        ///     Get Information in Terabytes.
+        ///     Get <see cref="Information{T}" /> in Terabytes.
         /// </summary>
-        public double Terabytes => As(InformationUnit.Terabyte);
+        public T Terabytes => As(InformationUnit.Terabyte);
 
         #endregion
 
@@ -356,249 +352,223 @@ public static string GetAbbreviation(InformationUnit unit, IFormatProvider? prov
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Information from Bits.
+        ///     Get <see cref="Information{T}" /> from Bits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromBits(QuantityValue bits)
+        public static Information<T> FromBits(T bits)
         {
-            decimal value = (decimal) bits;
-            return new Information(value, InformationUnit.Bit);
+            return new Information<T>(bits, InformationUnit.Bit);
         }
         /// <summary>
-        ///     Get Information from Bytes.
+        ///     Get <see cref="Information{T}" /> from Bytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromBytes(QuantityValue bytes)
+        public static Information<T> FromBytes(T bytes)
         {
-            decimal value = (decimal) bytes;
-            return new Information(value, InformationUnit.Byte);
+            return new Information<T>(bytes, InformationUnit.Byte);
         }
         /// <summary>
-        ///     Get Information from Exabits.
+        ///     Get <see cref="Information{T}" /> from Exabits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExabits(QuantityValue exabits)
+        public static Information<T> FromExabits(T exabits)
         {
-            decimal value = (decimal) exabits;
-            return new Information(value, InformationUnit.Exabit);
+            return new Information<T>(exabits, InformationUnit.Exabit);
         }
         /// <summary>
-        ///     Get Information from Exabytes.
+        ///     Get <see cref="Information{T}" /> from Exabytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExabytes(QuantityValue exabytes)
+        public static Information<T> FromExabytes(T exabytes)
         {
-            decimal value = (decimal) exabytes;
-            return new Information(value, InformationUnit.Exabyte);
+            return new Information<T>(exabytes, InformationUnit.Exabyte);
         }
         /// <summary>
-        ///     Get Information from Exbibits.
+        ///     Get <see cref="Information{T}" /> from Exbibits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExbibits(QuantityValue exbibits)
+        public static Information<T> FromExbibits(T exbibits)
         {
-            decimal value = (decimal) exbibits;
-            return new Information(value, InformationUnit.Exbibit);
+            return new Information<T>(exbibits, InformationUnit.Exbibit);
         }
         /// <summary>
-        ///     Get Information from Exbibytes.
+        ///     Get <see cref="Information{T}" /> from Exbibytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExbibytes(QuantityValue exbibytes)
+        public static Information<T> FromExbibytes(T exbibytes)
         {
-            decimal value = (decimal) exbibytes;
-            return new Information(value, InformationUnit.Exbibyte);
+            return new Information<T>(exbibytes, InformationUnit.Exbibyte);
         }
         /// <summary>
-        ///     Get Information from Gibibits.
+        ///     Get <see cref="Information{T}" /> from Gibibits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGibibits(QuantityValue gibibits)
+        public static Information<T> FromGibibits(T gibibits)
         {
-            decimal value = (decimal) gibibits;
-            return new Information(value, InformationUnit.Gibibit);
+            return new Information<T>(gibibits, InformationUnit.Gibibit);
         }
         /// <summary>
-        ///     Get Information from Gibibytes.
+        ///     Get <see cref="Information{T}" /> from Gibibytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGibibytes(QuantityValue gibibytes)
+        public static Information<T> FromGibibytes(T gibibytes)
         {
-            decimal value = (decimal) gibibytes;
-            return new Information(value, InformationUnit.Gibibyte);
+            return new Information<T>(gibibytes, InformationUnit.Gibibyte);
         }
         /// <summary>
-        ///     Get Information from Gigabits.
+        ///     Get <see cref="Information{T}" /> from Gigabits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGigabits(QuantityValue gigabits)
+        public static Information<T> FromGigabits(T gigabits)
         {
-            decimal value = (decimal) gigabits;
-            return new Information(value, InformationUnit.Gigabit);
+            return new Information<T>(gigabits, InformationUnit.Gigabit);
         }
         /// <summary>
-        ///     Get Information from Gigabytes.
+        ///     Get <see cref="Information{T}" /> from Gigabytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGigabytes(QuantityValue gigabytes)
+        public static Information<T> FromGigabytes(T gigabytes)
         {
-            decimal value = (decimal) gigabytes;
-            return new Information(value, InformationUnit.Gigabyte);
+            return new Information<T>(gigabytes, InformationUnit.Gigabyte);
         }
         /// <summary>
-        ///     Get Information from Kibibits.
+        ///     Get <see cref="Information{T}" /> from Kibibits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKibibits(QuantityValue kibibits)
+        public static Information<T> FromKibibits(T kibibits)
         {
-            decimal value = (decimal) kibibits;
-            return new Information(value, InformationUnit.Kibibit);
+            return new Information<T>(kibibits, InformationUnit.Kibibit);
         }
         /// <summary>
-        ///     Get Information from Kibibytes.
+        ///     Get <see cref="Information{T}" /> from Kibibytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKibibytes(QuantityValue kibibytes)
+        public static Information<T> FromKibibytes(T kibibytes)
         {
-            decimal value = (decimal) kibibytes;
-            return new Information(value, InformationUnit.Kibibyte);
+            return new Information<T>(kibibytes, InformationUnit.Kibibyte);
         }
         /// <summary>
-        ///     Get Information from Kilobits.
+        ///     Get <see cref="Information{T}" /> from Kilobits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKilobits(QuantityValue kilobits)
+        public static Information<T> FromKilobits(T kilobits)
         {
-            decimal value = (decimal) kilobits;
-            return new Information(value, InformationUnit.Kilobit);
+            return new Information<T>(kilobits, InformationUnit.Kilobit);
         }
         /// <summary>
-        ///     Get Information from Kilobytes.
+        ///     Get <see cref="Information{T}" /> from Kilobytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKilobytes(QuantityValue kilobytes)
+        public static Information<T> FromKilobytes(T kilobytes)
         {
-            decimal value = (decimal) kilobytes;
-            return new Information(value, InformationUnit.Kilobyte);
+            return new Information<T>(kilobytes, InformationUnit.Kilobyte);
         }
         /// <summary>
-        ///     Get Information from Mebibits.
+        ///     Get <see cref="Information{T}" /> from Mebibits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMebibits(QuantityValue mebibits)
+        public static Information<T> FromMebibits(T mebibits)
         {
-            decimal value = (decimal) mebibits;
-            return new Information(value, InformationUnit.Mebibit);
+            return new Information<T>(mebibits, InformationUnit.Mebibit);
         }
         /// <summary>
-        ///     Get Information from Mebibytes.
+        ///     Get <see cref="Information{T}" /> from Mebibytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMebibytes(QuantityValue mebibytes)
+        public static Information<T> FromMebibytes(T mebibytes)
         {
-            decimal value = (decimal) mebibytes;
-            return new Information(value, InformationUnit.Mebibyte);
+            return new Information<T>(mebibytes, InformationUnit.Mebibyte);
         }
         /// <summary>
-        ///     Get Information from Megabits.
+        ///     Get <see cref="Information{T}" /> from Megabits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMegabits(QuantityValue megabits)
+        public static Information<T> FromMegabits(T megabits)
         {
-            decimal value = (decimal) megabits;
-            return new Information(value, InformationUnit.Megabit);
+            return new Information<T>(megabits, InformationUnit.Megabit);
         }
         /// <summary>
-        ///     Get Information from Megabytes.
+        ///     Get <see cref="Information{T}" /> from Megabytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMegabytes(QuantityValue megabytes)
+        public static Information<T> FromMegabytes(T megabytes)
         {
-            decimal value = (decimal) megabytes;
-            return new Information(value, InformationUnit.Megabyte);
+            return new Information<T>(megabytes, InformationUnit.Megabyte);
         }
         /// <summary>
-        ///     Get Information from Pebibits.
+        ///     Get <see cref="Information{T}" /> from Pebibits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPebibits(QuantityValue pebibits)
+        public static Information<T> FromPebibits(T pebibits)
         {
-            decimal value = (decimal) pebibits;
-            return new Information(value, InformationUnit.Pebibit);
+            return new Information<T>(pebibits, InformationUnit.Pebibit);
         }
         /// <summary>
-        ///     Get Information from Pebibytes.
+        ///     Get <see cref="Information{T}" /> from Pebibytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPebibytes(QuantityValue pebibytes)
+        public static Information<T> FromPebibytes(T pebibytes)
         {
-            decimal value = (decimal) pebibytes;
-            return new Information(value, InformationUnit.Pebibyte);
+            return new Information<T>(pebibytes, InformationUnit.Pebibyte);
         }
         /// <summary>
-        ///     Get Information from Petabits.
+        ///     Get <see cref="Information{T}" /> from Petabits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPetabits(QuantityValue petabits)
+        public static Information<T> FromPetabits(T petabits)
         {
-            decimal value = (decimal) petabits;
-            return new Information(value, InformationUnit.Petabit);
+            return new Information<T>(petabits, InformationUnit.Petabit);
         }
         /// <summary>
-        ///     Get Information from Petabytes.
+        ///     Get <see cref="Information{T}" /> from Petabytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPetabytes(QuantityValue petabytes)
+        public static Information<T> FromPetabytes(T petabytes)
         {
-            decimal value = (decimal) petabytes;
-            return new Information(value, InformationUnit.Petabyte);
+            return new Information<T>(petabytes, InformationUnit.Petabyte);
         }
         /// <summary>
-        ///     Get Information from Tebibits.
+        ///     Get <see cref="Information{T}" /> from Tebibits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTebibits(QuantityValue tebibits)
+        public static Information<T> FromTebibits(T tebibits)
         {
-            decimal value = (decimal) tebibits;
-            return new Information(value, InformationUnit.Tebibit);
+            return new Information<T>(tebibits, InformationUnit.Tebibit);
         }
         /// <summary>
-        ///     Get Information from Tebibytes.
+        ///     Get <see cref="Information{T}" /> from Tebibytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTebibytes(QuantityValue tebibytes)
+        public static Information<T> FromTebibytes(T tebibytes)
         {
-            decimal value = (decimal) tebibytes;
-            return new Information(value, InformationUnit.Tebibyte);
+            return new Information<T>(tebibytes, InformationUnit.Tebibyte);
         }
         /// <summary>
-        ///     Get Information from Terabits.
+        ///     Get <see cref="Information{T}" /> from Terabits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTerabits(QuantityValue terabits)
+        public static Information<T> FromTerabits(T terabits)
         {
-            decimal value = (decimal) terabits;
-            return new Information(value, InformationUnit.Terabit);
+            return new Information<T>(terabits, InformationUnit.Terabit);
         }
         /// <summary>
-        ///     Get Information from Terabytes.
+        ///     Get <see cref="Information{T}" /> from Terabytes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTerabytes(QuantityValue terabytes)
+        public static Information<T> FromTerabytes(T terabytes)
         {
-            decimal value = (decimal) terabytes;
-            return new Information(value, InformationUnit.Terabyte);
+            return new Information<T>(terabytes, InformationUnit.Terabyte);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="InformationUnit" /> to <see cref="Information" />.
+        ///     Dynamically convert from value and unit enum <see cref="InformationUnit" /> to <see cref="Information{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Information unit value.</returns>
-        public static Information From(QuantityValue value, InformationUnit fromUnit)
+        /// <returns><see cref="Information{T}" /> unit value.</returns>
+        public static Information<T> From(T value, InformationUnit fromUnit)
         {
-            return new Information((decimal)value, fromUnit);
+            return new Information<T>(value, fromUnit);
         }
 
         #endregion
@@ -627,7 +597,7 @@ public static Information From(QuantityValue value, InformationUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Information Parse(string str)
+        public static Information<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -655,9 +625,9 @@ public static Information Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Information Parse(string str, IFormatProvider? provider)
+        public static Information<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Information, InformationUnit>(
+            return QuantityParser.Default.Parse<T, Information<T>, InformationUnit>(
                 str,
                 provider,
                 From);
@@ -671,7 +641,7 @@ public static Information Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Information result)
+        public static bool TryParse(string? str, out Information<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -686,9 +656,9 @@ public static bool TryParse(string? str, out Information result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Information result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Information<T> result)
         {
-            return QuantityParser.Default.TryParse<Information, InformationUnit>(
+            return QuantityParser.Default.TryParse<T, Information<T>, InformationUnit>(
                 str,
                 provider,
                 From,
@@ -750,45 +720,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Infor
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Information operator -(Information right)
+        public static Information<T> operator -(Information<T> right)
         {
-            return new Information(-right.Value, right.Unit);
+            return new Information<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Information"/> from adding two <see cref="Information"/>.</summary>
-        public static Information operator +(Information left, Information right)
+        /// <summary>Get <see cref="Information{T}"/> from adding two <see cref="Information{T}"/>.</summary>
+        public static Information<T> operator +(Information<T> left, Information<T> right)
         {
-            return new Information(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Information<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Information"/> from subtracting two <see cref="Information"/>.</summary>
-        public static Information operator -(Information left, Information right)
+        /// <summary>Get <see cref="Information{T}"/> from subtracting two <see cref="Information{T}"/>.</summary>
+        public static Information<T> operator -(Information<T> left, Information<T> right)
         {
-            return new Information(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Information<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Information"/> from multiplying value and <see cref="Information"/>.</summary>
-        public static Information operator *(decimal left, Information right)
+        /// <summary>Get <see cref="Information{T}"/> from multiplying value and <see cref="Information{T}"/>.</summary>
+        public static Information<T> operator *(T left, Information<T> right)
         {
-            return new Information(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Information<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Information"/> from multiplying value and <see cref="Information"/>.</summary>
-        public static Information operator *(Information left, decimal right)
+        /// <summary>Get <see cref="Information{T}"/> from multiplying value and <see cref="Information{T}"/>.</summary>
+        public static Information<T> operator *(Information<T> left, T right)
         {
-            return new Information(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Information<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Information"/> from dividing <see cref="Information"/> by value.</summary>
-        public static Information operator /(Information left, decimal right)
+        /// <summary>Get <see cref="Information{T}"/> from dividing <see cref="Information{T}"/> by value.</summary>
+        public static Information<T> operator /(Information<T> left, T right)
         {
-            return new Information(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Information<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Information"/> by <see cref="Information"/>.</summary>
-        public static double operator /(Information left, Information right)
+        /// <summary>Get ratio value from dividing <see cref="Information{T}"/> by <see cref="Information{T}"/>.</summary>
+        public static T operator /(Information<T> left, Information<T> right)
         {
-            return left.Bits / right.Bits;
+            return CompiledLambdas.Divide(left.Bits, right.Bits);
         }
 
         #endregion
@@ -796,39 +771,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Infor
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Information left, Information right)
+        public static bool operator <=(Information<T> left, Information<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Information left, Information right)
+        public static bool operator >=(Information<T> left, Information<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Information left, Information right)
+        public static bool operator <(Information<T> left, Information<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Information left, Information right)
+        public static bool operator >(Information<T> left, Information<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Information, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Information left, Information right)
+        /// <remarks>Consider using <see cref="Equals(Information{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Information<T> left, Information<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Information, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Information left, Information right)
+        /// <remarks>Consider using <see cref="Equals(Information{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Information<T> left, Information<T> right)
         {
             return !(left == right);
         }
@@ -837,37 +812,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Infor
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Information objInformation)) throw new ArgumentException("Expected type Information.", nameof(obj));
+            if(!(obj is Information<T> objInformation)) throw new ArgumentException("Expected type Information.", nameof(obj));
 
             return CompareTo(objInformation);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Information other)
+        public int CompareTo(Information<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Information, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Information{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Information objInformation))
+            if(obj is null || !(obj is Information<T> objInformation))
                 return false;
 
             return Equals(objInformation);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Information, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Information other)
+        /// <remarks>Consider using <see cref="Equals(Information{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Information<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Information within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Information{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -905,21 +880,19 @@ public bool Equals(Information other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Information other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Information<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Information.</returns>
+        /// <returns>A hash code for the current <see cref="Information{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -933,17 +906,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(InformationUnit unit)
+        public T As(InformationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -963,17 +936,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is InformationUnit unitAsInformationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(InformationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsInformationUnit);
+            var asValue = As(unitAsInformationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<InformationUnit>.As(InformationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Information to another Information with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Information{T}" /> to another <see cref="Information{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Information with the specified unit.</returns>
-        public Information ToUnit(InformationUnit unit)
+        /// <returns>A <see cref="Information{T}" /> with the specified unit.</returns>
+        public Information<T> ToUnit(InformationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Information(convertedValue, unit);
+            return new Information<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -986,7 +964,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Information ToUnit(UnitSystem unitSystem)
+        public Information<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1006,44 +984,50 @@ public Information ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<InformationUnit> IQuantity<InformationUnit>.ToUnit(InformationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<InformationUnit, T> IQuantityT<InformationUnit, T>.ToUnit(InformationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<InformationUnit> IQuantity<InformationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<InformationUnit, T> IQuantityT<InformationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private decimal GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case InformationUnit.Bit: return _value;
-                case InformationUnit.Byte: return _value*8m;
-                case InformationUnit.Exabit: return (_value) * 1e18m;
-                case InformationUnit.Exabyte: return (_value*8m) * 1e18m;
-                case InformationUnit.Exbibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
-                case InformationUnit.Exbibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
-                case InformationUnit.Gibibit: return (_value) * (1024m * 1024 * 1024);
-                case InformationUnit.Gibibyte: return (_value*8m) * (1024m * 1024 * 1024);
-                case InformationUnit.Gigabit: return (_value) * 1e9m;
-                case InformationUnit.Gigabyte: return (_value*8m) * 1e9m;
-                case InformationUnit.Kibibit: return (_value) * 1024m;
-                case InformationUnit.Kibibyte: return (_value*8m) * 1024m;
-                case InformationUnit.Kilobit: return (_value) * 1e3m;
-                case InformationUnit.Kilobyte: return (_value*8m) * 1e3m;
-                case InformationUnit.Mebibit: return (_value) * (1024m * 1024);
-                case InformationUnit.Mebibyte: return (_value*8m) * (1024m * 1024);
-                case InformationUnit.Megabit: return (_value) * 1e6m;
-                case InformationUnit.Megabyte: return (_value*8m) * 1e6m;
-                case InformationUnit.Pebibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024);
-                case InformationUnit.Pebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024);
-                case InformationUnit.Petabit: return (_value) * 1e15m;
-                case InformationUnit.Petabyte: return (_value*8m) * 1e15m;
-                case InformationUnit.Tebibit: return (_value) * (1024m * 1024 * 1024 * 1024);
-                case InformationUnit.Tebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024);
-                case InformationUnit.Terabit: return (_value) * 1e12m;
-                case InformationUnit.Terabyte: return (_value*8m) * 1e12m;
+                case InformationUnit.Bit: return Value;
+                case InformationUnit.Byte: return Value*8m;
+                case InformationUnit.Exabit: return (Value) * 1e18m;
+                case InformationUnit.Exabyte: return (Value*8m) * 1e18m;
+                case InformationUnit.Exbibit: return (Value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
+                case InformationUnit.Exbibyte: return (Value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
+                case InformationUnit.Gibibit: return (Value) * (1024m * 1024 * 1024);
+                case InformationUnit.Gibibyte: return (Value*8m) * (1024m * 1024 * 1024);
+                case InformationUnit.Gigabit: return (Value) * 1e9m;
+                case InformationUnit.Gigabyte: return (Value*8m) * 1e9m;
+                case InformationUnit.Kibibit: return (Value) * 1024m;
+                case InformationUnit.Kibibyte: return (Value*8m) * 1024m;
+                case InformationUnit.Kilobit: return (Value) * 1e3m;
+                case InformationUnit.Kilobyte: return (Value*8m) * 1e3m;
+                case InformationUnit.Mebibit: return (Value) * (1024m * 1024);
+                case InformationUnit.Mebibyte: return (Value*8m) * (1024m * 1024);
+                case InformationUnit.Megabit: return (Value) * 1e6m;
+                case InformationUnit.Megabyte: return (Value*8m) * 1e6m;
+                case InformationUnit.Pebibit: return (Value) * (1024m * 1024 * 1024 * 1024 * 1024);
+                case InformationUnit.Pebibyte: return (Value*8m) * (1024m * 1024 * 1024 * 1024 * 1024);
+                case InformationUnit.Petabit: return (Value) * 1e15m;
+                case InformationUnit.Petabyte: return (Value*8m) * 1e15m;
+                case InformationUnit.Tebibit: return (Value) * (1024m * 1024 * 1024 * 1024);
+                case InformationUnit.Tebibyte: return (Value*8m) * (1024m * 1024 * 1024 * 1024);
+                case InformationUnit.Terabit: return (Value) * 1e12m;
+                case InformationUnit.Terabyte: return (Value*8m) * 1e12m;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1054,16 +1038,16 @@ private decimal GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Information ToBaseUnit()
+        internal Information<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Information(baseUnitValue, BaseUnit);
+            return new Information<T>(baseUnitValue, BaseUnit);
         }
 
-        private decimal GetValueAs(InformationUnit unit)
+        private T GetValueAs(InformationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1191,57 +1175,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Information)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Information<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Information)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Information<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Information)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Information<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1251,33 +1235,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Information))
+            if(conversionType == typeof(Information<T>))
                 return this;
             else if(conversionType == typeof(InformationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Information.QuantityType;
+                return Information<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Information.Info;
+                return Information<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Information.BaseDimensions;
+                return Information<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Information)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Information<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
index 243e700262..6a2af8311d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Irradiance is the intensity of ultraviolet (UV) or visible light incident on a surface.
     /// </summary>
-    public partial struct Irradiance : IQuantity<IrradianceUnit>, IEquatable<Irradiance>, IComparable, IComparable<Irradiance>, IConvertible, IFormattable
+    public partial struct Irradiance<T> : IQuantityT<IrradianceUnit, T>, IEquatable<Irradiance<T>>, IComparable, IComparable<Irradiance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -76,12 +72,12 @@ static Irradiance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Irradiance(double value, IrradianceUnit unit)
+        public Irradiance(T value, IrradianceUnit unit)
         {
             if(unit == IrradianceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -93,14 +89,14 @@ public Irradiance(double value, IrradianceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Irradiance(double value, UnitSystem unitSystem)
+        public Irradiance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -115,19 +111,19 @@ public Irradiance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Irradiance, which is WattPerSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Irradiance{T}" />, which is WattPerSquareMeter. All conversions go via this value.
         /// </summary>
         public static IrradianceUnit BaseUnit { get; } = IrradianceUnit.WattPerSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Irradiance
+        /// Represents the largest possible value of <see cref="Irradiance{T}" />
         /// </summary>
-        public static Irradiance MaxValue { get; } = new Irradiance(double.MaxValue, BaseUnit);
+        public static Irradiance<T> MaxValue { get; } = new Irradiance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Irradiance
+        /// Represents the smallest possible value of <see cref="Irradiance{T}" />
         /// </summary>
-        public static Irradiance MinValue { get; } = new Irradiance(double.MinValue, BaseUnit);
+        public static Irradiance<T> MinValue { get; } = new Irradiance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -136,14 +132,14 @@ public Irradiance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Irradiance;
 
         /// <summary>
-        ///     All units of measurement for the Irradiance quantity.
+        ///     All units of measurement for the <see cref="Irradiance{T}" /> quantity.
         /// </summary>
         public static IrradianceUnit[] Units { get; } = Enum.GetValues(typeof(IrradianceUnit)).Cast<IrradianceUnit>().Except(new IrradianceUnit[]{ IrradianceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit WattPerSquareMeter.
         /// </summary>
-        public static Irradiance Zero { get; } = new Irradiance(0, BaseUnit);
+        public static Irradiance<T> Zero { get; } = new Irradiance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -152,7 +148,9 @@ public Irradiance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -168,86 +166,86 @@ public Irradiance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Irradiance.QuantityType;
+        public QuantityType Type => Irradiance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Irradiance.BaseDimensions;
+        public BaseDimensions Dimensions => Irradiance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Irradiance in KilowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> in KilowattsPerSquareCentimeter.
         /// </summary>
-        public double KilowattsPerSquareCentimeter => As(IrradianceUnit.KilowattPerSquareCentimeter);
+        public T KilowattsPerSquareCentimeter => As(IrradianceUnit.KilowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiance in KilowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> in KilowattsPerSquareMeter.
         /// </summary>
-        public double KilowattsPerSquareMeter => As(IrradianceUnit.KilowattPerSquareMeter);
+        public T KilowattsPerSquareMeter => As(IrradianceUnit.KilowattPerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiance in MegawattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> in MegawattsPerSquareCentimeter.
         /// </summary>
-        public double MegawattsPerSquareCentimeter => As(IrradianceUnit.MegawattPerSquareCentimeter);
+        public T MegawattsPerSquareCentimeter => As(IrradianceUnit.MegawattPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiance in MegawattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> in MegawattsPerSquareMeter.
         /// </summary>
-        public double MegawattsPerSquareMeter => As(IrradianceUnit.MegawattPerSquareMeter);
+        public T MegawattsPerSquareMeter => As(IrradianceUnit.MegawattPerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiance in MicrowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> in MicrowattsPerSquareCentimeter.
         /// </summary>
-        public double MicrowattsPerSquareCentimeter => As(IrradianceUnit.MicrowattPerSquareCentimeter);
+        public T MicrowattsPerSquareCentimeter => As(IrradianceUnit.MicrowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiance in MicrowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> in MicrowattsPerSquareMeter.
         /// </summary>
-        public double MicrowattsPerSquareMeter => As(IrradianceUnit.MicrowattPerSquareMeter);
+        public T MicrowattsPerSquareMeter => As(IrradianceUnit.MicrowattPerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiance in MilliwattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> in MilliwattsPerSquareCentimeter.
         /// </summary>
-        public double MilliwattsPerSquareCentimeter => As(IrradianceUnit.MilliwattPerSquareCentimeter);
+        public T MilliwattsPerSquareCentimeter => As(IrradianceUnit.MilliwattPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiance in MilliwattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> in MilliwattsPerSquareMeter.
         /// </summary>
-        public double MilliwattsPerSquareMeter => As(IrradianceUnit.MilliwattPerSquareMeter);
+        public T MilliwattsPerSquareMeter => As(IrradianceUnit.MilliwattPerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiance in NanowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> in NanowattsPerSquareCentimeter.
         /// </summary>
-        public double NanowattsPerSquareCentimeter => As(IrradianceUnit.NanowattPerSquareCentimeter);
+        public T NanowattsPerSquareCentimeter => As(IrradianceUnit.NanowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiance in NanowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> in NanowattsPerSquareMeter.
         /// </summary>
-        public double NanowattsPerSquareMeter => As(IrradianceUnit.NanowattPerSquareMeter);
+        public T NanowattsPerSquareMeter => As(IrradianceUnit.NanowattPerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiance in PicowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> in PicowattsPerSquareCentimeter.
         /// </summary>
-        public double PicowattsPerSquareCentimeter => As(IrradianceUnit.PicowattPerSquareCentimeter);
+        public T PicowattsPerSquareCentimeter => As(IrradianceUnit.PicowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiance in PicowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> in PicowattsPerSquareMeter.
         /// </summary>
-        public double PicowattsPerSquareMeter => As(IrradianceUnit.PicowattPerSquareMeter);
+        public T PicowattsPerSquareMeter => As(IrradianceUnit.PicowattPerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiance in WattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> in WattsPerSquareCentimeter.
         /// </summary>
-        public double WattsPerSquareCentimeter => As(IrradianceUnit.WattPerSquareCentimeter);
+        public T WattsPerSquareCentimeter => As(IrradianceUnit.WattPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiance in WattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> in WattsPerSquareMeter.
         /// </summary>
-        public double WattsPerSquareMeter => As(IrradianceUnit.WattPerSquareMeter);
+        public T WattsPerSquareMeter => As(IrradianceUnit.WattPerSquareMeter);
 
         #endregion
 
@@ -279,141 +277,127 @@ public static string GetAbbreviation(IrradianceUnit unit, IFormatProvider? provi
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Irradiance from KilowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> from KilowattsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromKilowattsPerSquareCentimeter(QuantityValue kilowattspersquarecentimeter)
+        public static Irradiance<T> FromKilowattsPerSquareCentimeter(T kilowattspersquarecentimeter)
         {
-            double value = (double) kilowattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter);
+            return new Irradiance<T>(kilowattspersquarecentimeter, IrradianceUnit.KilowattPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiance from KilowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> from KilowattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromKilowattsPerSquareMeter(QuantityValue kilowattspersquaremeter)
+        public static Irradiance<T> FromKilowattsPerSquareMeter(T kilowattspersquaremeter)
         {
-            double value = (double) kilowattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter);
+            return new Irradiance<T>(kilowattspersquaremeter, IrradianceUnit.KilowattPerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiance from MegawattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> from MegawattsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMegawattsPerSquareCentimeter(QuantityValue megawattspersquarecentimeter)
+        public static Irradiance<T> FromMegawattsPerSquareCentimeter(T megawattspersquarecentimeter)
         {
-            double value = (double) megawattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter);
+            return new Irradiance<T>(megawattspersquarecentimeter, IrradianceUnit.MegawattPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiance from MegawattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> from MegawattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMegawattsPerSquareMeter(QuantityValue megawattspersquaremeter)
+        public static Irradiance<T> FromMegawattsPerSquareMeter(T megawattspersquaremeter)
         {
-            double value = (double) megawattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter);
+            return new Irradiance<T>(megawattspersquaremeter, IrradianceUnit.MegawattPerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiance from MicrowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> from MicrowattsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMicrowattsPerSquareCentimeter(QuantityValue microwattspersquarecentimeter)
+        public static Irradiance<T> FromMicrowattsPerSquareCentimeter(T microwattspersquarecentimeter)
         {
-            double value = (double) microwattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter);
+            return new Irradiance<T>(microwattspersquarecentimeter, IrradianceUnit.MicrowattPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiance from MicrowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> from MicrowattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMicrowattsPerSquareMeter(QuantityValue microwattspersquaremeter)
+        public static Irradiance<T> FromMicrowattsPerSquareMeter(T microwattspersquaremeter)
         {
-            double value = (double) microwattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter);
+            return new Irradiance<T>(microwattspersquaremeter, IrradianceUnit.MicrowattPerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiance from MilliwattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> from MilliwattsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMilliwattsPerSquareCentimeter(QuantityValue milliwattspersquarecentimeter)
+        public static Irradiance<T> FromMilliwattsPerSquareCentimeter(T milliwattspersquarecentimeter)
         {
-            double value = (double) milliwattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter);
+            return new Irradiance<T>(milliwattspersquarecentimeter, IrradianceUnit.MilliwattPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiance from MilliwattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> from MilliwattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMilliwattsPerSquareMeter(QuantityValue milliwattspersquaremeter)
+        public static Irradiance<T> FromMilliwattsPerSquareMeter(T milliwattspersquaremeter)
         {
-            double value = (double) milliwattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter);
+            return new Irradiance<T>(milliwattspersquaremeter, IrradianceUnit.MilliwattPerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiance from NanowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> from NanowattsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromNanowattsPerSquareCentimeter(QuantityValue nanowattspersquarecentimeter)
+        public static Irradiance<T> FromNanowattsPerSquareCentimeter(T nanowattspersquarecentimeter)
         {
-            double value = (double) nanowattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter);
+            return new Irradiance<T>(nanowattspersquarecentimeter, IrradianceUnit.NanowattPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiance from NanowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> from NanowattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromNanowattsPerSquareMeter(QuantityValue nanowattspersquaremeter)
+        public static Irradiance<T> FromNanowattsPerSquareMeter(T nanowattspersquaremeter)
         {
-            double value = (double) nanowattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter);
+            return new Irradiance<T>(nanowattspersquaremeter, IrradianceUnit.NanowattPerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiance from PicowattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> from PicowattsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromPicowattsPerSquareCentimeter(QuantityValue picowattspersquarecentimeter)
+        public static Irradiance<T> FromPicowattsPerSquareCentimeter(T picowattspersquarecentimeter)
         {
-            double value = (double) picowattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter);
+            return new Irradiance<T>(picowattspersquarecentimeter, IrradianceUnit.PicowattPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiance from PicowattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> from PicowattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromPicowattsPerSquareMeter(QuantityValue picowattspersquaremeter)
+        public static Irradiance<T> FromPicowattsPerSquareMeter(T picowattspersquaremeter)
         {
-            double value = (double) picowattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter);
+            return new Irradiance<T>(picowattspersquaremeter, IrradianceUnit.PicowattPerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiance from WattsPerSquareCentimeter.
+        ///     Get <see cref="Irradiance{T}" /> from WattsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromWattsPerSquareCentimeter(QuantityValue wattspersquarecentimeter)
+        public static Irradiance<T> FromWattsPerSquareCentimeter(T wattspersquarecentimeter)
         {
-            double value = (double) wattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter);
+            return new Irradiance<T>(wattspersquarecentimeter, IrradianceUnit.WattPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiance from WattsPerSquareMeter.
+        ///     Get <see cref="Irradiance{T}" /> from WattsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromWattsPerSquareMeter(QuantityValue wattspersquaremeter)
+        public static Irradiance<T> FromWattsPerSquareMeter(T wattspersquaremeter)
         {
-            double value = (double) wattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.WattPerSquareMeter);
+            return new Irradiance<T>(wattspersquaremeter, IrradianceUnit.WattPerSquareMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="IrradianceUnit" /> to <see cref="Irradiance" />.
+        ///     Dynamically convert from value and unit enum <see cref="IrradianceUnit" /> to <see cref="Irradiance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Irradiance unit value.</returns>
-        public static Irradiance From(QuantityValue value, IrradianceUnit fromUnit)
+        /// <returns><see cref="Irradiance{T}" /> unit value.</returns>
+        public static Irradiance<T> From(T value, IrradianceUnit fromUnit)
         {
-            return new Irradiance((double)value, fromUnit);
+            return new Irradiance<T>(value, fromUnit);
         }
 
         #endregion
@@ -442,7 +426,7 @@ public static Irradiance From(QuantityValue value, IrradianceUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Irradiance Parse(string str)
+        public static Irradiance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -470,9 +454,9 @@ public static Irradiance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Irradiance Parse(string str, IFormatProvider? provider)
+        public static Irradiance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Irradiance, IrradianceUnit>(
+            return QuantityParser.Default.Parse<T, Irradiance<T>, IrradianceUnit>(
                 str,
                 provider,
                 From);
@@ -486,7 +470,7 @@ public static Irradiance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Irradiance result)
+        public static bool TryParse(string? str, out Irradiance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -501,9 +485,9 @@ public static bool TryParse(string? str, out Irradiance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Irradiance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Irradiance<T> result)
         {
-            return QuantityParser.Default.TryParse<Irradiance, IrradianceUnit>(
+            return QuantityParser.Default.TryParse<T, Irradiance<T>, IrradianceUnit>(
                 str,
                 provider,
                 From,
@@ -565,45 +549,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Irrad
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Irradiance operator -(Irradiance right)
+        public static Irradiance<T> operator -(Irradiance<T> right)
         {
-            return new Irradiance(-right.Value, right.Unit);
+            return new Irradiance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiance"/> from adding two <see cref="Irradiance"/>.</summary>
-        public static Irradiance operator +(Irradiance left, Irradiance right)
+        /// <summary>Get <see cref="Irradiance{T}"/> from adding two <see cref="Irradiance{T}"/>.</summary>
+        public static Irradiance<T> operator +(Irradiance<T> left, Irradiance<T> right)
         {
-            return new Irradiance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Irradiance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiance"/> from subtracting two <see cref="Irradiance"/>.</summary>
-        public static Irradiance operator -(Irradiance left, Irradiance right)
+        /// <summary>Get <see cref="Irradiance{T}"/> from subtracting two <see cref="Irradiance{T}"/>.</summary>
+        public static Irradiance<T> operator -(Irradiance<T> left, Irradiance<T> right)
         {
-            return new Irradiance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Irradiance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiance"/> from multiplying value and <see cref="Irradiance"/>.</summary>
-        public static Irradiance operator *(double left, Irradiance right)
+        /// <summary>Get <see cref="Irradiance{T}"/> from multiplying value and <see cref="Irradiance{T}"/>.</summary>
+        public static Irradiance<T> operator *(T left, Irradiance<T> right)
         {
-            return new Irradiance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Irradiance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiance"/> from multiplying value and <see cref="Irradiance"/>.</summary>
-        public static Irradiance operator *(Irradiance left, double right)
+        /// <summary>Get <see cref="Irradiance{T}"/> from multiplying value and <see cref="Irradiance{T}"/>.</summary>
+        public static Irradiance<T> operator *(Irradiance<T> left, T right)
         {
-            return new Irradiance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Irradiance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiance"/> from dividing <see cref="Irradiance"/> by value.</summary>
-        public static Irradiance operator /(Irradiance left, double right)
+        /// <summary>Get <see cref="Irradiance{T}"/> from dividing <see cref="Irradiance{T}"/> by value.</summary>
+        public static Irradiance<T> operator /(Irradiance<T> left, T right)
         {
-            return new Irradiance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Irradiance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Irradiance"/> by <see cref="Irradiance"/>.</summary>
-        public static double operator /(Irradiance left, Irradiance right)
+        /// <summary>Get ratio value from dividing <see cref="Irradiance{T}"/> by <see cref="Irradiance{T}"/>.</summary>
+        public static T operator /(Irradiance<T> left, Irradiance<T> right)
         {
-            return left.WattsPerSquareMeter / right.WattsPerSquareMeter;
+            return CompiledLambdas.Divide(left.WattsPerSquareMeter, right.WattsPerSquareMeter);
         }
 
         #endregion
@@ -611,39 +600,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Irrad
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Irradiance left, Irradiance right)
+        public static bool operator <=(Irradiance<T> left, Irradiance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Irradiance left, Irradiance right)
+        public static bool operator >=(Irradiance<T> left, Irradiance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Irradiance left, Irradiance right)
+        public static bool operator <(Irradiance<T> left, Irradiance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Irradiance left, Irradiance right)
+        public static bool operator >(Irradiance<T> left, Irradiance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Irradiance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Irradiance left, Irradiance right)
+        /// <remarks>Consider using <see cref="Equals(Irradiance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Irradiance<T> left, Irradiance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Irradiance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Irradiance left, Irradiance right)
+        /// <remarks>Consider using <see cref="Equals(Irradiance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Irradiance<T> left, Irradiance<T> right)
         {
             return !(left == right);
         }
@@ -652,37 +641,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Irrad
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Irradiance objIrradiance)) throw new ArgumentException("Expected type Irradiance.", nameof(obj));
+            if(!(obj is Irradiance<T> objIrradiance)) throw new ArgumentException("Expected type Irradiance.", nameof(obj));
 
             return CompareTo(objIrradiance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Irradiance other)
+        public int CompareTo(Irradiance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Irradiance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Irradiance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Irradiance objIrradiance))
+            if(obj is null || !(obj is Irradiance<T> objIrradiance))
                 return false;
 
             return Equals(objIrradiance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Irradiance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Irradiance other)
+        /// <remarks>Consider using <see cref="Equals(Irradiance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Irradiance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Irradiance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Irradiance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -720,21 +709,19 @@ public bool Equals(Irradiance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Irradiance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Irradiance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Irradiance.</returns>
+        /// <returns>A hash code for the current <see cref="Irradiance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -748,17 +735,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(IrradianceUnit unit)
+        public T As(IrradianceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -778,17 +765,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is IrradianceUnit unitAsIrradianceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradianceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsIrradianceUnit);
+            var asValue = As(unitAsIrradianceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<IrradianceUnit>.As(IrradianceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Irradiance to another Irradiance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Irradiance{T}" /> to another <see cref="Irradiance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Irradiance with the specified unit.</returns>
-        public Irradiance ToUnit(IrradianceUnit unit)
+        /// <returns>A <see cref="Irradiance{T}" /> with the specified unit.</returns>
+        public Irradiance<T> ToUnit(IrradianceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Irradiance(convertedValue, unit);
+            return new Irradiance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -801,7 +793,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Irradiance ToUnit(UnitSystem unitSystem)
+        public Irradiance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -821,32 +813,38 @@ public Irradiance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<IrradianceUnit> IQuantity<IrradianceUnit>.ToUnit(IrradianceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<IrradianceUnit, T> IQuantityT<IrradianceUnit, T>.ToUnit(IrradianceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<IrradianceUnit> IQuantity<IrradianceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<IrradianceUnit, T> IQuantityT<IrradianceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case IrradianceUnit.KilowattPerSquareCentimeter: return (_value*10000) * 1e3d;
-                case IrradianceUnit.KilowattPerSquareMeter: return (_value) * 1e3d;
-                case IrradianceUnit.MegawattPerSquareCentimeter: return (_value*10000) * 1e6d;
-                case IrradianceUnit.MegawattPerSquareMeter: return (_value) * 1e6d;
-                case IrradianceUnit.MicrowattPerSquareCentimeter: return (_value*10000) * 1e-6d;
-                case IrradianceUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d;
-                case IrradianceUnit.MilliwattPerSquareCentimeter: return (_value*10000) * 1e-3d;
-                case IrradianceUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d;
-                case IrradianceUnit.NanowattPerSquareCentimeter: return (_value*10000) * 1e-9d;
-                case IrradianceUnit.NanowattPerSquareMeter: return (_value) * 1e-9d;
-                case IrradianceUnit.PicowattPerSquareCentimeter: return (_value*10000) * 1e-12d;
-                case IrradianceUnit.PicowattPerSquareMeter: return (_value) * 1e-12d;
-                case IrradianceUnit.WattPerSquareCentimeter: return _value*10000;
-                case IrradianceUnit.WattPerSquareMeter: return _value;
+                case IrradianceUnit.KilowattPerSquareCentimeter: return (Value*10000) * 1e3d;
+                case IrradianceUnit.KilowattPerSquareMeter: return (Value) * 1e3d;
+                case IrradianceUnit.MegawattPerSquareCentimeter: return (Value*10000) * 1e6d;
+                case IrradianceUnit.MegawattPerSquareMeter: return (Value) * 1e6d;
+                case IrradianceUnit.MicrowattPerSquareCentimeter: return (Value*10000) * 1e-6d;
+                case IrradianceUnit.MicrowattPerSquareMeter: return (Value) * 1e-6d;
+                case IrradianceUnit.MilliwattPerSquareCentimeter: return (Value*10000) * 1e-3d;
+                case IrradianceUnit.MilliwattPerSquareMeter: return (Value) * 1e-3d;
+                case IrradianceUnit.NanowattPerSquareCentimeter: return (Value*10000) * 1e-9d;
+                case IrradianceUnit.NanowattPerSquareMeter: return (Value) * 1e-9d;
+                case IrradianceUnit.PicowattPerSquareCentimeter: return (Value*10000) * 1e-12d;
+                case IrradianceUnit.PicowattPerSquareMeter: return (Value) * 1e-12d;
+                case IrradianceUnit.WattPerSquareCentimeter: return Value*10000;
+                case IrradianceUnit.WattPerSquareMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -857,16 +855,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Irradiance ToBaseUnit()
+        internal Irradiance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Irradiance(baseUnitValue, BaseUnit);
+            return new Irradiance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(IrradianceUnit unit)
+        private T GetValueAs(IrradianceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -982,57 +980,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Irradiance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Irradiance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Irradiance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Irradiance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Irradiance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Irradiance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1042,33 +1040,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Irradiance))
+            if(conversionType == typeof(Irradiance<T>))
                 return this;
             else if(conversionType == typeof(IrradianceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Irradiance.QuantityType;
+                return Irradiance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Irradiance.Info;
+                return Irradiance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Irradiance.BaseDimensions;
+                return Irradiance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Irradiance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Irradiance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
index 2579a542fc..fd28f61827 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Irradiation
     /// </remarks>
-    public partial struct Irradiation : IQuantity<IrradiationUnit>, IEquatable<Irradiation>, IComparable, IComparable<Irradiation>, IConvertible, IFormattable
+    public partial struct Irradiation<T> : IQuantityT<IrradiationUnit, T>, IEquatable<Irradiation<T>>, IComparable, IComparable<Irradiation<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -72,12 +68,12 @@ static Irradiation()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Irradiation(double value, IrradiationUnit unit)
+        public Irradiation(T value, IrradiationUnit unit)
         {
             if(unit == IrradiationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -89,14 +85,14 @@ public Irradiation(double value, IrradiationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Irradiation(double value, UnitSystem unitSystem)
+        public Irradiation(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -111,19 +107,19 @@ public Irradiation(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Irradiation, which is JoulePerSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Irradiation{T}" />, which is JoulePerSquareMeter. All conversions go via this value.
         /// </summary>
         public static IrradiationUnit BaseUnit { get; } = IrradiationUnit.JoulePerSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Irradiation
+        /// Represents the largest possible value of <see cref="Irradiation{T}" />
         /// </summary>
-        public static Irradiation MaxValue { get; } = new Irradiation(double.MaxValue, BaseUnit);
+        public static Irradiation<T> MaxValue { get; } = new Irradiation<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Irradiation
+        /// Represents the smallest possible value of <see cref="Irradiation{T}" />
         /// </summary>
-        public static Irradiation MinValue { get; } = new Irradiation(double.MinValue, BaseUnit);
+        public static Irradiation<T> MinValue { get; } = new Irradiation<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -132,14 +128,14 @@ public Irradiation(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Irradiation;
 
         /// <summary>
-        ///     All units of measurement for the Irradiation quantity.
+        ///     All units of measurement for the <see cref="Irradiation{T}" /> quantity.
         /// </summary>
         public static IrradiationUnit[] Units { get; } = Enum.GetValues(typeof(IrradiationUnit)).Cast<IrradiationUnit>().Except(new IrradiationUnit[]{ IrradiationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit JoulePerSquareMeter.
         /// </summary>
-        public static Irradiation Zero { get; } = new Irradiation(0, BaseUnit);
+        public static Irradiation<T> Zero { get; } = new Irradiation<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -148,7 +144,9 @@ public Irradiation(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -164,51 +162,51 @@ public Irradiation(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Irradiation.QuantityType;
+        public QuantityType Type => Irradiation<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Irradiation.BaseDimensions;
+        public BaseDimensions Dimensions => Irradiation<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Irradiation in JoulesPerSquareCentimeter.
+        ///     Get <see cref="Irradiation{T}" /> in JoulesPerSquareCentimeter.
         /// </summary>
-        public double JoulesPerSquareCentimeter => As(IrradiationUnit.JoulePerSquareCentimeter);
+        public T JoulesPerSquareCentimeter => As(IrradiationUnit.JoulePerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiation in JoulesPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> in JoulesPerSquareMeter.
         /// </summary>
-        public double JoulesPerSquareMeter => As(IrradiationUnit.JoulePerSquareMeter);
+        public T JoulesPerSquareMeter => As(IrradiationUnit.JoulePerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiation in JoulesPerSquareMillimeter.
+        ///     Get <see cref="Irradiation{T}" /> in JoulesPerSquareMillimeter.
         /// </summary>
-        public double JoulesPerSquareMillimeter => As(IrradiationUnit.JoulePerSquareMillimeter);
+        public T JoulesPerSquareMillimeter => As(IrradiationUnit.JoulePerSquareMillimeter);
 
         /// <summary>
-        ///     Get Irradiation in KilojoulesPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> in KilojoulesPerSquareMeter.
         /// </summary>
-        public double KilojoulesPerSquareMeter => As(IrradiationUnit.KilojoulePerSquareMeter);
+        public T KilojoulesPerSquareMeter => As(IrradiationUnit.KilojoulePerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiation in KilowattHoursPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> in KilowattHoursPerSquareMeter.
         /// </summary>
-        public double KilowattHoursPerSquareMeter => As(IrradiationUnit.KilowattHourPerSquareMeter);
+        public T KilowattHoursPerSquareMeter => As(IrradiationUnit.KilowattHourPerSquareMeter);
 
         /// <summary>
-        ///     Get Irradiation in MillijoulesPerSquareCentimeter.
+        ///     Get <see cref="Irradiation{T}" /> in MillijoulesPerSquareCentimeter.
         /// </summary>
-        public double MillijoulesPerSquareCentimeter => As(IrradiationUnit.MillijoulePerSquareCentimeter);
+        public T MillijoulesPerSquareCentimeter => As(IrradiationUnit.MillijoulePerSquareCentimeter);
 
         /// <summary>
-        ///     Get Irradiation in WattHoursPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> in WattHoursPerSquareMeter.
         /// </summary>
-        public double WattHoursPerSquareMeter => As(IrradiationUnit.WattHourPerSquareMeter);
+        public T WattHoursPerSquareMeter => As(IrradiationUnit.WattHourPerSquareMeter);
 
         #endregion
 
@@ -240,78 +238,71 @@ public static string GetAbbreviation(IrradiationUnit unit, IFormatProvider? prov
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Irradiation from JoulesPerSquareCentimeter.
+        ///     Get <see cref="Irradiation{T}" /> from JoulesPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareCentimeter(QuantityValue joulespersquarecentimeter)
+        public static Irradiation<T> FromJoulesPerSquareCentimeter(T joulespersquarecentimeter)
         {
-            double value = (double) joulespersquarecentimeter;
-            return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter);
+            return new Irradiation<T>(joulespersquarecentimeter, IrradiationUnit.JoulePerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiation from JoulesPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> from JoulesPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareMeter(QuantityValue joulespersquaremeter)
+        public static Irradiation<T> FromJoulesPerSquareMeter(T joulespersquaremeter)
         {
-            double value = (double) joulespersquaremeter;
-            return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter);
+            return new Irradiation<T>(joulespersquaremeter, IrradiationUnit.JoulePerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiation from JoulesPerSquareMillimeter.
+        ///     Get <see cref="Irradiation{T}" /> from JoulesPerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareMillimeter(QuantityValue joulespersquaremillimeter)
+        public static Irradiation<T> FromJoulesPerSquareMillimeter(T joulespersquaremillimeter)
         {
-            double value = (double) joulespersquaremillimeter;
-            return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter);
+            return new Irradiation<T>(joulespersquaremillimeter, IrradiationUnit.JoulePerSquareMillimeter);
         }
         /// <summary>
-        ///     Get Irradiation from KilojoulesPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> from KilojoulesPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromKilojoulesPerSquareMeter(QuantityValue kilojoulespersquaremeter)
+        public static Irradiation<T> FromKilojoulesPerSquareMeter(T kilojoulespersquaremeter)
         {
-            double value = (double) kilojoulespersquaremeter;
-            return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter);
+            return new Irradiation<T>(kilojoulespersquaremeter, IrradiationUnit.KilojoulePerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiation from KilowattHoursPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> from KilowattHoursPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromKilowattHoursPerSquareMeter(QuantityValue kilowatthourspersquaremeter)
+        public static Irradiation<T> FromKilowattHoursPerSquareMeter(T kilowatthourspersquaremeter)
         {
-            double value = (double) kilowatthourspersquaremeter;
-            return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter);
+            return new Irradiation<T>(kilowatthourspersquaremeter, IrradiationUnit.KilowattHourPerSquareMeter);
         }
         /// <summary>
-        ///     Get Irradiation from MillijoulesPerSquareCentimeter.
+        ///     Get <see cref="Irradiation{T}" /> from MillijoulesPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromMillijoulesPerSquareCentimeter(QuantityValue millijoulespersquarecentimeter)
+        public static Irradiation<T> FromMillijoulesPerSquareCentimeter(T millijoulespersquarecentimeter)
         {
-            double value = (double) millijoulespersquarecentimeter;
-            return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter);
+            return new Irradiation<T>(millijoulespersquarecentimeter, IrradiationUnit.MillijoulePerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Irradiation from WattHoursPerSquareMeter.
+        ///     Get <see cref="Irradiation{T}" /> from WattHoursPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromWattHoursPerSquareMeter(QuantityValue watthourspersquaremeter)
+        public static Irradiation<T> FromWattHoursPerSquareMeter(T watthourspersquaremeter)
         {
-            double value = (double) watthourspersquaremeter;
-            return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter);
+            return new Irradiation<T>(watthourspersquaremeter, IrradiationUnit.WattHourPerSquareMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="IrradiationUnit" /> to <see cref="Irradiation" />.
+        ///     Dynamically convert from value and unit enum <see cref="IrradiationUnit" /> to <see cref="Irradiation{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Irradiation unit value.</returns>
-        public static Irradiation From(QuantityValue value, IrradiationUnit fromUnit)
+        /// <returns><see cref="Irradiation{T}" /> unit value.</returns>
+        public static Irradiation<T> From(T value, IrradiationUnit fromUnit)
         {
-            return new Irradiation((double)value, fromUnit);
+            return new Irradiation<T>(value, fromUnit);
         }
 
         #endregion
@@ -340,7 +331,7 @@ public static Irradiation From(QuantityValue value, IrradiationUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Irradiation Parse(string str)
+        public static Irradiation<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -368,9 +359,9 @@ public static Irradiation Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Irradiation Parse(string str, IFormatProvider? provider)
+        public static Irradiation<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Irradiation, IrradiationUnit>(
+            return QuantityParser.Default.Parse<T, Irradiation<T>, IrradiationUnit>(
                 str,
                 provider,
                 From);
@@ -384,7 +375,7 @@ public static Irradiation Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Irradiation result)
+        public static bool TryParse(string? str, out Irradiation<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -399,9 +390,9 @@ public static bool TryParse(string? str, out Irradiation result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Irradiation result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Irradiation<T> result)
         {
-            return QuantityParser.Default.TryParse<Irradiation, IrradiationUnit>(
+            return QuantityParser.Default.TryParse<T, Irradiation<T>, IrradiationUnit>(
                 str,
                 provider,
                 From,
@@ -463,45 +454,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Irrad
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Irradiation operator -(Irradiation right)
+        public static Irradiation<T> operator -(Irradiation<T> right)
         {
-            return new Irradiation(-right.Value, right.Unit);
+            return new Irradiation<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiation"/> from adding two <see cref="Irradiation"/>.</summary>
-        public static Irradiation operator +(Irradiation left, Irradiation right)
+        /// <summary>Get <see cref="Irradiation{T}"/> from adding two <see cref="Irradiation{T}"/>.</summary>
+        public static Irradiation<T> operator +(Irradiation<T> left, Irradiation<T> right)
         {
-            return new Irradiation(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Irradiation<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiation"/> from subtracting two <see cref="Irradiation"/>.</summary>
-        public static Irradiation operator -(Irradiation left, Irradiation right)
+        /// <summary>Get <see cref="Irradiation{T}"/> from subtracting two <see cref="Irradiation{T}"/>.</summary>
+        public static Irradiation<T> operator -(Irradiation<T> left, Irradiation<T> right)
         {
-            return new Irradiation(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Irradiation<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiation"/> from multiplying value and <see cref="Irradiation"/>.</summary>
-        public static Irradiation operator *(double left, Irradiation right)
+        /// <summary>Get <see cref="Irradiation{T}"/> from multiplying value and <see cref="Irradiation{T}"/>.</summary>
+        public static Irradiation<T> operator *(T left, Irradiation<T> right)
         {
-            return new Irradiation(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Irradiation<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiation"/> from multiplying value and <see cref="Irradiation"/>.</summary>
-        public static Irradiation operator *(Irradiation left, double right)
+        /// <summary>Get <see cref="Irradiation{T}"/> from multiplying value and <see cref="Irradiation{T}"/>.</summary>
+        public static Irradiation<T> operator *(Irradiation<T> left, T right)
         {
-            return new Irradiation(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Irradiation<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Irradiation"/> from dividing <see cref="Irradiation"/> by value.</summary>
-        public static Irradiation operator /(Irradiation left, double right)
+        /// <summary>Get <see cref="Irradiation{T}"/> from dividing <see cref="Irradiation{T}"/> by value.</summary>
+        public static Irradiation<T> operator /(Irradiation<T> left, T right)
         {
-            return new Irradiation(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Irradiation<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Irradiation"/> by <see cref="Irradiation"/>.</summary>
-        public static double operator /(Irradiation left, Irradiation right)
+        /// <summary>Get ratio value from dividing <see cref="Irradiation{T}"/> by <see cref="Irradiation{T}"/>.</summary>
+        public static T operator /(Irradiation<T> left, Irradiation<T> right)
         {
-            return left.JoulesPerSquareMeter / right.JoulesPerSquareMeter;
+            return CompiledLambdas.Divide(left.JoulesPerSquareMeter, right.JoulesPerSquareMeter);
         }
 
         #endregion
@@ -509,39 +505,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Irrad
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Irradiation left, Irradiation right)
+        public static bool operator <=(Irradiation<T> left, Irradiation<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Irradiation left, Irradiation right)
+        public static bool operator >=(Irradiation<T> left, Irradiation<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Irradiation left, Irradiation right)
+        public static bool operator <(Irradiation<T> left, Irradiation<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Irradiation left, Irradiation right)
+        public static bool operator >(Irradiation<T> left, Irradiation<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Irradiation, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Irradiation left, Irradiation right)
+        /// <remarks>Consider using <see cref="Equals(Irradiation{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Irradiation<T> left, Irradiation<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Irradiation, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Irradiation left, Irradiation right)
+        /// <remarks>Consider using <see cref="Equals(Irradiation{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Irradiation<T> left, Irradiation<T> right)
         {
             return !(left == right);
         }
@@ -550,37 +546,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Irrad
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Irradiation objIrradiation)) throw new ArgumentException("Expected type Irradiation.", nameof(obj));
+            if(!(obj is Irradiation<T> objIrradiation)) throw new ArgumentException("Expected type Irradiation.", nameof(obj));
 
             return CompareTo(objIrradiation);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Irradiation other)
+        public int CompareTo(Irradiation<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Irradiation, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Irradiation{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Irradiation objIrradiation))
+            if(obj is null || !(obj is Irradiation<T> objIrradiation))
                 return false;
 
             return Equals(objIrradiation);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Irradiation, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Irradiation other)
+        /// <remarks>Consider using <see cref="Equals(Irradiation{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Irradiation<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Irradiation within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Irradiation{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -618,21 +614,19 @@ public bool Equals(Irradiation other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Irradiation other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Irradiation<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Irradiation.</returns>
+        /// <returns>A hash code for the current <see cref="Irradiation{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -646,17 +640,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(IrradiationUnit unit)
+        public T As(IrradiationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -676,17 +670,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is IrradiationUnit unitAsIrradiationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradiationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsIrradiationUnit);
+            var asValue = As(unitAsIrradiationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<IrradiationUnit>.As(IrradiationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Irradiation to another Irradiation with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Irradiation{T}" /> to another <see cref="Irradiation{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Irradiation with the specified unit.</returns>
-        public Irradiation ToUnit(IrradiationUnit unit)
+        /// <returns>A <see cref="Irradiation{T}" /> with the specified unit.</returns>
+        public Irradiation<T> ToUnit(IrradiationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Irradiation(convertedValue, unit);
+            return new Irradiation<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -699,7 +698,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Irradiation ToUnit(UnitSystem unitSystem)
+        public Irradiation<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -719,25 +718,31 @@ public Irradiation ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<IrradiationUnit> IQuantity<IrradiationUnit>.ToUnit(IrradiationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<IrradiationUnit, T> IQuantityT<IrradiationUnit, T>.ToUnit(IrradiationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<IrradiationUnit> IQuantity<IrradiationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<IrradiationUnit, T> IQuantityT<IrradiationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case IrradiationUnit.JoulePerSquareCentimeter: return _value*1e4;
-                case IrradiationUnit.JoulePerSquareMeter: return _value;
-                case IrradiationUnit.JoulePerSquareMillimeter: return _value*1e6;
-                case IrradiationUnit.KilojoulePerSquareMeter: return (_value) * 1e3d;
-                case IrradiationUnit.KilowattHourPerSquareMeter: return (_value*3600d) * 1e3d;
-                case IrradiationUnit.MillijoulePerSquareCentimeter: return (_value*1e4) * 1e-3d;
-                case IrradiationUnit.WattHourPerSquareMeter: return _value*3600d;
+                case IrradiationUnit.JoulePerSquareCentimeter: return Value*1e4;
+                case IrradiationUnit.JoulePerSquareMeter: return Value;
+                case IrradiationUnit.JoulePerSquareMillimeter: return Value*1e6;
+                case IrradiationUnit.KilojoulePerSquareMeter: return (Value) * 1e3d;
+                case IrradiationUnit.KilowattHourPerSquareMeter: return (Value*3600d) * 1e3d;
+                case IrradiationUnit.MillijoulePerSquareCentimeter: return (Value*1e4) * 1e-3d;
+                case IrradiationUnit.WattHourPerSquareMeter: return Value*3600d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -748,16 +753,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Irradiation ToBaseUnit()
+        internal Irradiation<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Irradiation(baseUnitValue, BaseUnit);
+            return new Irradiation<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(IrradiationUnit unit)
+        private T GetValueAs(IrradiationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -866,57 +871,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Irradiation)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Irradiation<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Irradiation)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Irradiation<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Irradiation)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Irradiation<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -926,33 +931,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Irradiation))
+            if(conversionType == typeof(Irradiation<T>))
                 return this;
             else if(conversionType == typeof(IrradiationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Irradiation.QuantityType;
+                return Irradiation<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Irradiation.Info;
+                return Irradiation<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Irradiation.BaseDimensions;
+                return Irradiation<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Irradiation)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Irradiation<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
index 98764911b2..1dc9580e8f 100644
--- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     http://en.wikipedia.org/wiki/Viscosity
     /// </remarks>
-    public partial struct KinematicViscosity : IQuantity<KinematicViscosityUnit>, IEquatable<KinematicViscosity>, IComparable, IComparable<KinematicViscosity>, IConvertible, IFormattable
+    public partial struct KinematicViscosity<T> : IQuantityT<KinematicViscosityUnit, T>, IEquatable<KinematicViscosity<T>>, IComparable, IComparable<KinematicViscosity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -73,12 +69,12 @@ static KinematicViscosity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public KinematicViscosity(double value, KinematicViscosityUnit unit)
+        public KinematicViscosity(T value, KinematicViscosityUnit unit)
         {
             if(unit == KinematicViscosityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -90,14 +86,14 @@ public KinematicViscosity(double value, KinematicViscosityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public KinematicViscosity(double value, UnitSystem unitSystem)
+        public KinematicViscosity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -112,19 +108,19 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of KinematicViscosity, which is SquareMeterPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="KinematicViscosity{T}" />, which is SquareMeterPerSecond. All conversions go via this value.
         /// </summary>
         public static KinematicViscosityUnit BaseUnit { get; } = KinematicViscosityUnit.SquareMeterPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of KinematicViscosity
+        /// Represents the largest possible value of <see cref="KinematicViscosity{T}" />
         /// </summary>
-        public static KinematicViscosity MaxValue { get; } = new KinematicViscosity(double.MaxValue, BaseUnit);
+        public static KinematicViscosity<T> MaxValue { get; } = new KinematicViscosity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of KinematicViscosity
+        /// Represents the smallest possible value of <see cref="KinematicViscosity{T}" />
         /// </summary>
-        public static KinematicViscosity MinValue { get; } = new KinematicViscosity(double.MinValue, BaseUnit);
+        public static KinematicViscosity<T> MinValue { get; } = new KinematicViscosity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -133,14 +129,14 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.KinematicViscosity;
 
         /// <summary>
-        ///     All units of measurement for the KinematicViscosity quantity.
+        ///     All units of measurement for the <see cref="KinematicViscosity{T}" /> quantity.
         /// </summary>
         public static KinematicViscosityUnit[] Units { get; } = Enum.GetValues(typeof(KinematicViscosityUnit)).Cast<KinematicViscosityUnit>().Except(new KinematicViscosityUnit[]{ KinematicViscosityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit SquareMeterPerSecond.
         /// </summary>
-        public static KinematicViscosity Zero { get; } = new KinematicViscosity(0, BaseUnit);
+        public static KinematicViscosity<T> Zero { get; } = new KinematicViscosity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -149,7 +145,9 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -165,56 +163,56 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => KinematicViscosity.QuantityType;
+        public QuantityType Type => KinematicViscosity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => KinematicViscosity.BaseDimensions;
+        public BaseDimensions Dimensions => KinematicViscosity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get KinematicViscosity in Centistokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> in Centistokes.
         /// </summary>
-        public double Centistokes => As(KinematicViscosityUnit.Centistokes);
+        public T Centistokes => As(KinematicViscosityUnit.Centistokes);
 
         /// <summary>
-        ///     Get KinematicViscosity in Decistokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> in Decistokes.
         /// </summary>
-        public double Decistokes => As(KinematicViscosityUnit.Decistokes);
+        public T Decistokes => As(KinematicViscosityUnit.Decistokes);
 
         /// <summary>
-        ///     Get KinematicViscosity in Kilostokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> in Kilostokes.
         /// </summary>
-        public double Kilostokes => As(KinematicViscosityUnit.Kilostokes);
+        public T Kilostokes => As(KinematicViscosityUnit.Kilostokes);
 
         /// <summary>
-        ///     Get KinematicViscosity in Microstokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> in Microstokes.
         /// </summary>
-        public double Microstokes => As(KinematicViscosityUnit.Microstokes);
+        public T Microstokes => As(KinematicViscosityUnit.Microstokes);
 
         /// <summary>
-        ///     Get KinematicViscosity in Millistokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> in Millistokes.
         /// </summary>
-        public double Millistokes => As(KinematicViscosityUnit.Millistokes);
+        public T Millistokes => As(KinematicViscosityUnit.Millistokes);
 
         /// <summary>
-        ///     Get KinematicViscosity in Nanostokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> in Nanostokes.
         /// </summary>
-        public double Nanostokes => As(KinematicViscosityUnit.Nanostokes);
+        public T Nanostokes => As(KinematicViscosityUnit.Nanostokes);
 
         /// <summary>
-        ///     Get KinematicViscosity in SquareMetersPerSecond.
+        ///     Get <see cref="KinematicViscosity{T}" /> in SquareMetersPerSecond.
         /// </summary>
-        public double SquareMetersPerSecond => As(KinematicViscosityUnit.SquareMeterPerSecond);
+        public T SquareMetersPerSecond => As(KinematicViscosityUnit.SquareMeterPerSecond);
 
         /// <summary>
-        ///     Get KinematicViscosity in Stokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> in Stokes.
         /// </summary>
-        public double Stokes => As(KinematicViscosityUnit.Stokes);
+        public T Stokes => As(KinematicViscosityUnit.Stokes);
 
         #endregion
 
@@ -246,87 +244,79 @@ public static string GetAbbreviation(KinematicViscosityUnit unit, IFormatProvide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get KinematicViscosity from Centistokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> from Centistokes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromCentistokes(QuantityValue centistokes)
+        public static KinematicViscosity<T> FromCentistokes(T centistokes)
         {
-            double value = (double) centistokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes);
+            return new KinematicViscosity<T>(centistokes, KinematicViscosityUnit.Centistokes);
         }
         /// <summary>
-        ///     Get KinematicViscosity from Decistokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> from Decistokes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromDecistokes(QuantityValue decistokes)
+        public static KinematicViscosity<T> FromDecistokes(T decistokes)
         {
-            double value = (double) decistokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes);
+            return new KinematicViscosity<T>(decistokes, KinematicViscosityUnit.Decistokes);
         }
         /// <summary>
-        ///     Get KinematicViscosity from Kilostokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> from Kilostokes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromKilostokes(QuantityValue kilostokes)
+        public static KinematicViscosity<T> FromKilostokes(T kilostokes)
         {
-            double value = (double) kilostokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes);
+            return new KinematicViscosity<T>(kilostokes, KinematicViscosityUnit.Kilostokes);
         }
         /// <summary>
-        ///     Get KinematicViscosity from Microstokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> from Microstokes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromMicrostokes(QuantityValue microstokes)
+        public static KinematicViscosity<T> FromMicrostokes(T microstokes)
         {
-            double value = (double) microstokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes);
+            return new KinematicViscosity<T>(microstokes, KinematicViscosityUnit.Microstokes);
         }
         /// <summary>
-        ///     Get KinematicViscosity from Millistokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> from Millistokes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromMillistokes(QuantityValue millistokes)
+        public static KinematicViscosity<T> FromMillistokes(T millistokes)
         {
-            double value = (double) millistokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes);
+            return new KinematicViscosity<T>(millistokes, KinematicViscosityUnit.Millistokes);
         }
         /// <summary>
-        ///     Get KinematicViscosity from Nanostokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> from Nanostokes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromNanostokes(QuantityValue nanostokes)
+        public static KinematicViscosity<T> FromNanostokes(T nanostokes)
         {
-            double value = (double) nanostokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes);
+            return new KinematicViscosity<T>(nanostokes, KinematicViscosityUnit.Nanostokes);
         }
         /// <summary>
-        ///     Get KinematicViscosity from SquareMetersPerSecond.
+        ///     Get <see cref="KinematicViscosity{T}" /> from SquareMetersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromSquareMetersPerSecond(QuantityValue squaremeterspersecond)
+        public static KinematicViscosity<T> FromSquareMetersPerSecond(T squaremeterspersecond)
         {
-            double value = (double) squaremeterspersecond;
-            return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond);
+            return new KinematicViscosity<T>(squaremeterspersecond, KinematicViscosityUnit.SquareMeterPerSecond);
         }
         /// <summary>
-        ///     Get KinematicViscosity from Stokes.
+        ///     Get <see cref="KinematicViscosity{T}" /> from Stokes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromStokes(QuantityValue stokes)
+        public static KinematicViscosity<T> FromStokes(T stokes)
         {
-            double value = (double) stokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Stokes);
+            return new KinematicViscosity<T>(stokes, KinematicViscosityUnit.Stokes);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="KinematicViscosityUnit" /> to <see cref="KinematicViscosity" />.
+        ///     Dynamically convert from value and unit enum <see cref="KinematicViscosityUnit" /> to <see cref="KinematicViscosity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>KinematicViscosity unit value.</returns>
-        public static KinematicViscosity From(QuantityValue value, KinematicViscosityUnit fromUnit)
+        /// <returns><see cref="KinematicViscosity{T}" /> unit value.</returns>
+        public static KinematicViscosity<T> From(T value, KinematicViscosityUnit fromUnit)
         {
-            return new KinematicViscosity((double)value, fromUnit);
+            return new KinematicViscosity<T>(value, fromUnit);
         }
 
         #endregion
@@ -355,7 +345,7 @@ public static KinematicViscosity From(QuantityValue value, KinematicViscosityUni
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static KinematicViscosity Parse(string str)
+        public static KinematicViscosity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -383,9 +373,9 @@ public static KinematicViscosity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static KinematicViscosity Parse(string str, IFormatProvider? provider)
+        public static KinematicViscosity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<KinematicViscosity, KinematicViscosityUnit>(
+            return QuantityParser.Default.Parse<T, KinematicViscosity<T>, KinematicViscosityUnit>(
                 str,
                 provider,
                 From);
@@ -399,7 +389,7 @@ public static KinematicViscosity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out KinematicViscosity result)
+        public static bool TryParse(string? str, out KinematicViscosity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -414,9 +404,9 @@ public static bool TryParse(string? str, out KinematicViscosity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out KinematicViscosity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out KinematicViscosity<T> result)
         {
-            return QuantityParser.Default.TryParse<KinematicViscosity, KinematicViscosityUnit>(
+            return QuantityParser.Default.TryParse<T, KinematicViscosity<T>, KinematicViscosityUnit>(
                 str,
                 provider,
                 From,
@@ -478,45 +468,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Kinem
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static KinematicViscosity operator -(KinematicViscosity right)
+        public static KinematicViscosity<T> operator -(KinematicViscosity<T> right)
         {
-            return new KinematicViscosity(-right.Value, right.Unit);
+            return new KinematicViscosity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="KinematicViscosity"/> from adding two <see cref="KinematicViscosity"/>.</summary>
-        public static KinematicViscosity operator +(KinematicViscosity left, KinematicViscosity right)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from adding two <see cref="KinematicViscosity{T}"/>.</summary>
+        public static KinematicViscosity<T> operator +(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
-            return new KinematicViscosity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new KinematicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="KinematicViscosity"/> from subtracting two <see cref="KinematicViscosity"/>.</summary>
-        public static KinematicViscosity operator -(KinematicViscosity left, KinematicViscosity right)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from subtracting two <see cref="KinematicViscosity{T}"/>.</summary>
+        public static KinematicViscosity<T> operator -(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
-            return new KinematicViscosity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new KinematicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="KinematicViscosity"/> from multiplying value and <see cref="KinematicViscosity"/>.</summary>
-        public static KinematicViscosity operator *(double left, KinematicViscosity right)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from multiplying value and <see cref="KinematicViscosity{T}"/>.</summary>
+        public static KinematicViscosity<T> operator *(T left, KinematicViscosity<T> right)
         {
-            return new KinematicViscosity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new KinematicViscosity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="KinematicViscosity"/> from multiplying value and <see cref="KinematicViscosity"/>.</summary>
-        public static KinematicViscosity operator *(KinematicViscosity left, double right)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from multiplying value and <see cref="KinematicViscosity{T}"/>.</summary>
+        public static KinematicViscosity<T> operator *(KinematicViscosity<T> left, T right)
         {
-            return new KinematicViscosity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new KinematicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="KinematicViscosity"/> from dividing <see cref="KinematicViscosity"/> by value.</summary>
-        public static KinematicViscosity operator /(KinematicViscosity left, double right)
+        /// <summary>Get <see cref="KinematicViscosity{T}"/> from dividing <see cref="KinematicViscosity{T}"/> by value.</summary>
+        public static KinematicViscosity<T> operator /(KinematicViscosity<T> left, T right)
         {
-            return new KinematicViscosity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new KinematicViscosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="KinematicViscosity"/> by <see cref="KinematicViscosity"/>.</summary>
-        public static double operator /(KinematicViscosity left, KinematicViscosity right)
+        /// <summary>Get ratio value from dividing <see cref="KinematicViscosity{T}"/> by <see cref="KinematicViscosity{T}"/>.</summary>
+        public static T operator /(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
-            return left.SquareMetersPerSecond / right.SquareMetersPerSecond;
+            return CompiledLambdas.Divide(left.SquareMetersPerSecond, right.SquareMetersPerSecond);
         }
 
         #endregion
@@ -524,39 +519,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Kinem
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(KinematicViscosity left, KinematicViscosity right)
+        public static bool operator <=(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(KinematicViscosity left, KinematicViscosity right)
+        public static bool operator >=(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(KinematicViscosity left, KinematicViscosity right)
+        public static bool operator <(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(KinematicViscosity left, KinematicViscosity right)
+        public static bool operator >(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(KinematicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(KinematicViscosity left, KinematicViscosity right)
+        /// <remarks>Consider using <see cref="Equals(KinematicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(KinematicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(KinematicViscosity left, KinematicViscosity right)
+        /// <remarks>Consider using <see cref="Equals(KinematicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(KinematicViscosity<T> left, KinematicViscosity<T> right)
         {
             return !(left == right);
         }
@@ -565,37 +560,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Kinem
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is KinematicViscosity objKinematicViscosity)) throw new ArgumentException("Expected type KinematicViscosity.", nameof(obj));
+            if(!(obj is KinematicViscosity<T> objKinematicViscosity)) throw new ArgumentException("Expected type KinematicViscosity.", nameof(obj));
 
             return CompareTo(objKinematicViscosity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(KinematicViscosity other)
+        public int CompareTo(KinematicViscosity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(KinematicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(KinematicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is KinematicViscosity objKinematicViscosity))
+            if(obj is null || !(obj is KinematicViscosity<T> objKinematicViscosity))
                 return false;
 
             return Equals(objKinematicViscosity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(KinematicViscosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(KinematicViscosity other)
+        /// <remarks>Consider using <see cref="Equals(KinematicViscosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(KinematicViscosity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another KinematicViscosity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="KinematicViscosity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -633,21 +628,19 @@ public bool Equals(KinematicViscosity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(KinematicViscosity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(KinematicViscosity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current KinematicViscosity.</returns>
+        /// <returns>A hash code for the current <see cref="KinematicViscosity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -661,17 +654,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(KinematicViscosityUnit unit)
+        public T As(KinematicViscosityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -691,17 +684,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is KinematicViscosityUnit unitAsKinematicViscosityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(KinematicViscosityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsKinematicViscosityUnit);
+            var asValue = As(unitAsKinematicViscosityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<KinematicViscosityUnit>.As(KinematicViscosityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this KinematicViscosity to another KinematicViscosity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="KinematicViscosity{T}" /> to another <see cref="KinematicViscosity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A KinematicViscosity with the specified unit.</returns>
-        public KinematicViscosity ToUnit(KinematicViscosityUnit unit)
+        /// <returns>A <see cref="KinematicViscosity{T}" /> with the specified unit.</returns>
+        public KinematicViscosity<T> ToUnit(KinematicViscosityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new KinematicViscosity(convertedValue, unit);
+            return new KinematicViscosity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -714,7 +712,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public KinematicViscosity ToUnit(UnitSystem unitSystem)
+        public KinematicViscosity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -734,26 +732,32 @@ public KinematicViscosity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<KinematicViscosityUnit> IQuantity<KinematicViscosityUnit>.ToUnit(KinematicViscosityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<KinematicViscosityUnit, T> IQuantityT<KinematicViscosityUnit, T>.ToUnit(KinematicViscosityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<KinematicViscosityUnit> IQuantity<KinematicViscosityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<KinematicViscosityUnit, T> IQuantityT<KinematicViscosityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case KinematicViscosityUnit.Centistokes: return (_value/1e4) * 1e-2d;
-                case KinematicViscosityUnit.Decistokes: return (_value/1e4) * 1e-1d;
-                case KinematicViscosityUnit.Kilostokes: return (_value/1e4) * 1e3d;
-                case KinematicViscosityUnit.Microstokes: return (_value/1e4) * 1e-6d;
-                case KinematicViscosityUnit.Millistokes: return (_value/1e4) * 1e-3d;
-                case KinematicViscosityUnit.Nanostokes: return (_value/1e4) * 1e-9d;
-                case KinematicViscosityUnit.SquareMeterPerSecond: return _value;
-                case KinematicViscosityUnit.Stokes: return _value/1e4;
+                case KinematicViscosityUnit.Centistokes: return (Value/1e4) * 1e-2d;
+                case KinematicViscosityUnit.Decistokes: return (Value/1e4) * 1e-1d;
+                case KinematicViscosityUnit.Kilostokes: return (Value/1e4) * 1e3d;
+                case KinematicViscosityUnit.Microstokes: return (Value/1e4) * 1e-6d;
+                case KinematicViscosityUnit.Millistokes: return (Value/1e4) * 1e-3d;
+                case KinematicViscosityUnit.Nanostokes: return (Value/1e4) * 1e-9d;
+                case KinematicViscosityUnit.SquareMeterPerSecond: return Value;
+                case KinematicViscosityUnit.Stokes: return Value/1e4;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -764,16 +768,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal KinematicViscosity ToBaseUnit()
+        internal KinematicViscosity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new KinematicViscosity(baseUnitValue, BaseUnit);
+            return new KinematicViscosity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(KinematicViscosityUnit unit)
+        private T GetValueAs(KinematicViscosityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -883,57 +887,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(KinematicViscosity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(KinematicViscosity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(KinematicViscosity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(KinematicViscosity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(KinematicViscosity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(KinematicViscosity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -943,33 +947,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(KinematicViscosity))
+            if(conversionType == typeof(KinematicViscosity<T>))
                 return this;
             else if(conversionType == typeof(KinematicViscosityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return KinematicViscosity.QuantityType;
+                return KinematicViscosity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return KinematicViscosity.Info;
+                return KinematicViscosity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return KinematicViscosity.BaseDimensions;
+                return KinematicViscosity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(KinematicViscosity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(KinematicViscosity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs
index 632fa67ce5..d515870961 100644
--- a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Lapse rate is the rate at which Earth's atmospheric temperature decreases with an increase in altitude, or increases with the decrease in altitude.
     /// </summary>
-    public partial struct LapseRate : IQuantity<LapseRateUnit>, IEquatable<LapseRate>, IComparable, IComparable<LapseRate>, IConvertible, IFormattable
+    public partial struct LapseRate<T> : IQuantityT<LapseRateUnit, T>, IEquatable<LapseRate<T>>, IComparable, IComparable<LapseRate<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -63,12 +59,12 @@ static LapseRate()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public LapseRate(double value, LapseRateUnit unit)
+        public LapseRate(T value, LapseRateUnit unit)
         {
             if(unit == LapseRateUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -80,14 +76,14 @@ public LapseRate(double value, LapseRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LapseRate(double value, UnitSystem unitSystem)
+        public LapseRate(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -102,19 +98,19 @@ public LapseRate(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of LapseRate, which is DegreeCelsiusPerKilometer. All conversions go via this value.
+        ///     The base unit of <see cref="LapseRate{T}" />, which is DegreeCelsiusPerKilometer. All conversions go via this value.
         /// </summary>
         public static LapseRateUnit BaseUnit { get; } = LapseRateUnit.DegreeCelsiusPerKilometer;
 
         /// <summary>
-        /// Represents the largest possible value of LapseRate
+        /// Represents the largest possible value of <see cref="LapseRate{T}" />
         /// </summary>
-        public static LapseRate MaxValue { get; } = new LapseRate(double.MaxValue, BaseUnit);
+        public static LapseRate<T> MaxValue { get; } = new LapseRate<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of LapseRate
+        /// Represents the smallest possible value of <see cref="LapseRate{T}" />
         /// </summary>
-        public static LapseRate MinValue { get; } = new LapseRate(double.MinValue, BaseUnit);
+        public static LapseRate<T> MinValue { get; } = new LapseRate<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -123,14 +119,14 @@ public LapseRate(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.LapseRate;
 
         /// <summary>
-        ///     All units of measurement for the LapseRate quantity.
+        ///     All units of measurement for the <see cref="LapseRate{T}" /> quantity.
         /// </summary>
         public static LapseRateUnit[] Units { get; } = Enum.GetValues(typeof(LapseRateUnit)).Cast<LapseRateUnit>().Except(new LapseRateUnit[]{ LapseRateUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DegreeCelsiusPerKilometer.
         /// </summary>
-        public static LapseRate Zero { get; } = new LapseRate(0, BaseUnit);
+        public static LapseRate<T> Zero { get; } = new LapseRate<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -139,7 +135,9 @@ public LapseRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -155,21 +153,21 @@ public LapseRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => LapseRate.QuantityType;
+        public QuantityType Type => LapseRate<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => LapseRate.BaseDimensions;
+        public BaseDimensions Dimensions => LapseRate<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get LapseRate in DegreesCelciusPerKilometer.
+        ///     Get <see cref="LapseRate{T}" /> in DegreesCelciusPerKilometer.
         /// </summary>
-        public double DegreesCelciusPerKilometer => As(LapseRateUnit.DegreeCelsiusPerKilometer);
+        public T DegreesCelciusPerKilometer => As(LapseRateUnit.DegreeCelsiusPerKilometer);
 
         #endregion
 
@@ -201,24 +199,23 @@ public static string GetAbbreviation(LapseRateUnit unit, IFormatProvider? provid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get LapseRate from DegreesCelciusPerKilometer.
+        ///     Get <see cref="LapseRate{T}" /> from DegreesCelciusPerKilometer.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LapseRate FromDegreesCelciusPerKilometer(QuantityValue degreescelciusperkilometer)
+        public static LapseRate<T> FromDegreesCelciusPerKilometer(T degreescelciusperkilometer)
         {
-            double value = (double) degreescelciusperkilometer;
-            return new LapseRate(value, LapseRateUnit.DegreeCelsiusPerKilometer);
+            return new LapseRate<T>(degreescelciusperkilometer, LapseRateUnit.DegreeCelsiusPerKilometer);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LapseRateUnit" /> to <see cref="LapseRate" />.
+        ///     Dynamically convert from value and unit enum <see cref="LapseRateUnit" /> to <see cref="LapseRate{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LapseRate unit value.</returns>
-        public static LapseRate From(QuantityValue value, LapseRateUnit fromUnit)
+        /// <returns><see cref="LapseRate{T}" /> unit value.</returns>
+        public static LapseRate<T> From(T value, LapseRateUnit fromUnit)
         {
-            return new LapseRate((double)value, fromUnit);
+            return new LapseRate<T>(value, fromUnit);
         }
 
         #endregion
@@ -247,7 +244,7 @@ public static LapseRate From(QuantityValue value, LapseRateUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static LapseRate Parse(string str)
+        public static LapseRate<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -275,9 +272,9 @@ public static LapseRate Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static LapseRate Parse(string str, IFormatProvider? provider)
+        public static LapseRate<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<LapseRate, LapseRateUnit>(
+            return QuantityParser.Default.Parse<T, LapseRate<T>, LapseRateUnit>(
                 str,
                 provider,
                 From);
@@ -291,7 +288,7 @@ public static LapseRate Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out LapseRate result)
+        public static bool TryParse(string? str, out LapseRate<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -306,9 +303,9 @@ public static bool TryParse(string? str, out LapseRate result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out LapseRate result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out LapseRate<T> result)
         {
-            return QuantityParser.Default.TryParse<LapseRate, LapseRateUnit>(
+            return QuantityParser.Default.TryParse<T, LapseRate<T>, LapseRateUnit>(
                 str,
                 provider,
                 From,
@@ -370,45 +367,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lapse
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static LapseRate operator -(LapseRate right)
+        public static LapseRate<T> operator -(LapseRate<T> right)
         {
-            return new LapseRate(-right.Value, right.Unit);
+            return new LapseRate<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="LapseRate"/> from adding two <see cref="LapseRate"/>.</summary>
-        public static LapseRate operator +(LapseRate left, LapseRate right)
+        /// <summary>Get <see cref="LapseRate{T}"/> from adding two <see cref="LapseRate{T}"/>.</summary>
+        public static LapseRate<T> operator +(LapseRate<T> left, LapseRate<T> right)
         {
-            return new LapseRate(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new LapseRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LapseRate"/> from subtracting two <see cref="LapseRate"/>.</summary>
-        public static LapseRate operator -(LapseRate left, LapseRate right)
+        /// <summary>Get <see cref="LapseRate{T}"/> from subtracting two <see cref="LapseRate{T}"/>.</summary>
+        public static LapseRate<T> operator -(LapseRate<T> left, LapseRate<T> right)
         {
-            return new LapseRate(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new LapseRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LapseRate"/> from multiplying value and <see cref="LapseRate"/>.</summary>
-        public static LapseRate operator *(double left, LapseRate right)
+        /// <summary>Get <see cref="LapseRate{T}"/> from multiplying value and <see cref="LapseRate{T}"/>.</summary>
+        public static LapseRate<T> operator *(T left, LapseRate<T> right)
         {
-            return new LapseRate(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new LapseRate<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="LapseRate"/> from multiplying value and <see cref="LapseRate"/>.</summary>
-        public static LapseRate operator *(LapseRate left, double right)
+        /// <summary>Get <see cref="LapseRate{T}"/> from multiplying value and <see cref="LapseRate{T}"/>.</summary>
+        public static LapseRate<T> operator *(LapseRate<T> left, T right)
         {
-            return new LapseRate(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new LapseRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LapseRate"/> from dividing <see cref="LapseRate"/> by value.</summary>
-        public static LapseRate operator /(LapseRate left, double right)
+        /// <summary>Get <see cref="LapseRate{T}"/> from dividing <see cref="LapseRate{T}"/> by value.</summary>
+        public static LapseRate<T> operator /(LapseRate<T> left, T right)
         {
-            return new LapseRate(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new LapseRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="LapseRate"/> by <see cref="LapseRate"/>.</summary>
-        public static double operator /(LapseRate left, LapseRate right)
+        /// <summary>Get ratio value from dividing <see cref="LapseRate{T}"/> by <see cref="LapseRate{T}"/>.</summary>
+        public static T operator /(LapseRate<T> left, LapseRate<T> right)
         {
-            return left.DegreesCelciusPerKilometer / right.DegreesCelciusPerKilometer;
+            return CompiledLambdas.Divide(left.DegreesCelciusPerKilometer, right.DegreesCelciusPerKilometer);
         }
 
         #endregion
@@ -416,39 +418,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lapse
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(LapseRate left, LapseRate right)
+        public static bool operator <=(LapseRate<T> left, LapseRate<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(LapseRate left, LapseRate right)
+        public static bool operator >=(LapseRate<T> left, LapseRate<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(LapseRate left, LapseRate right)
+        public static bool operator <(LapseRate<T> left, LapseRate<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(LapseRate left, LapseRate right)
+        public static bool operator >(LapseRate<T> left, LapseRate<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LapseRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(LapseRate left, LapseRate right)
+        /// <remarks>Consider using <see cref="Equals(LapseRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(LapseRate<T> left, LapseRate<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LapseRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(LapseRate left, LapseRate right)
+        /// <remarks>Consider using <see cref="Equals(LapseRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(LapseRate<T> left, LapseRate<T> right)
         {
             return !(left == right);
         }
@@ -457,37 +459,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lapse
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is LapseRate objLapseRate)) throw new ArgumentException("Expected type LapseRate.", nameof(obj));
+            if(!(obj is LapseRate<T> objLapseRate)) throw new ArgumentException("Expected type LapseRate.", nameof(obj));
 
             return CompareTo(objLapseRate);
         }
 
         /// <inheritdoc />
-        public int CompareTo(LapseRate other)
+        public int CompareTo(LapseRate<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LapseRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(LapseRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is LapseRate objLapseRate))
+            if(obj is null || !(obj is LapseRate<T> objLapseRate))
                 return false;
 
             return Equals(objLapseRate);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LapseRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(LapseRate other)
+        /// <remarks>Consider using <see cref="Equals(LapseRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(LapseRate<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another LapseRate within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="LapseRate{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -525,21 +527,19 @@ public bool Equals(LapseRate other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(LapseRate other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(LapseRate<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current LapseRate.</returns>
+        /// <returns>A hash code for the current <see cref="LapseRate{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -553,17 +553,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LapseRateUnit unit)
+        public T As(LapseRateUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -583,17 +583,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LapseRateUnit unitAsLapseRateUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LapseRateUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLapseRateUnit);
+            var asValue = As(unitAsLapseRateUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LapseRateUnit>.As(LapseRateUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this LapseRate to another LapseRate with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="LapseRate{T}" /> to another <see cref="LapseRate{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A LapseRate with the specified unit.</returns>
-        public LapseRate ToUnit(LapseRateUnit unit)
+        /// <returns>A <see cref="LapseRate{T}" /> with the specified unit.</returns>
+        public LapseRate<T> ToUnit(LapseRateUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new LapseRate(convertedValue, unit);
+            return new LapseRate<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -606,7 +611,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public LapseRate ToUnit(UnitSystem unitSystem)
+        public LapseRate<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -626,19 +631,25 @@ public LapseRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LapseRateUnit> IQuantity<LapseRateUnit>.ToUnit(LapseRateUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LapseRateUnit, T> IQuantityT<LapseRateUnit, T>.ToUnit(LapseRateUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LapseRateUnit> IQuantity<LapseRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LapseRateUnit, T> IQuantityT<LapseRateUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LapseRateUnit.DegreeCelsiusPerKilometer: return _value;
+                case LapseRateUnit.DegreeCelsiusPerKilometer: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -649,16 +660,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal LapseRate ToBaseUnit()
+        internal LapseRate<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new LapseRate(baseUnitValue, BaseUnit);
+            return new LapseRate<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LapseRateUnit unit)
+        private T GetValueAs(LapseRateUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -761,57 +772,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LapseRate)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LapseRate<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LapseRate)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LapseRate<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LapseRate)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LapseRate<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -821,33 +832,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(LapseRate))
+            if(conversionType == typeof(LapseRate<T>))
                 return this;
             else if(conversionType == typeof(LapseRateUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return LapseRate.QuantityType;
+                return LapseRate<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return LapseRate.Info;
+                return LapseRate<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return LapseRate.BaseDimensions;
+                return LapseRate<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(LapseRate)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(LapseRate<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
index d6e2f06466..8b2935484c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Many different units of length have been used around the world. The main units in modern use are U.S. customary units in the United States and the Metric system elsewhere. British Imperial units are still used for some purposes in the United Kingdom and some other countries. The metric system is sub-divided into SI and non-SI units.
     /// </summary>
-    public partial struct Length : IQuantity<LengthUnit>, IEquatable<Length>, IComparable, IComparable<Length>, IConvertible, IFormattable
+    public partial struct Length<T> : IQuantityT<LengthUnit, T>, IEquatable<Length<T>>, IComparable, IComparable<Length<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -95,12 +91,12 @@ static Length()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Length(double value, LengthUnit unit)
+        public Length(T value, LengthUnit unit)
         {
             if(unit == LengthUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -112,14 +108,14 @@ public Length(double value, LengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Length(double value, UnitSystem unitSystem)
+        public Length(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -134,19 +130,19 @@ public Length(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Length, which is Meter. All conversions go via this value.
+        ///     The base unit of <see cref="Length{T}" />, which is Meter. All conversions go via this value.
         /// </summary>
         public static LengthUnit BaseUnit { get; } = LengthUnit.Meter;
 
         /// <summary>
-        /// Represents the largest possible value of Length
+        /// Represents the largest possible value of <see cref="Length{T}" />
         /// </summary>
-        public static Length MaxValue { get; } = new Length(double.MaxValue, BaseUnit);
+        public static Length<T> MaxValue { get; } = new Length<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Length
+        /// Represents the smallest possible value of <see cref="Length{T}" />
         /// </summary>
-        public static Length MinValue { get; } = new Length(double.MinValue, BaseUnit);
+        public static Length<T> MinValue { get; } = new Length<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -155,14 +151,14 @@ public Length(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Length;
 
         /// <summary>
-        ///     All units of measurement for the Length quantity.
+        ///     All units of measurement for the <see cref="Length{T}" /> quantity.
         /// </summary>
         public static LengthUnit[] Units { get; } = Enum.GetValues(typeof(LengthUnit)).Cast<LengthUnit>().Except(new LengthUnit[]{ LengthUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Meter.
         /// </summary>
-        public static Length Zero { get; } = new Length(0, BaseUnit);
+        public static Length<T> Zero { get; } = new Length<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -171,7 +167,9 @@ public Length(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -187,181 +185,181 @@ public Length(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Length.QuantityType;
+        public QuantityType Type => Length<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Length.BaseDimensions;
+        public BaseDimensions Dimensions => Length<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Length in AstronomicalUnits.
+        ///     Get <see cref="Length{T}" /> in AstronomicalUnits.
         /// </summary>
-        public double AstronomicalUnits => As(LengthUnit.AstronomicalUnit);
+        public T AstronomicalUnits => As(LengthUnit.AstronomicalUnit);
 
         /// <summary>
-        ///     Get Length in Centimeters.
+        ///     Get <see cref="Length{T}" /> in Centimeters.
         /// </summary>
-        public double Centimeters => As(LengthUnit.Centimeter);
+        public T Centimeters => As(LengthUnit.Centimeter);
 
         /// <summary>
-        ///     Get Length in Chains.
+        ///     Get <see cref="Length{T}" /> in Chains.
         /// </summary>
-        public double Chains => As(LengthUnit.Chain);
+        public T Chains => As(LengthUnit.Chain);
 
         /// <summary>
-        ///     Get Length in Decimeters.
+        ///     Get <see cref="Length{T}" /> in Decimeters.
         /// </summary>
-        public double Decimeters => As(LengthUnit.Decimeter);
+        public T Decimeters => As(LengthUnit.Decimeter);
 
         /// <summary>
-        ///     Get Length in DtpPicas.
+        ///     Get <see cref="Length{T}" /> in DtpPicas.
         /// </summary>
-        public double DtpPicas => As(LengthUnit.DtpPica);
+        public T DtpPicas => As(LengthUnit.DtpPica);
 
         /// <summary>
-        ///     Get Length in DtpPoints.
+        ///     Get <see cref="Length{T}" /> in DtpPoints.
         /// </summary>
-        public double DtpPoints => As(LengthUnit.DtpPoint);
+        public T DtpPoints => As(LengthUnit.DtpPoint);
 
         /// <summary>
-        ///     Get Length in Fathoms.
+        ///     Get <see cref="Length{T}" /> in Fathoms.
         /// </summary>
-        public double Fathoms => As(LengthUnit.Fathom);
+        public T Fathoms => As(LengthUnit.Fathom);
 
         /// <summary>
-        ///     Get Length in Feet.
+        ///     Get <see cref="Length{T}" /> in Feet.
         /// </summary>
-        public double Feet => As(LengthUnit.Foot);
+        public T Feet => As(LengthUnit.Foot);
 
         /// <summary>
-        ///     Get Length in Hands.
+        ///     Get <see cref="Length{T}" /> in Hands.
         /// </summary>
-        public double Hands => As(LengthUnit.Hand);
+        public T Hands => As(LengthUnit.Hand);
 
         /// <summary>
-        ///     Get Length in Hectometers.
+        ///     Get <see cref="Length{T}" /> in Hectometers.
         /// </summary>
-        public double Hectometers => As(LengthUnit.Hectometer);
+        public T Hectometers => As(LengthUnit.Hectometer);
 
         /// <summary>
-        ///     Get Length in Inches.
+        ///     Get <see cref="Length{T}" /> in Inches.
         /// </summary>
-        public double Inches => As(LengthUnit.Inch);
+        public T Inches => As(LengthUnit.Inch);
 
         /// <summary>
-        ///     Get Length in KilolightYears.
+        ///     Get <see cref="Length{T}" /> in KilolightYears.
         /// </summary>
-        public double KilolightYears => As(LengthUnit.KilolightYear);
+        public T KilolightYears => As(LengthUnit.KilolightYear);
 
         /// <summary>
-        ///     Get Length in Kilometers.
+        ///     Get <see cref="Length{T}" /> in Kilometers.
         /// </summary>
-        public double Kilometers => As(LengthUnit.Kilometer);
+        public T Kilometers => As(LengthUnit.Kilometer);
 
         /// <summary>
-        ///     Get Length in Kiloparsecs.
+        ///     Get <see cref="Length{T}" /> in Kiloparsecs.
         /// </summary>
-        public double Kiloparsecs => As(LengthUnit.Kiloparsec);
+        public T Kiloparsecs => As(LengthUnit.Kiloparsec);
 
         /// <summary>
-        ///     Get Length in LightYears.
+        ///     Get <see cref="Length{T}" /> in LightYears.
         /// </summary>
-        public double LightYears => As(LengthUnit.LightYear);
+        public T LightYears => As(LengthUnit.LightYear);
 
         /// <summary>
-        ///     Get Length in MegalightYears.
+        ///     Get <see cref="Length{T}" /> in MegalightYears.
         /// </summary>
-        public double MegalightYears => As(LengthUnit.MegalightYear);
+        public T MegalightYears => As(LengthUnit.MegalightYear);
 
         /// <summary>
-        ///     Get Length in Megaparsecs.
+        ///     Get <see cref="Length{T}" /> in Megaparsecs.
         /// </summary>
-        public double Megaparsecs => As(LengthUnit.Megaparsec);
+        public T Megaparsecs => As(LengthUnit.Megaparsec);
 
         /// <summary>
-        ///     Get Length in Meters.
+        ///     Get <see cref="Length{T}" /> in Meters.
         /// </summary>
-        public double Meters => As(LengthUnit.Meter);
+        public T Meters => As(LengthUnit.Meter);
 
         /// <summary>
-        ///     Get Length in Microinches.
+        ///     Get <see cref="Length{T}" /> in Microinches.
         /// </summary>
-        public double Microinches => As(LengthUnit.Microinch);
+        public T Microinches => As(LengthUnit.Microinch);
 
         /// <summary>
-        ///     Get Length in Micrometers.
+        ///     Get <see cref="Length{T}" /> in Micrometers.
         /// </summary>
-        public double Micrometers => As(LengthUnit.Micrometer);
+        public T Micrometers => As(LengthUnit.Micrometer);
 
         /// <summary>
-        ///     Get Length in Mils.
+        ///     Get <see cref="Length{T}" /> in Mils.
         /// </summary>
-        public double Mils => As(LengthUnit.Mil);
+        public T Mils => As(LengthUnit.Mil);
 
         /// <summary>
-        ///     Get Length in Miles.
+        ///     Get <see cref="Length{T}" /> in Miles.
         /// </summary>
-        public double Miles => As(LengthUnit.Mile);
+        public T Miles => As(LengthUnit.Mile);
 
         /// <summary>
-        ///     Get Length in Millimeters.
+        ///     Get <see cref="Length{T}" /> in Millimeters.
         /// </summary>
-        public double Millimeters => As(LengthUnit.Millimeter);
+        public T Millimeters => As(LengthUnit.Millimeter);
 
         /// <summary>
-        ///     Get Length in Nanometers.
+        ///     Get <see cref="Length{T}" /> in Nanometers.
         /// </summary>
-        public double Nanometers => As(LengthUnit.Nanometer);
+        public T Nanometers => As(LengthUnit.Nanometer);
 
         /// <summary>
-        ///     Get Length in NauticalMiles.
+        ///     Get <see cref="Length{T}" /> in NauticalMiles.
         /// </summary>
-        public double NauticalMiles => As(LengthUnit.NauticalMile);
+        public T NauticalMiles => As(LengthUnit.NauticalMile);
 
         /// <summary>
-        ///     Get Length in Parsecs.
+        ///     Get <see cref="Length{T}" /> in Parsecs.
         /// </summary>
-        public double Parsecs => As(LengthUnit.Parsec);
+        public T Parsecs => As(LengthUnit.Parsec);
 
         /// <summary>
-        ///     Get Length in PrinterPicas.
+        ///     Get <see cref="Length{T}" /> in PrinterPicas.
         /// </summary>
-        public double PrinterPicas => As(LengthUnit.PrinterPica);
+        public T PrinterPicas => As(LengthUnit.PrinterPica);
 
         /// <summary>
-        ///     Get Length in PrinterPoints.
+        ///     Get <see cref="Length{T}" /> in PrinterPoints.
         /// </summary>
-        public double PrinterPoints => As(LengthUnit.PrinterPoint);
+        public T PrinterPoints => As(LengthUnit.PrinterPoint);
 
         /// <summary>
-        ///     Get Length in Shackles.
+        ///     Get <see cref="Length{T}" /> in Shackles.
         /// </summary>
-        public double Shackles => As(LengthUnit.Shackle);
+        public T Shackles => As(LengthUnit.Shackle);
 
         /// <summary>
-        ///     Get Length in SolarRadiuses.
+        ///     Get <see cref="Length{T}" /> in SolarRadiuses.
         /// </summary>
-        public double SolarRadiuses => As(LengthUnit.SolarRadius);
+        public T SolarRadiuses => As(LengthUnit.SolarRadius);
 
         /// <summary>
-        ///     Get Length in Twips.
+        ///     Get <see cref="Length{T}" /> in Twips.
         /// </summary>
-        public double Twips => As(LengthUnit.Twip);
+        public T Twips => As(LengthUnit.Twip);
 
         /// <summary>
-        ///     Get Length in UsSurveyFeet.
+        ///     Get <see cref="Length{T}" /> in UsSurveyFeet.
         /// </summary>
-        public double UsSurveyFeet => As(LengthUnit.UsSurveyFoot);
+        public T UsSurveyFeet => As(LengthUnit.UsSurveyFoot);
 
         /// <summary>
-        ///     Get Length in Yards.
+        ///     Get <see cref="Length{T}" /> in Yards.
         /// </summary>
-        public double Yards => As(LengthUnit.Yard);
+        public T Yards => As(LengthUnit.Yard);
 
         #endregion
 
@@ -393,312 +391,279 @@ public static string GetAbbreviation(LengthUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Length from AstronomicalUnits.
+        ///     Get <see cref="Length{T}" /> from AstronomicalUnits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromAstronomicalUnits(QuantityValue astronomicalunits)
+        public static Length<T> FromAstronomicalUnits(T astronomicalunits)
         {
-            double value = (double) astronomicalunits;
-            return new Length(value, LengthUnit.AstronomicalUnit);
+            return new Length<T>(astronomicalunits, LengthUnit.AstronomicalUnit);
         }
         /// <summary>
-        ///     Get Length from Centimeters.
+        ///     Get <see cref="Length{T}" /> from Centimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromCentimeters(QuantityValue centimeters)
+        public static Length<T> FromCentimeters(T centimeters)
         {
-            double value = (double) centimeters;
-            return new Length(value, LengthUnit.Centimeter);
+            return new Length<T>(centimeters, LengthUnit.Centimeter);
         }
         /// <summary>
-        ///     Get Length from Chains.
+        ///     Get <see cref="Length{T}" /> from Chains.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromChains(QuantityValue chains)
+        public static Length<T> FromChains(T chains)
         {
-            double value = (double) chains;
-            return new Length(value, LengthUnit.Chain);
+            return new Length<T>(chains, LengthUnit.Chain);
         }
         /// <summary>
-        ///     Get Length from Decimeters.
+        ///     Get <see cref="Length{T}" /> from Decimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDecimeters(QuantityValue decimeters)
+        public static Length<T> FromDecimeters(T decimeters)
         {
-            double value = (double) decimeters;
-            return new Length(value, LengthUnit.Decimeter);
+            return new Length<T>(decimeters, LengthUnit.Decimeter);
         }
         /// <summary>
-        ///     Get Length from DtpPicas.
+        ///     Get <see cref="Length{T}" /> from DtpPicas.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDtpPicas(QuantityValue dtppicas)
+        public static Length<T> FromDtpPicas(T dtppicas)
         {
-            double value = (double) dtppicas;
-            return new Length(value, LengthUnit.DtpPica);
+            return new Length<T>(dtppicas, LengthUnit.DtpPica);
         }
         /// <summary>
-        ///     Get Length from DtpPoints.
+        ///     Get <see cref="Length{T}" /> from DtpPoints.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDtpPoints(QuantityValue dtppoints)
+        public static Length<T> FromDtpPoints(T dtppoints)
         {
-            double value = (double) dtppoints;
-            return new Length(value, LengthUnit.DtpPoint);
+            return new Length<T>(dtppoints, LengthUnit.DtpPoint);
         }
         /// <summary>
-        ///     Get Length from Fathoms.
+        ///     Get <see cref="Length{T}" /> from Fathoms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFathoms(QuantityValue fathoms)
+        public static Length<T> FromFathoms(T fathoms)
         {
-            double value = (double) fathoms;
-            return new Length(value, LengthUnit.Fathom);
+            return new Length<T>(fathoms, LengthUnit.Fathom);
         }
         /// <summary>
-        ///     Get Length from Feet.
+        ///     Get <see cref="Length{T}" /> from Feet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFeet(QuantityValue feet)
+        public static Length<T> FromFeet(T feet)
         {
-            double value = (double) feet;
-            return new Length(value, LengthUnit.Foot);
+            return new Length<T>(feet, LengthUnit.Foot);
         }
         /// <summary>
-        ///     Get Length from Hands.
+        ///     Get <see cref="Length{T}" /> from Hands.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromHands(QuantityValue hands)
+        public static Length<T> FromHands(T hands)
         {
-            double value = (double) hands;
-            return new Length(value, LengthUnit.Hand);
+            return new Length<T>(hands, LengthUnit.Hand);
         }
         /// <summary>
-        ///     Get Length from Hectometers.
+        ///     Get <see cref="Length{T}" /> from Hectometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromHectometers(QuantityValue hectometers)
+        public static Length<T> FromHectometers(T hectometers)
         {
-            double value = (double) hectometers;
-            return new Length(value, LengthUnit.Hectometer);
+            return new Length<T>(hectometers, LengthUnit.Hectometer);
         }
         /// <summary>
-        ///     Get Length from Inches.
+        ///     Get <see cref="Length{T}" /> from Inches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromInches(QuantityValue inches)
+        public static Length<T> FromInches(T inches)
         {
-            double value = (double) inches;
-            return new Length(value, LengthUnit.Inch);
+            return new Length<T>(inches, LengthUnit.Inch);
         }
         /// <summary>
-        ///     Get Length from KilolightYears.
+        ///     Get <see cref="Length{T}" /> from KilolightYears.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilolightYears(QuantityValue kilolightyears)
+        public static Length<T> FromKilolightYears(T kilolightyears)
         {
-            double value = (double) kilolightyears;
-            return new Length(value, LengthUnit.KilolightYear);
+            return new Length<T>(kilolightyears, LengthUnit.KilolightYear);
         }
         /// <summary>
-        ///     Get Length from Kilometers.
+        ///     Get <see cref="Length{T}" /> from Kilometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilometers(QuantityValue kilometers)
+        public static Length<T> FromKilometers(T kilometers)
         {
-            double value = (double) kilometers;
-            return new Length(value, LengthUnit.Kilometer);
+            return new Length<T>(kilometers, LengthUnit.Kilometer);
         }
         /// <summary>
-        ///     Get Length from Kiloparsecs.
+        ///     Get <see cref="Length{T}" /> from Kiloparsecs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKiloparsecs(QuantityValue kiloparsecs)
+        public static Length<T> FromKiloparsecs(T kiloparsecs)
         {
-            double value = (double) kiloparsecs;
-            return new Length(value, LengthUnit.Kiloparsec);
+            return new Length<T>(kiloparsecs, LengthUnit.Kiloparsec);
         }
         /// <summary>
-        ///     Get Length from LightYears.
+        ///     Get <see cref="Length{T}" /> from LightYears.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromLightYears(QuantityValue lightyears)
+        public static Length<T> FromLightYears(T lightyears)
         {
-            double value = (double) lightyears;
-            return new Length(value, LengthUnit.LightYear);
+            return new Length<T>(lightyears, LengthUnit.LightYear);
         }
         /// <summary>
-        ///     Get Length from MegalightYears.
+        ///     Get <see cref="Length{T}" /> from MegalightYears.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegalightYears(QuantityValue megalightyears)
+        public static Length<T> FromMegalightYears(T megalightyears)
         {
-            double value = (double) megalightyears;
-            return new Length(value, LengthUnit.MegalightYear);
+            return new Length<T>(megalightyears, LengthUnit.MegalightYear);
         }
         /// <summary>
-        ///     Get Length from Megaparsecs.
+        ///     Get <see cref="Length{T}" /> from Megaparsecs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegaparsecs(QuantityValue megaparsecs)
+        public static Length<T> FromMegaparsecs(T megaparsecs)
         {
-            double value = (double) megaparsecs;
-            return new Length(value, LengthUnit.Megaparsec);
+            return new Length<T>(megaparsecs, LengthUnit.Megaparsec);
         }
         /// <summary>
-        ///     Get Length from Meters.
+        ///     Get <see cref="Length{T}" /> from Meters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMeters(QuantityValue meters)
+        public static Length<T> FromMeters(T meters)
         {
-            double value = (double) meters;
-            return new Length(value, LengthUnit.Meter);
+            return new Length<T>(meters, LengthUnit.Meter);
         }
         /// <summary>
-        ///     Get Length from Microinches.
+        ///     Get <see cref="Length{T}" /> from Microinches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMicroinches(QuantityValue microinches)
+        public static Length<T> FromMicroinches(T microinches)
         {
-            double value = (double) microinches;
-            return new Length(value, LengthUnit.Microinch);
+            return new Length<T>(microinches, LengthUnit.Microinch);
         }
         /// <summary>
-        ///     Get Length from Micrometers.
+        ///     Get <see cref="Length{T}" /> from Micrometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMicrometers(QuantityValue micrometers)
+        public static Length<T> FromMicrometers(T micrometers)
         {
-            double value = (double) micrometers;
-            return new Length(value, LengthUnit.Micrometer);
+            return new Length<T>(micrometers, LengthUnit.Micrometer);
         }
         /// <summary>
-        ///     Get Length from Mils.
+        ///     Get <see cref="Length{T}" /> from Mils.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMils(QuantityValue mils)
+        public static Length<T> FromMils(T mils)
         {
-            double value = (double) mils;
-            return new Length(value, LengthUnit.Mil);
+            return new Length<T>(mils, LengthUnit.Mil);
         }
         /// <summary>
-        ///     Get Length from Miles.
+        ///     Get <see cref="Length{T}" /> from Miles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMiles(QuantityValue miles)
+        public static Length<T> FromMiles(T miles)
         {
-            double value = (double) miles;
-            return new Length(value, LengthUnit.Mile);
+            return new Length<T>(miles, LengthUnit.Mile);
         }
         /// <summary>
-        ///     Get Length from Millimeters.
+        ///     Get <see cref="Length{T}" /> from Millimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMillimeters(QuantityValue millimeters)
+        public static Length<T> FromMillimeters(T millimeters)
         {
-            double value = (double) millimeters;
-            return new Length(value, LengthUnit.Millimeter);
+            return new Length<T>(millimeters, LengthUnit.Millimeter);
         }
         /// <summary>
-        ///     Get Length from Nanometers.
+        ///     Get <see cref="Length{T}" /> from Nanometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromNanometers(QuantityValue nanometers)
+        public static Length<T> FromNanometers(T nanometers)
         {
-            double value = (double) nanometers;
-            return new Length(value, LengthUnit.Nanometer);
+            return new Length<T>(nanometers, LengthUnit.Nanometer);
         }
         /// <summary>
-        ///     Get Length from NauticalMiles.
+        ///     Get <see cref="Length{T}" /> from NauticalMiles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromNauticalMiles(QuantityValue nauticalmiles)
+        public static Length<T> FromNauticalMiles(T nauticalmiles)
         {
-            double value = (double) nauticalmiles;
-            return new Length(value, LengthUnit.NauticalMile);
+            return new Length<T>(nauticalmiles, LengthUnit.NauticalMile);
         }
         /// <summary>
-        ///     Get Length from Parsecs.
+        ///     Get <see cref="Length{T}" /> from Parsecs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromParsecs(QuantityValue parsecs)
+        public static Length<T> FromParsecs(T parsecs)
         {
-            double value = (double) parsecs;
-            return new Length(value, LengthUnit.Parsec);
+            return new Length<T>(parsecs, LengthUnit.Parsec);
         }
         /// <summary>
-        ///     Get Length from PrinterPicas.
+        ///     Get <see cref="Length{T}" /> from PrinterPicas.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPrinterPicas(QuantityValue printerpicas)
+        public static Length<T> FromPrinterPicas(T printerpicas)
         {
-            double value = (double) printerpicas;
-            return new Length(value, LengthUnit.PrinterPica);
+            return new Length<T>(printerpicas, LengthUnit.PrinterPica);
         }
         /// <summary>
-        ///     Get Length from PrinterPoints.
+        ///     Get <see cref="Length{T}" /> from PrinterPoints.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPrinterPoints(QuantityValue printerpoints)
+        public static Length<T> FromPrinterPoints(T printerpoints)
         {
-            double value = (double) printerpoints;
-            return new Length(value, LengthUnit.PrinterPoint);
+            return new Length<T>(printerpoints, LengthUnit.PrinterPoint);
         }
         /// <summary>
-        ///     Get Length from Shackles.
+        ///     Get <see cref="Length{T}" /> from Shackles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromShackles(QuantityValue shackles)
+        public static Length<T> FromShackles(T shackles)
         {
-            double value = (double) shackles;
-            return new Length(value, LengthUnit.Shackle);
+            return new Length<T>(shackles, LengthUnit.Shackle);
         }
         /// <summary>
-        ///     Get Length from SolarRadiuses.
+        ///     Get <see cref="Length{T}" /> from SolarRadiuses.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromSolarRadiuses(QuantityValue solarradiuses)
+        public static Length<T> FromSolarRadiuses(T solarradiuses)
         {
-            double value = (double) solarradiuses;
-            return new Length(value, LengthUnit.SolarRadius);
+            return new Length<T>(solarradiuses, LengthUnit.SolarRadius);
         }
         /// <summary>
-        ///     Get Length from Twips.
+        ///     Get <see cref="Length{T}" /> from Twips.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromTwips(QuantityValue twips)
+        public static Length<T> FromTwips(T twips)
         {
-            double value = (double) twips;
-            return new Length(value, LengthUnit.Twip);
+            return new Length<T>(twips, LengthUnit.Twip);
         }
         /// <summary>
-        ///     Get Length from UsSurveyFeet.
+        ///     Get <see cref="Length{T}" /> from UsSurveyFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromUsSurveyFeet(QuantityValue ussurveyfeet)
+        public static Length<T> FromUsSurveyFeet(T ussurveyfeet)
         {
-            double value = (double) ussurveyfeet;
-            return new Length(value, LengthUnit.UsSurveyFoot);
+            return new Length<T>(ussurveyfeet, LengthUnit.UsSurveyFoot);
         }
         /// <summary>
-        ///     Get Length from Yards.
+        ///     Get <see cref="Length{T}" /> from Yards.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromYards(QuantityValue yards)
+        public static Length<T> FromYards(T yards)
         {
-            double value = (double) yards;
-            return new Length(value, LengthUnit.Yard);
+            return new Length<T>(yards, LengthUnit.Yard);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LengthUnit" /> to <see cref="Length" />.
+        ///     Dynamically convert from value and unit enum <see cref="LengthUnit" /> to <see cref="Length{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Length unit value.</returns>
-        public static Length From(QuantityValue value, LengthUnit fromUnit)
+        /// <returns><see cref="Length{T}" /> unit value.</returns>
+        public static Length<T> From(T value, LengthUnit fromUnit)
         {
-            return new Length((double)value, fromUnit);
+            return new Length<T>(value, fromUnit);
         }
 
         #endregion
@@ -727,7 +692,7 @@ public static Length From(QuantityValue value, LengthUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Length Parse(string str)
+        public static Length<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -755,9 +720,9 @@ public static Length Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Length Parse(string str, IFormatProvider? provider)
+        public static Length<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Length, LengthUnit>(
+            return QuantityParser.Default.Parse<T, Length<T>, LengthUnit>(
                 str,
                 provider,
                 From);
@@ -771,7 +736,7 @@ public static Length Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Length result)
+        public static bool TryParse(string? str, out Length<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -786,9 +751,9 @@ public static bool TryParse(string? str, out Length result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Length result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Length<T> result)
         {
-            return QuantityParser.Default.TryParse<Length, LengthUnit>(
+            return QuantityParser.Default.TryParse<T, Length<T>, LengthUnit>(
                 str,
                 provider,
                 From,
@@ -850,45 +815,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lengt
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Length operator -(Length right)
+        public static Length<T> operator -(Length<T> right)
         {
-            return new Length(-right.Value, right.Unit);
+            return new Length<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Length"/> from adding two <see cref="Length"/>.</summary>
-        public static Length operator +(Length left, Length right)
+        /// <summary>Get <see cref="Length{T}"/> from adding two <see cref="Length{T}"/>.</summary>
+        public static Length<T> operator +(Length<T> left, Length<T> right)
         {
-            return new Length(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Length<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Length"/> from subtracting two <see cref="Length"/>.</summary>
-        public static Length operator -(Length left, Length right)
+        /// <summary>Get <see cref="Length{T}"/> from subtracting two <see cref="Length{T}"/>.</summary>
+        public static Length<T> operator -(Length<T> left, Length<T> right)
         {
-            return new Length(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Length<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Length"/> from multiplying value and <see cref="Length"/>.</summary>
-        public static Length operator *(double left, Length right)
+        /// <summary>Get <see cref="Length{T}"/> from multiplying value and <see cref="Length{T}"/>.</summary>
+        public static Length<T> operator *(T left, Length<T> right)
         {
-            return new Length(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Length<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Length"/> from multiplying value and <see cref="Length"/>.</summary>
-        public static Length operator *(Length left, double right)
+        /// <summary>Get <see cref="Length{T}"/> from multiplying value and <see cref="Length{T}"/>.</summary>
+        public static Length<T> operator *(Length<T> left, T right)
         {
-            return new Length(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Length<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Length"/> from dividing <see cref="Length"/> by value.</summary>
-        public static Length operator /(Length left, double right)
+        /// <summary>Get <see cref="Length{T}"/> from dividing <see cref="Length{T}"/> by value.</summary>
+        public static Length<T> operator /(Length<T> left, T right)
         {
-            return new Length(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Length<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Length"/> by <see cref="Length"/>.</summary>
-        public static double operator /(Length left, Length right)
+        /// <summary>Get ratio value from dividing <see cref="Length{T}"/> by <see cref="Length{T}"/>.</summary>
+        public static T operator /(Length<T> left, Length<T> right)
         {
-            return left.Meters / right.Meters;
+            return CompiledLambdas.Divide(left.Meters, right.Meters);
         }
 
         #endregion
@@ -896,39 +866,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lengt
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Length left, Length right)
+        public static bool operator <=(Length<T> left, Length<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Length left, Length right)
+        public static bool operator >=(Length<T> left, Length<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Length left, Length right)
+        public static bool operator <(Length<T> left, Length<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Length left, Length right)
+        public static bool operator >(Length<T> left, Length<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Length, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Length left, Length right)
+        /// <remarks>Consider using <see cref="Equals(Length{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Length<T> left, Length<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Length, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Length left, Length right)
+        /// <remarks>Consider using <see cref="Equals(Length{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Length<T> left, Length<T> right)
         {
             return !(left == right);
         }
@@ -937,37 +907,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lengt
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Length objLength)) throw new ArgumentException("Expected type Length.", nameof(obj));
+            if(!(obj is Length<T> objLength)) throw new ArgumentException("Expected type Length.", nameof(obj));
 
             return CompareTo(objLength);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Length other)
+        public int CompareTo(Length<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Length, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Length{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Length objLength))
+            if(obj is null || !(obj is Length<T> objLength))
                 return false;
 
             return Equals(objLength);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Length, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Length other)
+        /// <remarks>Consider using <see cref="Equals(Length{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Length<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Length within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Length{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1005,21 +975,19 @@ public bool Equals(Length other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Length other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Length<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Length.</returns>
+        /// <returns>A hash code for the current <see cref="Length{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1033,17 +1001,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LengthUnit unit)
+        public T As(LengthUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1063,17 +1031,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LengthUnit unitAsLengthUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LengthUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLengthUnit);
+            var asValue = As(unitAsLengthUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LengthUnit>.As(LengthUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Length to another Length with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Length{T}" /> to another <see cref="Length{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Length with the specified unit.</returns>
-        public Length ToUnit(LengthUnit unit)
+        /// <returns>A <see cref="Length{T}" /> with the specified unit.</returns>
+        public Length<T> ToUnit(LengthUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Length(convertedValue, unit);
+            return new Length<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1086,7 +1059,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Length ToUnit(UnitSystem unitSystem)
+        public Length<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1106,51 +1079,57 @@ public Length ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LengthUnit> IQuantity<LengthUnit>.ToUnit(LengthUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LengthUnit, T> IQuantityT<LengthUnit, T>.ToUnit(LengthUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LengthUnit> IQuantity<LengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LengthUnit, T> IQuantityT<LengthUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LengthUnit.AstronomicalUnit: return _value * 1.4959787070e11;
-                case LengthUnit.Centimeter: return (_value) * 1e-2d;
-                case LengthUnit.Chain: return _value*20.1168;
-                case LengthUnit.Decimeter: return (_value) * 1e-1d;
-                case LengthUnit.DtpPica: return _value/236.220472441;
-                case LengthUnit.DtpPoint: return (_value/72)*2.54e-2;
-                case LengthUnit.Fathom: return _value*1.8288;
-                case LengthUnit.Foot: return _value*0.3048;
-                case LengthUnit.Hand: return _value * 1.016e-1;
-                case LengthUnit.Hectometer: return (_value) * 1e2d;
-                case LengthUnit.Inch: return _value*2.54e-2;
-                case LengthUnit.KilolightYear: return (_value * 9.46073047258e15) * 1e3d;
-                case LengthUnit.Kilometer: return (_value) * 1e3d;
-                case LengthUnit.Kiloparsec: return (_value * 3.08567758128e16) * 1e3d;
-                case LengthUnit.LightYear: return _value * 9.46073047258e15;
-                case LengthUnit.MegalightYear: return (_value * 9.46073047258e15) * 1e6d;
-                case LengthUnit.Megaparsec: return (_value * 3.08567758128e16) * 1e6d;
-                case LengthUnit.Meter: return _value;
-                case LengthUnit.Microinch: return _value*2.54e-8;
-                case LengthUnit.Micrometer: return (_value) * 1e-6d;
-                case LengthUnit.Mil: return _value*2.54e-5;
-                case LengthUnit.Mile: return _value*1609.34;
-                case LengthUnit.Millimeter: return (_value) * 1e-3d;
-                case LengthUnit.Nanometer: return (_value) * 1e-9d;
-                case LengthUnit.NauticalMile: return _value*1852;
-                case LengthUnit.Parsec: return _value * 3.08567758128e16;
-                case LengthUnit.PrinterPica: return _value/237.106301584;
-                case LengthUnit.PrinterPoint: return (_value/72.27)*2.54e-2;
-                case LengthUnit.Shackle: return _value*27.432;
-                case LengthUnit.SolarRadius: return _value * 6.95510000E+08;
-                case LengthUnit.Twip: return _value/56692.913385826;
-                case LengthUnit.UsSurveyFoot: return _value*1200/3937;
-                case LengthUnit.Yard: return _value*0.9144;
+                case LengthUnit.AstronomicalUnit: return Value * 1.4959787070e11;
+                case LengthUnit.Centimeter: return (Value) * 1e-2d;
+                case LengthUnit.Chain: return Value*20.1168;
+                case LengthUnit.Decimeter: return (Value) * 1e-1d;
+                case LengthUnit.DtpPica: return Value/236.220472441;
+                case LengthUnit.DtpPoint: return (Value/72)*2.54e-2;
+                case LengthUnit.Fathom: return Value*1.8288;
+                case LengthUnit.Foot: return Value*0.3048;
+                case LengthUnit.Hand: return Value * 1.016e-1;
+                case LengthUnit.Hectometer: return (Value) * 1e2d;
+                case LengthUnit.Inch: return Value*2.54e-2;
+                case LengthUnit.KilolightYear: return (Value * 9.46073047258e15) * 1e3d;
+                case LengthUnit.Kilometer: return (Value) * 1e3d;
+                case LengthUnit.Kiloparsec: return (Value * 3.08567758128e16) * 1e3d;
+                case LengthUnit.LightYear: return Value * 9.46073047258e15;
+                case LengthUnit.MegalightYear: return (Value * 9.46073047258e15) * 1e6d;
+                case LengthUnit.Megaparsec: return (Value * 3.08567758128e16) * 1e6d;
+                case LengthUnit.Meter: return Value;
+                case LengthUnit.Microinch: return Value*2.54e-8;
+                case LengthUnit.Micrometer: return (Value) * 1e-6d;
+                case LengthUnit.Mil: return Value*2.54e-5;
+                case LengthUnit.Mile: return Value*1609.34;
+                case LengthUnit.Millimeter: return (Value) * 1e-3d;
+                case LengthUnit.Nanometer: return (Value) * 1e-9d;
+                case LengthUnit.NauticalMile: return Value*1852;
+                case LengthUnit.Parsec: return Value * 3.08567758128e16;
+                case LengthUnit.PrinterPica: return Value/237.106301584;
+                case LengthUnit.PrinterPoint: return (Value/72.27)*2.54e-2;
+                case LengthUnit.Shackle: return Value*27.432;
+                case LengthUnit.SolarRadius: return Value * 6.95510000E+08;
+                case LengthUnit.Twip: return Value/56692.913385826;
+                case LengthUnit.UsSurveyFoot: return Value*1200/3937;
+                case LengthUnit.Yard: return Value*0.9144;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1161,16 +1140,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Length ToBaseUnit()
+        internal Length<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Length(baseUnitValue, BaseUnit);
+            return new Length<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LengthUnit unit)
+        private T GetValueAs(LengthUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1305,57 +1284,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Length)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Length<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Length)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Length<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Length)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Length<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1365,33 +1344,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Length))
+            if(conversionType == typeof(Length<T>))
                 return this;
             else if(conversionType == typeof(LengthUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Length.QuantityType;
+                return Length<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Length.Info;
+                return Length<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Length.BaseDimensions;
+                return Length<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Length)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Length<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Level.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
index eca5f6df74..ab07afb04e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Level.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Level is the logarithm of the ratio of a quantity Q to a reference value of that quantity, Q₀, expressed in dimensionless units.
     /// </summary>
-    public partial struct Level : IQuantity<LevelUnit>, IEquatable<Level>, IComparable, IComparable<Level>, IConvertible, IFormattable
+    public partial struct Level<T> : IQuantityT<LevelUnit, T>, IEquatable<Level<T>>, IComparable, IComparable<Level<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -64,12 +60,12 @@ static Level()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Level(double value, LevelUnit unit)
+        public Level(T value, LevelUnit unit)
         {
             if(unit == LevelUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -81,14 +77,14 @@ public Level(double value, LevelUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Level(double value, UnitSystem unitSystem)
+        public Level(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -103,19 +99,19 @@ public Level(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Level, which is Decibel. All conversions go via this value.
+        ///     The base unit of <see cref="Level{T}" />, which is Decibel. All conversions go via this value.
         /// </summary>
         public static LevelUnit BaseUnit { get; } = LevelUnit.Decibel;
 
         /// <summary>
-        /// Represents the largest possible value of Level
+        /// Represents the largest possible value of <see cref="Level{T}" />
         /// </summary>
-        public static Level MaxValue { get; } = new Level(double.MaxValue, BaseUnit);
+        public static Level<T> MaxValue { get; } = new Level<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Level
+        /// Represents the smallest possible value of <see cref="Level{T}" />
         /// </summary>
-        public static Level MinValue { get; } = new Level(double.MinValue, BaseUnit);
+        public static Level<T> MinValue { get; } = new Level<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -124,14 +120,14 @@ public Level(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Level;
 
         /// <summary>
-        ///     All units of measurement for the Level quantity.
+        ///     All units of measurement for the <see cref="Level{T}" /> quantity.
         /// </summary>
         public static LevelUnit[] Units { get; } = Enum.GetValues(typeof(LevelUnit)).Cast<LevelUnit>().Except(new LevelUnit[]{ LevelUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Decibel.
         /// </summary>
-        public static Level Zero { get; } = new Level(0, BaseUnit);
+        public static Level<T> Zero { get; } = new Level<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -140,7 +136,9 @@ public Level(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -156,26 +154,26 @@ public Level(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Level.QuantityType;
+        public QuantityType Type => Level<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Level.BaseDimensions;
+        public BaseDimensions Dimensions => Level<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Level in Decibels.
+        ///     Get <see cref="Level{T}" /> in Decibels.
         /// </summary>
-        public double Decibels => As(LevelUnit.Decibel);
+        public T Decibels => As(LevelUnit.Decibel);
 
         /// <summary>
-        ///     Get Level in Nepers.
+        ///     Get <see cref="Level{T}" /> in Nepers.
         /// </summary>
-        public double Nepers => As(LevelUnit.Neper);
+        public T Nepers => As(LevelUnit.Neper);
 
         #endregion
 
@@ -207,33 +205,31 @@ public static string GetAbbreviation(LevelUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Level from Decibels.
+        ///     Get <see cref="Level{T}" /> from Decibels.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Level FromDecibels(QuantityValue decibels)
+        public static Level<T> FromDecibels(T decibels)
         {
-            double value = (double) decibels;
-            return new Level(value, LevelUnit.Decibel);
+            return new Level<T>(decibels, LevelUnit.Decibel);
         }
         /// <summary>
-        ///     Get Level from Nepers.
+        ///     Get <see cref="Level{T}" /> from Nepers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Level FromNepers(QuantityValue nepers)
+        public static Level<T> FromNepers(T nepers)
         {
-            double value = (double) nepers;
-            return new Level(value, LevelUnit.Neper);
+            return new Level<T>(nepers, LevelUnit.Neper);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LevelUnit" /> to <see cref="Level" />.
+        ///     Dynamically convert from value and unit enum <see cref="LevelUnit" /> to <see cref="Level{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Level unit value.</returns>
-        public static Level From(QuantityValue value, LevelUnit fromUnit)
+        /// <returns><see cref="Level{T}" /> unit value.</returns>
+        public static Level<T> From(T value, LevelUnit fromUnit)
         {
-            return new Level((double)value, fromUnit);
+            return new Level<T>(value, fromUnit);
         }
 
         #endregion
@@ -262,7 +258,7 @@ public static Level From(QuantityValue value, LevelUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Level Parse(string str)
+        public static Level<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -290,9 +286,9 @@ public static Level Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Level Parse(string str, IFormatProvider? provider)
+        public static Level<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Level, LevelUnit>(
+            return QuantityParser.Default.Parse<T, Level<T>, LevelUnit>(
                 str,
                 provider,
                 From);
@@ -306,7 +302,7 @@ public static Level Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Level result)
+        public static bool TryParse(string? str, out Level<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -321,9 +317,9 @@ public static bool TryParse(string? str, out Level result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Level result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Level<T> result)
         {
-            return QuantityParser.Default.TryParse<Level, LevelUnit>(
+            return QuantityParser.Default.TryParse<T, Level<T>, LevelUnit>(
                 str,
                 provider,
                 From,
@@ -385,50 +381,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Level
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Level operator -(Level right)
+        public static Level<T> operator -(Level<T> right)
         {
-            return new Level(-right.Value, right.Unit);
+            return new Level<T>(-right.Value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Level"/> from logarithmic addition of two <see cref="Level"/>.</summary>
-        public static Level operator +(Level left, Level right)
+        /// <summary>Get <see cref="Level{T}"/> from logarithmic addition of two <see cref="Level{T}"/>.</summary>
+        public static Level<T> operator +(Level<T> left, Level<T> right)
         {
             // Logarithmic addition
             // Formula: 10*log10(10^(x/10) + 10^(y/10))
-            return new Level(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
+            return new Level<T>(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
         }
 
-        /// <summary>Get <see cref="Level"/> from logarithmic subtraction of two <see cref="Level"/>.</summary>
-        public static Level operator -(Level left, Level right)
+        /// <summary>Get <see cref="Level{T}"/> from logarithmic subtraction of two <see cref="Level{T}"/>.</summary>
+        public static Level<T> operator -(Level<T> left, Level<T> right)
         {
             // Logarithmic subtraction
             // Formula: 10*log10(10^(x/10) - 10^(y/10))
-            return new Level(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
+            return new Level<T>(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
         }
 
-        /// <summary>Get <see cref="Level"/> from logarithmic multiplication of value and <see cref="Level"/>.</summary>
-        public static Level operator *(double left, Level right)
+        /// <summary>Get <see cref="Level{T}"/> from logarithmic multiplication of value and <see cref="Level{T}"/>.</summary>
+        public static Level<T> operator *(double left, Level<T> right)
         {
             // Logarithmic multiplication = addition
-            return new Level(left + right.Value, right.Unit);
+            return new Level<T>(left + right.Value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Level"/> from logarithmic multiplication of value and <see cref="Level"/>.</summary>
-        public static Level operator *(Level left, double right)
+        /// <summary>Get <see cref="Level{T}"/> from logarithmic multiplication of value and <see cref="Level{T}"/>.</summary>
+        public static Level<T> operator *(Level<T> left, double right)
         {
             // Logarithmic multiplication = addition
-            return new Level(left.Value + (double)right, left.Unit);
+            return new Level<T>(left.Value + (double)right, left.Unit);
         }
 
-        /// <summary>Get <see cref="Level"/> from logarithmic division of <see cref="Level"/> by value.</summary>
-        public static Level operator /(Level left, double right)
+        /// <summary>Get <see cref="Level{T}"/> from logarithmic division of <see cref="Level{T}"/> by value.</summary>
+        public static Level<T> operator /(Level<T> left, double right)
         {
             // Logarithmic division = subtraction
-            return new Level(left.Value - (double)right, left.Unit);
+            return new Level<T>(left.Value - (double)right, left.Unit);
         }
 
-        /// <summary>Get ratio value from logarithmic division of <see cref="Level"/> by <see cref="Level"/>.</summary>
-        public static double operator /(Level left, Level right)
+        /// <summary>Get ratio value from logarithmic division of <see cref="Level{T}"/> by <see cref="Level{T}"/>.</summary>
+        public static double operator /(Level<T> left, Level<T> right)
         {
             // Logarithmic division = subtraction
             return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit));
@@ -439,39 +435,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Level
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Level left, Level right)
+        public static bool operator <=(Level<T> left, Level<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Level left, Level right)
+        public static bool operator >=(Level<T> left, Level<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Level left, Level right)
+        public static bool operator <(Level<T> left, Level<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Level left, Level right)
+        public static bool operator >(Level<T> left, Level<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Level, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Level left, Level right)
+        /// <remarks>Consider using <see cref="Equals(Level{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Level<T> left, Level<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Level, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Level left, Level right)
+        /// <remarks>Consider using <see cref="Equals(Level{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Level<T> left, Level<T> right)
         {
             return !(left == right);
         }
@@ -480,37 +476,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Level
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Level objLevel)) throw new ArgumentException("Expected type Level.", nameof(obj));
+            if(!(obj is Level<T> objLevel)) throw new ArgumentException("Expected type Level.", nameof(obj));
 
             return CompareTo(objLevel);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Level other)
+        public int CompareTo(Level<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Level, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Level{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Level objLevel))
+            if(obj is null || !(obj is Level<T> objLevel))
                 return false;
 
             return Equals(objLevel);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Level, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Level other)
+        /// <remarks>Consider using <see cref="Equals(Level{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Level<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Level within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Level{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -548,21 +544,19 @@ public bool Equals(Level other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Level other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Level<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Level.</returns>
+        /// <returns>A hash code for the current <see cref="Level{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -576,17 +570,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LevelUnit unit)
+        public T As(LevelUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -606,17 +600,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LevelUnit unitAsLevelUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LevelUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLevelUnit);
+            var asValue = As(unitAsLevelUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LevelUnit>.As(LevelUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Level to another Level with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Level{T}" /> to another <see cref="Level{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Level with the specified unit.</returns>
-        public Level ToUnit(LevelUnit unit)
+        /// <returns>A <see cref="Level{T}" /> with the specified unit.</returns>
+        public Level<T> ToUnit(LevelUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Level(convertedValue, unit);
+            return new Level<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -629,7 +628,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Level ToUnit(UnitSystem unitSystem)
+        public Level<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -649,20 +648,26 @@ public Level ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LevelUnit> IQuantity<LevelUnit>.ToUnit(LevelUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LevelUnit, T> IQuantityT<LevelUnit, T>.ToUnit(LevelUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LevelUnit> IQuantity<LevelUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LevelUnit, T> IQuantityT<LevelUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LevelUnit.Decibel: return _value;
-                case LevelUnit.Neper: return (1/0.115129254)*_value;
+                case LevelUnit.Decibel: return Value;
+                case LevelUnit.Neper: return (1/0.115129254)*Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -673,16 +678,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Level ToBaseUnit()
+        internal Level<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Level(baseUnitValue, BaseUnit);
+            return new Level<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LevelUnit unit)
+        private T GetValueAs(LevelUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -786,57 +791,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Level)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Level<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Level)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Level<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Level)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Level<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -846,33 +851,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Level))
+            if(conversionType == typeof(Level<T>))
                 return this;
             else if(conversionType == typeof(LevelUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Level.QuantityType;
+                return Level<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Level.Info;
+                return Level<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Level.BaseDimensions;
+                return Level<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Level)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Level<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
index 2c12d61a3d..54e336300c 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     http://en.wikipedia.org/wiki/Linear_density
     /// </remarks>
-    public partial struct LinearDensity : IQuantity<LinearDensityUnit>, IEquatable<LinearDensity>, IComparable, IComparable<LinearDensity>, IConvertible, IFormattable
+    public partial struct LinearDensity<T> : IQuantityT<LinearDensityUnit, T>, IEquatable<LinearDensity<T>>, IComparable, IComparable<LinearDensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -79,12 +75,12 @@ static LinearDensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public LinearDensity(double value, LinearDensityUnit unit)
+        public LinearDensity(T value, LinearDensityUnit unit)
         {
             if(unit == LinearDensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -96,14 +92,14 @@ public LinearDensity(double value, LinearDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LinearDensity(double value, UnitSystem unitSystem)
+        public LinearDensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -118,19 +114,19 @@ public LinearDensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of LinearDensity, which is KilogramPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="LinearDensity{T}" />, which is KilogramPerMeter. All conversions go via this value.
         /// </summary>
         public static LinearDensityUnit BaseUnit { get; } = LinearDensityUnit.KilogramPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of LinearDensity
+        /// Represents the largest possible value of <see cref="LinearDensity{T}" />
         /// </summary>
-        public static LinearDensity MaxValue { get; } = new LinearDensity(double.MaxValue, BaseUnit);
+        public static LinearDensity<T> MaxValue { get; } = new LinearDensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of LinearDensity
+        /// Represents the smallest possible value of <see cref="LinearDensity{T}" />
         /// </summary>
-        public static LinearDensity MinValue { get; } = new LinearDensity(double.MinValue, BaseUnit);
+        public static LinearDensity<T> MinValue { get; } = new LinearDensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -139,14 +135,14 @@ public LinearDensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.LinearDensity;
 
         /// <summary>
-        ///     All units of measurement for the LinearDensity quantity.
+        ///     All units of measurement for the <see cref="LinearDensity{T}" /> quantity.
         /// </summary>
         public static LinearDensityUnit[] Units { get; } = Enum.GetValues(typeof(LinearDensityUnit)).Cast<LinearDensityUnit>().Except(new LinearDensityUnit[]{ LinearDensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramPerMeter.
         /// </summary>
-        public static LinearDensity Zero { get; } = new LinearDensity(0, BaseUnit);
+        public static LinearDensity<T> Zero { get; } = new LinearDensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -155,7 +151,9 @@ public LinearDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -171,86 +169,86 @@ public LinearDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => LinearDensity.QuantityType;
+        public QuantityType Type => LinearDensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => LinearDensity.BaseDimensions;
+        public BaseDimensions Dimensions => LinearDensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get LinearDensity in GramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in GramsPerCentimeter.
         /// </summary>
-        public double GramsPerCentimeter => As(LinearDensityUnit.GramPerCentimeter);
+        public T GramsPerCentimeter => As(LinearDensityUnit.GramPerCentimeter);
 
         /// <summary>
-        ///     Get LinearDensity in GramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> in GramsPerMeter.
         /// </summary>
-        public double GramsPerMeter => As(LinearDensityUnit.GramPerMeter);
+        public T GramsPerMeter => As(LinearDensityUnit.GramPerMeter);
 
         /// <summary>
-        ///     Get LinearDensity in GramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in GramsPerMillimeter.
         /// </summary>
-        public double GramsPerMillimeter => As(LinearDensityUnit.GramPerMillimeter);
+        public T GramsPerMillimeter => As(LinearDensityUnit.GramPerMillimeter);
 
         /// <summary>
-        ///     Get LinearDensity in KilogramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in KilogramsPerCentimeter.
         /// </summary>
-        public double KilogramsPerCentimeter => As(LinearDensityUnit.KilogramPerCentimeter);
+        public T KilogramsPerCentimeter => As(LinearDensityUnit.KilogramPerCentimeter);
 
         /// <summary>
-        ///     Get LinearDensity in KilogramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> in KilogramsPerMeter.
         /// </summary>
-        public double KilogramsPerMeter => As(LinearDensityUnit.KilogramPerMeter);
+        public T KilogramsPerMeter => As(LinearDensityUnit.KilogramPerMeter);
 
         /// <summary>
-        ///     Get LinearDensity in KilogramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in KilogramsPerMillimeter.
         /// </summary>
-        public double KilogramsPerMillimeter => As(LinearDensityUnit.KilogramPerMillimeter);
+        public T KilogramsPerMillimeter => As(LinearDensityUnit.KilogramPerMillimeter);
 
         /// <summary>
-        ///     Get LinearDensity in MicrogramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in MicrogramsPerCentimeter.
         /// </summary>
-        public double MicrogramsPerCentimeter => As(LinearDensityUnit.MicrogramPerCentimeter);
+        public T MicrogramsPerCentimeter => As(LinearDensityUnit.MicrogramPerCentimeter);
 
         /// <summary>
-        ///     Get LinearDensity in MicrogramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> in MicrogramsPerMeter.
         /// </summary>
-        public double MicrogramsPerMeter => As(LinearDensityUnit.MicrogramPerMeter);
+        public T MicrogramsPerMeter => As(LinearDensityUnit.MicrogramPerMeter);
 
         /// <summary>
-        ///     Get LinearDensity in MicrogramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in MicrogramsPerMillimeter.
         /// </summary>
-        public double MicrogramsPerMillimeter => As(LinearDensityUnit.MicrogramPerMillimeter);
+        public T MicrogramsPerMillimeter => As(LinearDensityUnit.MicrogramPerMillimeter);
 
         /// <summary>
-        ///     Get LinearDensity in MilligramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in MilligramsPerCentimeter.
         /// </summary>
-        public double MilligramsPerCentimeter => As(LinearDensityUnit.MilligramPerCentimeter);
+        public T MilligramsPerCentimeter => As(LinearDensityUnit.MilligramPerCentimeter);
 
         /// <summary>
-        ///     Get LinearDensity in MilligramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> in MilligramsPerMeter.
         /// </summary>
-        public double MilligramsPerMeter => As(LinearDensityUnit.MilligramPerMeter);
+        public T MilligramsPerMeter => As(LinearDensityUnit.MilligramPerMeter);
 
         /// <summary>
-        ///     Get LinearDensity in MilligramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> in MilligramsPerMillimeter.
         /// </summary>
-        public double MilligramsPerMillimeter => As(LinearDensityUnit.MilligramPerMillimeter);
+        public T MilligramsPerMillimeter => As(LinearDensityUnit.MilligramPerMillimeter);
 
         /// <summary>
-        ///     Get LinearDensity in PoundsPerFoot.
+        ///     Get <see cref="LinearDensity{T}" /> in PoundsPerFoot.
         /// </summary>
-        public double PoundsPerFoot => As(LinearDensityUnit.PoundPerFoot);
+        public T PoundsPerFoot => As(LinearDensityUnit.PoundPerFoot);
 
         /// <summary>
-        ///     Get LinearDensity in PoundsPerInch.
+        ///     Get <see cref="LinearDensity{T}" /> in PoundsPerInch.
         /// </summary>
-        public double PoundsPerInch => As(LinearDensityUnit.PoundPerInch);
+        public T PoundsPerInch => As(LinearDensityUnit.PoundPerInch);
 
         #endregion
 
@@ -282,141 +280,127 @@ public static string GetAbbreviation(LinearDensityUnit unit, IFormatProvider? pr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get LinearDensity from GramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from GramsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerCentimeter(QuantityValue gramspercentimeter)
+        public static LinearDensity<T> FromGramsPerCentimeter(T gramspercentimeter)
         {
-            double value = (double) gramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter);
+            return new LinearDensity<T>(gramspercentimeter, LinearDensityUnit.GramPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from GramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> from GramsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerMeter(QuantityValue gramspermeter)
+        public static LinearDensity<T> FromGramsPerMeter(T gramspermeter)
         {
-            double value = (double) gramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.GramPerMeter);
+            return new LinearDensity<T>(gramspermeter, LinearDensityUnit.GramPerMeter);
         }
         /// <summary>
-        ///     Get LinearDensity from GramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from GramsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerMillimeter(QuantityValue gramspermillimeter)
+        public static LinearDensity<T> FromGramsPerMillimeter(T gramspermillimeter)
         {
-            double value = (double) gramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter);
+            return new LinearDensity<T>(gramspermillimeter, LinearDensityUnit.GramPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from KilogramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from KilogramsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerCentimeter(QuantityValue kilogramspercentimeter)
+        public static LinearDensity<T> FromKilogramsPerCentimeter(T kilogramspercentimeter)
         {
-            double value = (double) kilogramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter);
+            return new LinearDensity<T>(kilogramspercentimeter, LinearDensityUnit.KilogramPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from KilogramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> from KilogramsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerMeter(QuantityValue kilogramspermeter)
+        public static LinearDensity<T> FromKilogramsPerMeter(T kilogramspermeter)
         {
-            double value = (double) kilogramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter);
+            return new LinearDensity<T>(kilogramspermeter, LinearDensityUnit.KilogramPerMeter);
         }
         /// <summary>
-        ///     Get LinearDensity from KilogramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from KilogramsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerMillimeter(QuantityValue kilogramspermillimeter)
+        public static LinearDensity<T> FromKilogramsPerMillimeter(T kilogramspermillimeter)
         {
-            double value = (double) kilogramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter);
+            return new LinearDensity<T>(kilogramspermillimeter, LinearDensityUnit.KilogramPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from MicrogramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from MicrogramsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerCentimeter(QuantityValue microgramspercentimeter)
+        public static LinearDensity<T> FromMicrogramsPerCentimeter(T microgramspercentimeter)
         {
-            double value = (double) microgramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter);
+            return new LinearDensity<T>(microgramspercentimeter, LinearDensityUnit.MicrogramPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from MicrogramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> from MicrogramsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerMeter(QuantityValue microgramspermeter)
+        public static LinearDensity<T> FromMicrogramsPerMeter(T microgramspermeter)
         {
-            double value = (double) microgramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter);
+            return new LinearDensity<T>(microgramspermeter, LinearDensityUnit.MicrogramPerMeter);
         }
         /// <summary>
-        ///     Get LinearDensity from MicrogramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from MicrogramsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerMillimeter(QuantityValue microgramspermillimeter)
+        public static LinearDensity<T> FromMicrogramsPerMillimeter(T microgramspermillimeter)
         {
-            double value = (double) microgramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter);
+            return new LinearDensity<T>(microgramspermillimeter, LinearDensityUnit.MicrogramPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from MilligramsPerCentimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from MilligramsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerCentimeter(QuantityValue milligramspercentimeter)
+        public static LinearDensity<T> FromMilligramsPerCentimeter(T milligramspercentimeter)
         {
-            double value = (double) milligramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter);
+            return new LinearDensity<T>(milligramspercentimeter, LinearDensityUnit.MilligramPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from MilligramsPerMeter.
+        ///     Get <see cref="LinearDensity{T}" /> from MilligramsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerMeter(QuantityValue milligramspermeter)
+        public static LinearDensity<T> FromMilligramsPerMeter(T milligramspermeter)
         {
-            double value = (double) milligramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter);
+            return new LinearDensity<T>(milligramspermeter, LinearDensityUnit.MilligramPerMeter);
         }
         /// <summary>
-        ///     Get LinearDensity from MilligramsPerMillimeter.
+        ///     Get <see cref="LinearDensity{T}" /> from MilligramsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerMillimeter(QuantityValue milligramspermillimeter)
+        public static LinearDensity<T> FromMilligramsPerMillimeter(T milligramspermillimeter)
         {
-            double value = (double) milligramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter);
+            return new LinearDensity<T>(milligramspermillimeter, LinearDensityUnit.MilligramPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearDensity from PoundsPerFoot.
+        ///     Get <see cref="LinearDensity{T}" /> from PoundsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromPoundsPerFoot(QuantityValue poundsperfoot)
+        public static LinearDensity<T> FromPoundsPerFoot(T poundsperfoot)
         {
-            double value = (double) poundsperfoot;
-            return new LinearDensity(value, LinearDensityUnit.PoundPerFoot);
+            return new LinearDensity<T>(poundsperfoot, LinearDensityUnit.PoundPerFoot);
         }
         /// <summary>
-        ///     Get LinearDensity from PoundsPerInch.
+        ///     Get <see cref="LinearDensity{T}" /> from PoundsPerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromPoundsPerInch(QuantityValue poundsperinch)
+        public static LinearDensity<T> FromPoundsPerInch(T poundsperinch)
         {
-            double value = (double) poundsperinch;
-            return new LinearDensity(value, LinearDensityUnit.PoundPerInch);
+            return new LinearDensity<T>(poundsperinch, LinearDensityUnit.PoundPerInch);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LinearDensityUnit" /> to <see cref="LinearDensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="LinearDensityUnit" /> to <see cref="LinearDensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LinearDensity unit value.</returns>
-        public static LinearDensity From(QuantityValue value, LinearDensityUnit fromUnit)
+        /// <returns><see cref="LinearDensity{T}" /> unit value.</returns>
+        public static LinearDensity<T> From(T value, LinearDensityUnit fromUnit)
         {
-            return new LinearDensity((double)value, fromUnit);
+            return new LinearDensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -445,7 +429,7 @@ public static LinearDensity From(QuantityValue value, LinearDensityUnit fromUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static LinearDensity Parse(string str)
+        public static LinearDensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -473,9 +457,9 @@ public static LinearDensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static LinearDensity Parse(string str, IFormatProvider? provider)
+        public static LinearDensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<LinearDensity, LinearDensityUnit>(
+            return QuantityParser.Default.Parse<T, LinearDensity<T>, LinearDensityUnit>(
                 str,
                 provider,
                 From);
@@ -489,7 +473,7 @@ public static LinearDensity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out LinearDensity result)
+        public static bool TryParse(string? str, out LinearDensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -504,9 +488,9 @@ public static bool TryParse(string? str, out LinearDensity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out LinearDensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out LinearDensity<T> result)
         {
-            return QuantityParser.Default.TryParse<LinearDensity, LinearDensityUnit>(
+            return QuantityParser.Default.TryParse<T, LinearDensity<T>, LinearDensityUnit>(
                 str,
                 provider,
                 From,
@@ -568,45 +552,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Linea
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static LinearDensity operator -(LinearDensity right)
+        public static LinearDensity<T> operator -(LinearDensity<T> right)
         {
-            return new LinearDensity(-right.Value, right.Unit);
+            return new LinearDensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="LinearDensity"/> from adding two <see cref="LinearDensity"/>.</summary>
-        public static LinearDensity operator +(LinearDensity left, LinearDensity right)
+        /// <summary>Get <see cref="LinearDensity{T}"/> from adding two <see cref="LinearDensity{T}"/>.</summary>
+        public static LinearDensity<T> operator +(LinearDensity<T> left, LinearDensity<T> right)
         {
-            return new LinearDensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new LinearDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LinearDensity"/> from subtracting two <see cref="LinearDensity"/>.</summary>
-        public static LinearDensity operator -(LinearDensity left, LinearDensity right)
+        /// <summary>Get <see cref="LinearDensity{T}"/> from subtracting two <see cref="LinearDensity{T}"/>.</summary>
+        public static LinearDensity<T> operator -(LinearDensity<T> left, LinearDensity<T> right)
         {
-            return new LinearDensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new LinearDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LinearDensity"/> from multiplying value and <see cref="LinearDensity"/>.</summary>
-        public static LinearDensity operator *(double left, LinearDensity right)
+        /// <summary>Get <see cref="LinearDensity{T}"/> from multiplying value and <see cref="LinearDensity{T}"/>.</summary>
+        public static LinearDensity<T> operator *(T left, LinearDensity<T> right)
         {
-            return new LinearDensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new LinearDensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="LinearDensity"/> from multiplying value and <see cref="LinearDensity"/>.</summary>
-        public static LinearDensity operator *(LinearDensity left, double right)
+        /// <summary>Get <see cref="LinearDensity{T}"/> from multiplying value and <see cref="LinearDensity{T}"/>.</summary>
+        public static LinearDensity<T> operator *(LinearDensity<T> left, T right)
         {
-            return new LinearDensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new LinearDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LinearDensity"/> from dividing <see cref="LinearDensity"/> by value.</summary>
-        public static LinearDensity operator /(LinearDensity left, double right)
+        /// <summary>Get <see cref="LinearDensity{T}"/> from dividing <see cref="LinearDensity{T}"/> by value.</summary>
+        public static LinearDensity<T> operator /(LinearDensity<T> left, T right)
         {
-            return new LinearDensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new LinearDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="LinearDensity"/> by <see cref="LinearDensity"/>.</summary>
-        public static double operator /(LinearDensity left, LinearDensity right)
+        /// <summary>Get ratio value from dividing <see cref="LinearDensity{T}"/> by <see cref="LinearDensity{T}"/>.</summary>
+        public static T operator /(LinearDensity<T> left, LinearDensity<T> right)
         {
-            return left.KilogramsPerMeter / right.KilogramsPerMeter;
+            return CompiledLambdas.Divide(left.KilogramsPerMeter, right.KilogramsPerMeter);
         }
 
         #endregion
@@ -614,39 +603,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Linea
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(LinearDensity left, LinearDensity right)
+        public static bool operator <=(LinearDensity<T> left, LinearDensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(LinearDensity left, LinearDensity right)
+        public static bool operator >=(LinearDensity<T> left, LinearDensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(LinearDensity left, LinearDensity right)
+        public static bool operator <(LinearDensity<T> left, LinearDensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(LinearDensity left, LinearDensity right)
+        public static bool operator >(LinearDensity<T> left, LinearDensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LinearDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(LinearDensity left, LinearDensity right)
+        /// <remarks>Consider using <see cref="Equals(LinearDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(LinearDensity<T> left, LinearDensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LinearDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(LinearDensity left, LinearDensity right)
+        /// <remarks>Consider using <see cref="Equals(LinearDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(LinearDensity<T> left, LinearDensity<T> right)
         {
             return !(left == right);
         }
@@ -655,37 +644,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Linea
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is LinearDensity objLinearDensity)) throw new ArgumentException("Expected type LinearDensity.", nameof(obj));
+            if(!(obj is LinearDensity<T> objLinearDensity)) throw new ArgumentException("Expected type LinearDensity.", nameof(obj));
 
             return CompareTo(objLinearDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(LinearDensity other)
+        public int CompareTo(LinearDensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LinearDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(LinearDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is LinearDensity objLinearDensity))
+            if(obj is null || !(obj is LinearDensity<T> objLinearDensity))
                 return false;
 
             return Equals(objLinearDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LinearDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(LinearDensity other)
+        /// <remarks>Consider using <see cref="Equals(LinearDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(LinearDensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another LinearDensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="LinearDensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -723,21 +712,19 @@ public bool Equals(LinearDensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(LinearDensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(LinearDensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current LinearDensity.</returns>
+        /// <returns>A hash code for the current <see cref="LinearDensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -751,17 +738,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LinearDensityUnit unit)
+        public T As(LinearDensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -781,17 +768,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LinearDensityUnit unitAsLinearDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearDensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLinearDensityUnit);
+            var asValue = As(unitAsLinearDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LinearDensityUnit>.As(LinearDensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this LinearDensity to another LinearDensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="LinearDensity{T}" /> to another <see cref="LinearDensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A LinearDensity with the specified unit.</returns>
-        public LinearDensity ToUnit(LinearDensityUnit unit)
+        /// <returns>A <see cref="LinearDensity{T}" /> with the specified unit.</returns>
+        public LinearDensity<T> ToUnit(LinearDensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new LinearDensity(convertedValue, unit);
+            return new LinearDensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -804,7 +796,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public LinearDensity ToUnit(UnitSystem unitSystem)
+        public LinearDensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -824,32 +816,38 @@ public LinearDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LinearDensityUnit> IQuantity<LinearDensityUnit>.ToUnit(LinearDensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LinearDensityUnit, T> IQuantityT<LinearDensityUnit, T>.ToUnit(LinearDensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LinearDensityUnit> IQuantity<LinearDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LinearDensityUnit, T> IQuantityT<LinearDensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LinearDensityUnit.GramPerCentimeter: return _value*1e-1;
-                case LinearDensityUnit.GramPerMeter: return _value*1e-3;
-                case LinearDensityUnit.GramPerMillimeter: return _value;
-                case LinearDensityUnit.KilogramPerCentimeter: return (_value*1e-1) * 1e3d;
-                case LinearDensityUnit.KilogramPerMeter: return (_value*1e-3) * 1e3d;
-                case LinearDensityUnit.KilogramPerMillimeter: return (_value) * 1e3d;
-                case LinearDensityUnit.MicrogramPerCentimeter: return (_value*1e-1) * 1e-6d;
-                case LinearDensityUnit.MicrogramPerMeter: return (_value*1e-3) * 1e-6d;
-                case LinearDensityUnit.MicrogramPerMillimeter: return (_value) * 1e-6d;
-                case LinearDensityUnit.MilligramPerCentimeter: return (_value*1e-1) * 1e-3d;
-                case LinearDensityUnit.MilligramPerMeter: return (_value*1e-3) * 1e-3d;
-                case LinearDensityUnit.MilligramPerMillimeter: return (_value) * 1e-3d;
-                case LinearDensityUnit.PoundPerFoot: return _value*1.48816394;
-                case LinearDensityUnit.PoundPerInch: return _value/5.5997415e-2;
+                case LinearDensityUnit.GramPerCentimeter: return Value*1e-1;
+                case LinearDensityUnit.GramPerMeter: return Value*1e-3;
+                case LinearDensityUnit.GramPerMillimeter: return Value;
+                case LinearDensityUnit.KilogramPerCentimeter: return (Value*1e-1) * 1e3d;
+                case LinearDensityUnit.KilogramPerMeter: return (Value*1e-3) * 1e3d;
+                case LinearDensityUnit.KilogramPerMillimeter: return (Value) * 1e3d;
+                case LinearDensityUnit.MicrogramPerCentimeter: return (Value*1e-1) * 1e-6d;
+                case LinearDensityUnit.MicrogramPerMeter: return (Value*1e-3) * 1e-6d;
+                case LinearDensityUnit.MicrogramPerMillimeter: return (Value) * 1e-6d;
+                case LinearDensityUnit.MilligramPerCentimeter: return (Value*1e-1) * 1e-3d;
+                case LinearDensityUnit.MilligramPerMeter: return (Value*1e-3) * 1e-3d;
+                case LinearDensityUnit.MilligramPerMillimeter: return (Value) * 1e-3d;
+                case LinearDensityUnit.PoundPerFoot: return Value*1.48816394;
+                case LinearDensityUnit.PoundPerInch: return Value/5.5997415e-2;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -860,16 +858,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal LinearDensity ToBaseUnit()
+        internal LinearDensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new LinearDensity(baseUnitValue, BaseUnit);
+            return new LinearDensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LinearDensityUnit unit)
+        private T GetValueAs(LinearDensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -985,57 +983,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LinearDensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LinearDensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LinearDensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LinearDensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LinearDensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LinearDensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1045,33 +1043,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(LinearDensity))
+            if(conversionType == typeof(LinearDensity<T>))
                 return this;
             else if(conversionType == typeof(LinearDensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return LinearDensity.QuantityType;
+                return LinearDensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return LinearDensity.Info;
+                return LinearDensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return LinearDensity.BaseDimensions;
+                return LinearDensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(LinearDensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(LinearDensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
index bcc7904b7f..bf32b2e9f0 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     http://en.wikipedia.org/wiki/Linear_density
     /// </remarks>
-    public partial struct LinearPowerDensity : IQuantity<LinearPowerDensityUnit>, IEquatable<LinearPowerDensity>, IComparable, IComparable<LinearPowerDensity>, IConvertible, IFormattable
+    public partial struct LinearPowerDensity<T> : IQuantityT<LinearPowerDensityUnit, T>, IEquatable<LinearPowerDensity<T>>, IComparable, IComparable<LinearPowerDensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -90,12 +86,12 @@ static LinearPowerDensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public LinearPowerDensity(double value, LinearPowerDensityUnit unit)
+        public LinearPowerDensity(T value, LinearPowerDensityUnit unit)
         {
             if(unit == LinearPowerDensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -107,14 +103,14 @@ public LinearPowerDensity(double value, LinearPowerDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LinearPowerDensity(double value, UnitSystem unitSystem)
+        public LinearPowerDensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -129,19 +125,19 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of LinearPowerDensity, which is WattPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="LinearPowerDensity{T}" />, which is WattPerMeter. All conversions go via this value.
         /// </summary>
         public static LinearPowerDensityUnit BaseUnit { get; } = LinearPowerDensityUnit.WattPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of LinearPowerDensity
+        /// Represents the largest possible value of <see cref="LinearPowerDensity{T}" />
         /// </summary>
-        public static LinearPowerDensity MaxValue { get; } = new LinearPowerDensity(double.MaxValue, BaseUnit);
+        public static LinearPowerDensity<T> MaxValue { get; } = new LinearPowerDensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of LinearPowerDensity
+        /// Represents the smallest possible value of <see cref="LinearPowerDensity{T}" />
         /// </summary>
-        public static LinearPowerDensity MinValue { get; } = new LinearPowerDensity(double.MinValue, BaseUnit);
+        public static LinearPowerDensity<T> MinValue { get; } = new LinearPowerDensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -150,14 +146,14 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.LinearPowerDensity;
 
         /// <summary>
-        ///     All units of measurement for the LinearPowerDensity quantity.
+        ///     All units of measurement for the <see cref="LinearPowerDensity{T}" /> quantity.
         /// </summary>
         public static LinearPowerDensityUnit[] Units { get; } = Enum.GetValues(typeof(LinearPowerDensityUnit)).Cast<LinearPowerDensityUnit>().Except(new LinearPowerDensityUnit[]{ LinearPowerDensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit WattPerMeter.
         /// </summary>
-        public static LinearPowerDensity Zero { get; } = new LinearPowerDensity(0, BaseUnit);
+        public static LinearPowerDensity<T> Zero { get; } = new LinearPowerDensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -166,7 +162,9 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -182,141 +180,141 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => LinearPowerDensity.QuantityType;
+        public QuantityType Type => LinearPowerDensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => LinearPowerDensity.BaseDimensions;
+        public BaseDimensions Dimensions => LinearPowerDensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get LinearPowerDensity in GigawattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in GigawattsPerCentimeter.
         /// </summary>
-        public double GigawattsPerCentimeter => As(LinearPowerDensityUnit.GigawattPerCentimeter);
+        public T GigawattsPerCentimeter => As(LinearPowerDensityUnit.GigawattPerCentimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in GigawattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in GigawattsPerFoot.
         /// </summary>
-        public double GigawattsPerFoot => As(LinearPowerDensityUnit.GigawattPerFoot);
+        public T GigawattsPerFoot => As(LinearPowerDensityUnit.GigawattPerFoot);
 
         /// <summary>
-        ///     Get LinearPowerDensity in GigawattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in GigawattsPerInch.
         /// </summary>
-        public double GigawattsPerInch => As(LinearPowerDensityUnit.GigawattPerInch);
+        public T GigawattsPerInch => As(LinearPowerDensityUnit.GigawattPerInch);
 
         /// <summary>
-        ///     Get LinearPowerDensity in GigawattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in GigawattsPerMeter.
         /// </summary>
-        public double GigawattsPerMeter => As(LinearPowerDensityUnit.GigawattPerMeter);
+        public T GigawattsPerMeter => As(LinearPowerDensityUnit.GigawattPerMeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in GigawattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in GigawattsPerMillimeter.
         /// </summary>
-        public double GigawattsPerMillimeter => As(LinearPowerDensityUnit.GigawattPerMillimeter);
+        public T GigawattsPerMillimeter => As(LinearPowerDensityUnit.GigawattPerMillimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in KilowattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in KilowattsPerCentimeter.
         /// </summary>
-        public double KilowattsPerCentimeter => As(LinearPowerDensityUnit.KilowattPerCentimeter);
+        public T KilowattsPerCentimeter => As(LinearPowerDensityUnit.KilowattPerCentimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in KilowattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in KilowattsPerFoot.
         /// </summary>
-        public double KilowattsPerFoot => As(LinearPowerDensityUnit.KilowattPerFoot);
+        public T KilowattsPerFoot => As(LinearPowerDensityUnit.KilowattPerFoot);
 
         /// <summary>
-        ///     Get LinearPowerDensity in KilowattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in KilowattsPerInch.
         /// </summary>
-        public double KilowattsPerInch => As(LinearPowerDensityUnit.KilowattPerInch);
+        public T KilowattsPerInch => As(LinearPowerDensityUnit.KilowattPerInch);
 
         /// <summary>
-        ///     Get LinearPowerDensity in KilowattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in KilowattsPerMeter.
         /// </summary>
-        public double KilowattsPerMeter => As(LinearPowerDensityUnit.KilowattPerMeter);
+        public T KilowattsPerMeter => As(LinearPowerDensityUnit.KilowattPerMeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in KilowattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in KilowattsPerMillimeter.
         /// </summary>
-        public double KilowattsPerMillimeter => As(LinearPowerDensityUnit.KilowattPerMillimeter);
+        public T KilowattsPerMillimeter => As(LinearPowerDensityUnit.KilowattPerMillimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MegawattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MegawattsPerCentimeter.
         /// </summary>
-        public double MegawattsPerCentimeter => As(LinearPowerDensityUnit.MegawattPerCentimeter);
+        public T MegawattsPerCentimeter => As(LinearPowerDensityUnit.MegawattPerCentimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MegawattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MegawattsPerFoot.
         /// </summary>
-        public double MegawattsPerFoot => As(LinearPowerDensityUnit.MegawattPerFoot);
+        public T MegawattsPerFoot => As(LinearPowerDensityUnit.MegawattPerFoot);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MegawattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MegawattsPerInch.
         /// </summary>
-        public double MegawattsPerInch => As(LinearPowerDensityUnit.MegawattPerInch);
+        public T MegawattsPerInch => As(LinearPowerDensityUnit.MegawattPerInch);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MegawattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MegawattsPerMeter.
         /// </summary>
-        public double MegawattsPerMeter => As(LinearPowerDensityUnit.MegawattPerMeter);
+        public T MegawattsPerMeter => As(LinearPowerDensityUnit.MegawattPerMeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MegawattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MegawattsPerMillimeter.
         /// </summary>
-        public double MegawattsPerMillimeter => As(LinearPowerDensityUnit.MegawattPerMillimeter);
+        public T MegawattsPerMillimeter => As(LinearPowerDensityUnit.MegawattPerMillimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MilliwattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MilliwattsPerCentimeter.
         /// </summary>
-        public double MilliwattsPerCentimeter => As(LinearPowerDensityUnit.MilliwattPerCentimeter);
+        public T MilliwattsPerCentimeter => As(LinearPowerDensityUnit.MilliwattPerCentimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MilliwattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MilliwattsPerFoot.
         /// </summary>
-        public double MilliwattsPerFoot => As(LinearPowerDensityUnit.MilliwattPerFoot);
+        public T MilliwattsPerFoot => As(LinearPowerDensityUnit.MilliwattPerFoot);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MilliwattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MilliwattsPerInch.
         /// </summary>
-        public double MilliwattsPerInch => As(LinearPowerDensityUnit.MilliwattPerInch);
+        public T MilliwattsPerInch => As(LinearPowerDensityUnit.MilliwattPerInch);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MilliwattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MilliwattsPerMeter.
         /// </summary>
-        public double MilliwattsPerMeter => As(LinearPowerDensityUnit.MilliwattPerMeter);
+        public T MilliwattsPerMeter => As(LinearPowerDensityUnit.MilliwattPerMeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in MilliwattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in MilliwattsPerMillimeter.
         /// </summary>
-        public double MilliwattsPerMillimeter => As(LinearPowerDensityUnit.MilliwattPerMillimeter);
+        public T MilliwattsPerMillimeter => As(LinearPowerDensityUnit.MilliwattPerMillimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in WattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in WattsPerCentimeter.
         /// </summary>
-        public double WattsPerCentimeter => As(LinearPowerDensityUnit.WattPerCentimeter);
+        public T WattsPerCentimeter => As(LinearPowerDensityUnit.WattPerCentimeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in WattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in WattsPerFoot.
         /// </summary>
-        public double WattsPerFoot => As(LinearPowerDensityUnit.WattPerFoot);
+        public T WattsPerFoot => As(LinearPowerDensityUnit.WattPerFoot);
 
         /// <summary>
-        ///     Get LinearPowerDensity in WattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in WattsPerInch.
         /// </summary>
-        public double WattsPerInch => As(LinearPowerDensityUnit.WattPerInch);
+        public T WattsPerInch => As(LinearPowerDensityUnit.WattPerInch);
 
         /// <summary>
-        ///     Get LinearPowerDensity in WattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in WattsPerMeter.
         /// </summary>
-        public double WattsPerMeter => As(LinearPowerDensityUnit.WattPerMeter);
+        public T WattsPerMeter => As(LinearPowerDensityUnit.WattPerMeter);
 
         /// <summary>
-        ///     Get LinearPowerDensity in WattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> in WattsPerMillimeter.
         /// </summary>
-        public double WattsPerMillimeter => As(LinearPowerDensityUnit.WattPerMillimeter);
+        public T WattsPerMillimeter => As(LinearPowerDensityUnit.WattPerMillimeter);
 
         #endregion
 
@@ -348,240 +346,215 @@ public static string GetAbbreviation(LinearPowerDensityUnit unit, IFormatProvide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get LinearPowerDensity from GigawattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from GigawattsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerCentimeter(QuantityValue gigawattspercentimeter)
+        public static LinearPowerDensity<T> FromGigawattsPerCentimeter(T gigawattspercentimeter)
         {
-            double value = (double) gigawattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter);
+            return new LinearPowerDensity<T>(gigawattspercentimeter, LinearPowerDensityUnit.GigawattPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from GigawattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from GigawattsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerFoot(QuantityValue gigawattsperfoot)
+        public static LinearPowerDensity<T> FromGigawattsPerFoot(T gigawattsperfoot)
         {
-            double value = (double) gigawattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot);
+            return new LinearPowerDensity<T>(gigawattsperfoot, LinearPowerDensityUnit.GigawattPerFoot);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from GigawattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from GigawattsPerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerInch(QuantityValue gigawattsperinch)
+        public static LinearPowerDensity<T> FromGigawattsPerInch(T gigawattsperinch)
         {
-            double value = (double) gigawattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch);
+            return new LinearPowerDensity<T>(gigawattsperinch, LinearPowerDensityUnit.GigawattPerInch);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from GigawattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from GigawattsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerMeter(QuantityValue gigawattspermeter)
+        public static LinearPowerDensity<T> FromGigawattsPerMeter(T gigawattspermeter)
         {
-            double value = (double) gigawattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter);
+            return new LinearPowerDensity<T>(gigawattspermeter, LinearPowerDensityUnit.GigawattPerMeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from GigawattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from GigawattsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerMillimeter(QuantityValue gigawattspermillimeter)
+        public static LinearPowerDensity<T> FromGigawattsPerMillimeter(T gigawattspermillimeter)
         {
-            double value = (double) gigawattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter);
+            return new LinearPowerDensity<T>(gigawattspermillimeter, LinearPowerDensityUnit.GigawattPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from KilowattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from KilowattsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerCentimeter(QuantityValue kilowattspercentimeter)
+        public static LinearPowerDensity<T> FromKilowattsPerCentimeter(T kilowattspercentimeter)
         {
-            double value = (double) kilowattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter);
+            return new LinearPowerDensity<T>(kilowattspercentimeter, LinearPowerDensityUnit.KilowattPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from KilowattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from KilowattsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerFoot(QuantityValue kilowattsperfoot)
+        public static LinearPowerDensity<T> FromKilowattsPerFoot(T kilowattsperfoot)
         {
-            double value = (double) kilowattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot);
+            return new LinearPowerDensity<T>(kilowattsperfoot, LinearPowerDensityUnit.KilowattPerFoot);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from KilowattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from KilowattsPerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerInch(QuantityValue kilowattsperinch)
+        public static LinearPowerDensity<T> FromKilowattsPerInch(T kilowattsperinch)
         {
-            double value = (double) kilowattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch);
+            return new LinearPowerDensity<T>(kilowattsperinch, LinearPowerDensityUnit.KilowattPerInch);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from KilowattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from KilowattsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerMeter(QuantityValue kilowattspermeter)
+        public static LinearPowerDensity<T> FromKilowattsPerMeter(T kilowattspermeter)
         {
-            double value = (double) kilowattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter);
+            return new LinearPowerDensity<T>(kilowattspermeter, LinearPowerDensityUnit.KilowattPerMeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from KilowattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from KilowattsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerMillimeter(QuantityValue kilowattspermillimeter)
+        public static LinearPowerDensity<T> FromKilowattsPerMillimeter(T kilowattspermillimeter)
         {
-            double value = (double) kilowattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter);
+            return new LinearPowerDensity<T>(kilowattspermillimeter, LinearPowerDensityUnit.KilowattPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MegawattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MegawattsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerCentimeter(QuantityValue megawattspercentimeter)
+        public static LinearPowerDensity<T> FromMegawattsPerCentimeter(T megawattspercentimeter)
         {
-            double value = (double) megawattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter);
+            return new LinearPowerDensity<T>(megawattspercentimeter, LinearPowerDensityUnit.MegawattPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MegawattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MegawattsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerFoot(QuantityValue megawattsperfoot)
+        public static LinearPowerDensity<T> FromMegawattsPerFoot(T megawattsperfoot)
         {
-            double value = (double) megawattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot);
+            return new LinearPowerDensity<T>(megawattsperfoot, LinearPowerDensityUnit.MegawattPerFoot);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MegawattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MegawattsPerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerInch(QuantityValue megawattsperinch)
+        public static LinearPowerDensity<T> FromMegawattsPerInch(T megawattsperinch)
         {
-            double value = (double) megawattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch);
+            return new LinearPowerDensity<T>(megawattsperinch, LinearPowerDensityUnit.MegawattPerInch);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MegawattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MegawattsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerMeter(QuantityValue megawattspermeter)
+        public static LinearPowerDensity<T> FromMegawattsPerMeter(T megawattspermeter)
         {
-            double value = (double) megawattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter);
+            return new LinearPowerDensity<T>(megawattspermeter, LinearPowerDensityUnit.MegawattPerMeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MegawattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MegawattsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerMillimeter(QuantityValue megawattspermillimeter)
+        public static LinearPowerDensity<T> FromMegawattsPerMillimeter(T megawattspermillimeter)
         {
-            double value = (double) megawattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter);
+            return new LinearPowerDensity<T>(megawattspermillimeter, LinearPowerDensityUnit.MegawattPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MilliwattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MilliwattsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerCentimeter(QuantityValue milliwattspercentimeter)
+        public static LinearPowerDensity<T> FromMilliwattsPerCentimeter(T milliwattspercentimeter)
         {
-            double value = (double) milliwattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter);
+            return new LinearPowerDensity<T>(milliwattspercentimeter, LinearPowerDensityUnit.MilliwattPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MilliwattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MilliwattsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerFoot(QuantityValue milliwattsperfoot)
+        public static LinearPowerDensity<T> FromMilliwattsPerFoot(T milliwattsperfoot)
         {
-            double value = (double) milliwattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot);
+            return new LinearPowerDensity<T>(milliwattsperfoot, LinearPowerDensityUnit.MilliwattPerFoot);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MilliwattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MilliwattsPerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerInch(QuantityValue milliwattsperinch)
+        public static LinearPowerDensity<T> FromMilliwattsPerInch(T milliwattsperinch)
         {
-            double value = (double) milliwattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch);
+            return new LinearPowerDensity<T>(milliwattsperinch, LinearPowerDensityUnit.MilliwattPerInch);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MilliwattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MilliwattsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerMeter(QuantityValue milliwattspermeter)
+        public static LinearPowerDensity<T> FromMilliwattsPerMeter(T milliwattspermeter)
         {
-            double value = (double) milliwattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter);
+            return new LinearPowerDensity<T>(milliwattspermeter, LinearPowerDensityUnit.MilliwattPerMeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from MilliwattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from MilliwattsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerMillimeter(QuantityValue milliwattspermillimeter)
+        public static LinearPowerDensity<T> FromMilliwattsPerMillimeter(T milliwattspermillimeter)
         {
-            double value = (double) milliwattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter);
+            return new LinearPowerDensity<T>(milliwattspermillimeter, LinearPowerDensityUnit.MilliwattPerMillimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from WattsPerCentimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from WattsPerCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerCentimeter(QuantityValue wattspercentimeter)
+        public static LinearPowerDensity<T> FromWattsPerCentimeter(T wattspercentimeter)
         {
-            double value = (double) wattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter);
+            return new LinearPowerDensity<T>(wattspercentimeter, LinearPowerDensityUnit.WattPerCentimeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from WattsPerFoot.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from WattsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerFoot(QuantityValue wattsperfoot)
+        public static LinearPowerDensity<T> FromWattsPerFoot(T wattsperfoot)
         {
-            double value = (double) wattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot);
+            return new LinearPowerDensity<T>(wattsperfoot, LinearPowerDensityUnit.WattPerFoot);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from WattsPerInch.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from WattsPerInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerInch(QuantityValue wattsperinch)
+        public static LinearPowerDensity<T> FromWattsPerInch(T wattsperinch)
         {
-            double value = (double) wattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch);
+            return new LinearPowerDensity<T>(wattsperinch, LinearPowerDensityUnit.WattPerInch);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from WattsPerMeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from WattsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerMeter(QuantityValue wattspermeter)
+        public static LinearPowerDensity<T> FromWattsPerMeter(T wattspermeter)
         {
-            double value = (double) wattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter);
+            return new LinearPowerDensity<T>(wattspermeter, LinearPowerDensityUnit.WattPerMeter);
         }
         /// <summary>
-        ///     Get LinearPowerDensity from WattsPerMillimeter.
+        ///     Get <see cref="LinearPowerDensity{T}" /> from WattsPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerMillimeter(QuantityValue wattspermillimeter)
+        public static LinearPowerDensity<T> FromWattsPerMillimeter(T wattspermillimeter)
         {
-            double value = (double) wattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter);
+            return new LinearPowerDensity<T>(wattspermillimeter, LinearPowerDensityUnit.WattPerMillimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LinearPowerDensityUnit" /> to <see cref="LinearPowerDensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="LinearPowerDensityUnit" /> to <see cref="LinearPowerDensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LinearPowerDensity unit value.</returns>
-        public static LinearPowerDensity From(QuantityValue value, LinearPowerDensityUnit fromUnit)
+        /// <returns><see cref="LinearPowerDensity{T}" /> unit value.</returns>
+        public static LinearPowerDensity<T> From(T value, LinearPowerDensityUnit fromUnit)
         {
-            return new LinearPowerDensity((double)value, fromUnit);
+            return new LinearPowerDensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -610,7 +583,7 @@ public static LinearPowerDensity From(QuantityValue value, LinearPowerDensityUni
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static LinearPowerDensity Parse(string str)
+        public static LinearPowerDensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -638,9 +611,9 @@ public static LinearPowerDensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static LinearPowerDensity Parse(string str, IFormatProvider? provider)
+        public static LinearPowerDensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<LinearPowerDensity, LinearPowerDensityUnit>(
+            return QuantityParser.Default.Parse<T, LinearPowerDensity<T>, LinearPowerDensityUnit>(
                 str,
                 provider,
                 From);
@@ -654,7 +627,7 @@ public static LinearPowerDensity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out LinearPowerDensity result)
+        public static bool TryParse(string? str, out LinearPowerDensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -669,9 +642,9 @@ public static bool TryParse(string? str, out LinearPowerDensity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out LinearPowerDensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out LinearPowerDensity<T> result)
         {
-            return QuantityParser.Default.TryParse<LinearPowerDensity, LinearPowerDensityUnit>(
+            return QuantityParser.Default.TryParse<T, LinearPowerDensity<T>, LinearPowerDensityUnit>(
                 str,
                 provider,
                 From,
@@ -733,45 +706,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Linea
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static LinearPowerDensity operator -(LinearPowerDensity right)
+        public static LinearPowerDensity<T> operator -(LinearPowerDensity<T> right)
         {
-            return new LinearPowerDensity(-right.Value, right.Unit);
+            return new LinearPowerDensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="LinearPowerDensity"/> from adding two <see cref="LinearPowerDensity"/>.</summary>
-        public static LinearPowerDensity operator +(LinearPowerDensity left, LinearPowerDensity right)
+        /// <summary>Get <see cref="LinearPowerDensity{T}"/> from adding two <see cref="LinearPowerDensity{T}"/>.</summary>
+        public static LinearPowerDensity<T> operator +(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
-            return new LinearPowerDensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new LinearPowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LinearPowerDensity"/> from subtracting two <see cref="LinearPowerDensity"/>.</summary>
-        public static LinearPowerDensity operator -(LinearPowerDensity left, LinearPowerDensity right)
+        /// <summary>Get <see cref="LinearPowerDensity{T}"/> from subtracting two <see cref="LinearPowerDensity{T}"/>.</summary>
+        public static LinearPowerDensity<T> operator -(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
-            return new LinearPowerDensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new LinearPowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LinearPowerDensity"/> from multiplying value and <see cref="LinearPowerDensity"/>.</summary>
-        public static LinearPowerDensity operator *(double left, LinearPowerDensity right)
+        /// <summary>Get <see cref="LinearPowerDensity{T}"/> from multiplying value and <see cref="LinearPowerDensity{T}"/>.</summary>
+        public static LinearPowerDensity<T> operator *(T left, LinearPowerDensity<T> right)
         {
-            return new LinearPowerDensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new LinearPowerDensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="LinearPowerDensity"/> from multiplying value and <see cref="LinearPowerDensity"/>.</summary>
-        public static LinearPowerDensity operator *(LinearPowerDensity left, double right)
+        /// <summary>Get <see cref="LinearPowerDensity{T}"/> from multiplying value and <see cref="LinearPowerDensity{T}"/>.</summary>
+        public static LinearPowerDensity<T> operator *(LinearPowerDensity<T> left, T right)
         {
-            return new LinearPowerDensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new LinearPowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LinearPowerDensity"/> from dividing <see cref="LinearPowerDensity"/> by value.</summary>
-        public static LinearPowerDensity operator /(LinearPowerDensity left, double right)
+        /// <summary>Get <see cref="LinearPowerDensity{T}"/> from dividing <see cref="LinearPowerDensity{T}"/> by value.</summary>
+        public static LinearPowerDensity<T> operator /(LinearPowerDensity<T> left, T right)
         {
-            return new LinearPowerDensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new LinearPowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="LinearPowerDensity"/> by <see cref="LinearPowerDensity"/>.</summary>
-        public static double operator /(LinearPowerDensity left, LinearPowerDensity right)
+        /// <summary>Get ratio value from dividing <see cref="LinearPowerDensity{T}"/> by <see cref="LinearPowerDensity{T}"/>.</summary>
+        public static T operator /(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
-            return left.WattsPerMeter / right.WattsPerMeter;
+            return CompiledLambdas.Divide(left.WattsPerMeter, right.WattsPerMeter);
         }
 
         #endregion
@@ -779,39 +757,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Linea
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(LinearPowerDensity left, LinearPowerDensity right)
+        public static bool operator <=(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(LinearPowerDensity left, LinearPowerDensity right)
+        public static bool operator >=(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(LinearPowerDensity left, LinearPowerDensity right)
+        public static bool operator <(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(LinearPowerDensity left, LinearPowerDensity right)
+        public static bool operator >(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(LinearPowerDensity left, LinearPowerDensity right)
+        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(LinearPowerDensity left, LinearPowerDensity right)
+        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(LinearPowerDensity<T> left, LinearPowerDensity<T> right)
         {
             return !(left == right);
         }
@@ -820,37 +798,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Linea
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is LinearPowerDensity objLinearPowerDensity)) throw new ArgumentException("Expected type LinearPowerDensity.", nameof(obj));
+            if(!(obj is LinearPowerDensity<T> objLinearPowerDensity)) throw new ArgumentException("Expected type LinearPowerDensity.", nameof(obj));
 
             return CompareTo(objLinearPowerDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(LinearPowerDensity other)
+        public int CompareTo(LinearPowerDensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is LinearPowerDensity objLinearPowerDensity))
+            if(obj is null || !(obj is LinearPowerDensity<T> objLinearPowerDensity))
                 return false;
 
             return Equals(objLinearPowerDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(LinearPowerDensity other)
+        /// <remarks>Consider using <see cref="Equals(LinearPowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(LinearPowerDensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another LinearPowerDensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="LinearPowerDensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -888,21 +866,19 @@ public bool Equals(LinearPowerDensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(LinearPowerDensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(LinearPowerDensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current LinearPowerDensity.</returns>
+        /// <returns>A hash code for the current <see cref="LinearPowerDensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -916,17 +892,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LinearPowerDensityUnit unit)
+        public T As(LinearPowerDensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -946,17 +922,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LinearPowerDensityUnit unitAsLinearPowerDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLinearPowerDensityUnit);
+            var asValue = As(unitAsLinearPowerDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LinearPowerDensityUnit>.As(LinearPowerDensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this LinearPowerDensity to another LinearPowerDensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="LinearPowerDensity{T}" /> to another <see cref="LinearPowerDensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A LinearPowerDensity with the specified unit.</returns>
-        public LinearPowerDensity ToUnit(LinearPowerDensityUnit unit)
+        /// <returns>A <see cref="LinearPowerDensity{T}" /> with the specified unit.</returns>
+        public LinearPowerDensity<T> ToUnit(LinearPowerDensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new LinearPowerDensity(convertedValue, unit);
+            return new LinearPowerDensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -969,7 +950,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public LinearPowerDensity ToUnit(UnitSystem unitSystem)
+        public LinearPowerDensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -989,43 +970,49 @@ public LinearPowerDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LinearPowerDensityUnit> IQuantity<LinearPowerDensityUnit>.ToUnit(LinearPowerDensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LinearPowerDensityUnit, T> IQuantityT<LinearPowerDensityUnit, T>.ToUnit(LinearPowerDensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LinearPowerDensityUnit> IQuantity<LinearPowerDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LinearPowerDensityUnit, T> IQuantityT<LinearPowerDensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LinearPowerDensityUnit.GigawattPerCentimeter: return (_value*1e2) * 1e9d;
-                case LinearPowerDensityUnit.GigawattPerFoot: return (_value*3.280839895) * 1e9d;
-                case LinearPowerDensityUnit.GigawattPerInch: return (_value*39.37007874) * 1e9d;
-                case LinearPowerDensityUnit.GigawattPerMeter: return (_value) * 1e9d;
-                case LinearPowerDensityUnit.GigawattPerMillimeter: return (_value*1e3) * 1e9d;
-                case LinearPowerDensityUnit.KilowattPerCentimeter: return (_value*1e2) * 1e3d;
-                case LinearPowerDensityUnit.KilowattPerFoot: return (_value*3.280839895) * 1e3d;
-                case LinearPowerDensityUnit.KilowattPerInch: return (_value*39.37007874) * 1e3d;
-                case LinearPowerDensityUnit.KilowattPerMeter: return (_value) * 1e3d;
-                case LinearPowerDensityUnit.KilowattPerMillimeter: return (_value*1e3) * 1e3d;
-                case LinearPowerDensityUnit.MegawattPerCentimeter: return (_value*1e2) * 1e6d;
-                case LinearPowerDensityUnit.MegawattPerFoot: return (_value*3.280839895) * 1e6d;
-                case LinearPowerDensityUnit.MegawattPerInch: return (_value*39.37007874) * 1e6d;
-                case LinearPowerDensityUnit.MegawattPerMeter: return (_value) * 1e6d;
-                case LinearPowerDensityUnit.MegawattPerMillimeter: return (_value*1e3) * 1e6d;
-                case LinearPowerDensityUnit.MilliwattPerCentimeter: return (_value*1e2) * 1e-3d;
-                case LinearPowerDensityUnit.MilliwattPerFoot: return (_value*3.280839895) * 1e-3d;
-                case LinearPowerDensityUnit.MilliwattPerInch: return (_value*39.37007874) * 1e-3d;
-                case LinearPowerDensityUnit.MilliwattPerMeter: return (_value) * 1e-3d;
-                case LinearPowerDensityUnit.MilliwattPerMillimeter: return (_value*1e3) * 1e-3d;
-                case LinearPowerDensityUnit.WattPerCentimeter: return _value*1e2;
-                case LinearPowerDensityUnit.WattPerFoot: return _value*3.280839895;
-                case LinearPowerDensityUnit.WattPerInch: return _value*39.37007874;
-                case LinearPowerDensityUnit.WattPerMeter: return _value;
-                case LinearPowerDensityUnit.WattPerMillimeter: return _value*1e3;
+                case LinearPowerDensityUnit.GigawattPerCentimeter: return (Value*1e2) * 1e9d;
+                case LinearPowerDensityUnit.GigawattPerFoot: return (Value*3.280839895) * 1e9d;
+                case LinearPowerDensityUnit.GigawattPerInch: return (Value*39.37007874) * 1e9d;
+                case LinearPowerDensityUnit.GigawattPerMeter: return (Value) * 1e9d;
+                case LinearPowerDensityUnit.GigawattPerMillimeter: return (Value*1e3) * 1e9d;
+                case LinearPowerDensityUnit.KilowattPerCentimeter: return (Value*1e2) * 1e3d;
+                case LinearPowerDensityUnit.KilowattPerFoot: return (Value*3.280839895) * 1e3d;
+                case LinearPowerDensityUnit.KilowattPerInch: return (Value*39.37007874) * 1e3d;
+                case LinearPowerDensityUnit.KilowattPerMeter: return (Value) * 1e3d;
+                case LinearPowerDensityUnit.KilowattPerMillimeter: return (Value*1e3) * 1e3d;
+                case LinearPowerDensityUnit.MegawattPerCentimeter: return (Value*1e2) * 1e6d;
+                case LinearPowerDensityUnit.MegawattPerFoot: return (Value*3.280839895) * 1e6d;
+                case LinearPowerDensityUnit.MegawattPerInch: return (Value*39.37007874) * 1e6d;
+                case LinearPowerDensityUnit.MegawattPerMeter: return (Value) * 1e6d;
+                case LinearPowerDensityUnit.MegawattPerMillimeter: return (Value*1e3) * 1e6d;
+                case LinearPowerDensityUnit.MilliwattPerCentimeter: return (Value*1e2) * 1e-3d;
+                case LinearPowerDensityUnit.MilliwattPerFoot: return (Value*3.280839895) * 1e-3d;
+                case LinearPowerDensityUnit.MilliwattPerInch: return (Value*39.37007874) * 1e-3d;
+                case LinearPowerDensityUnit.MilliwattPerMeter: return (Value) * 1e-3d;
+                case LinearPowerDensityUnit.MilliwattPerMillimeter: return (Value*1e3) * 1e-3d;
+                case LinearPowerDensityUnit.WattPerCentimeter: return Value*1e2;
+                case LinearPowerDensityUnit.WattPerFoot: return Value*3.280839895;
+                case LinearPowerDensityUnit.WattPerInch: return Value*39.37007874;
+                case LinearPowerDensityUnit.WattPerMeter: return Value;
+                case LinearPowerDensityUnit.WattPerMillimeter: return Value*1e3;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1036,16 +1023,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal LinearPowerDensity ToBaseUnit()
+        internal LinearPowerDensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new LinearPowerDensity(baseUnitValue, BaseUnit);
+            return new LinearPowerDensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LinearPowerDensityUnit unit)
+        private T GetValueAs(LinearPowerDensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1172,57 +1159,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LinearPowerDensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LinearPowerDensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LinearPowerDensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1232,33 +1219,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(LinearPowerDensity))
+            if(conversionType == typeof(LinearPowerDensity<T>))
                 return this;
             else if(conversionType == typeof(LinearPowerDensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return LinearPowerDensity.QuantityType;
+                return LinearPowerDensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return LinearPowerDensity.Info;
+                return LinearPowerDensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return LinearPowerDensity.BaseDimensions;
+                return LinearPowerDensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(LinearPowerDensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
index c4475ff4b2..425e2bdb86 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Luminosity
     /// </remarks>
-    public partial struct Luminosity : IQuantity<LuminosityUnit>, IEquatable<Luminosity>, IComparable, IComparable<Luminosity>, IConvertible, IFormattable
+    public partial struct Luminosity<T> : IQuantityT<LuminosityUnit, T>, IEquatable<Luminosity<T>>, IComparable, IComparable<Luminosity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -79,12 +75,12 @@ static Luminosity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Luminosity(double value, LuminosityUnit unit)
+        public Luminosity(T value, LuminosityUnit unit)
         {
             if(unit == LuminosityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -96,14 +92,14 @@ public Luminosity(double value, LuminosityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Luminosity(double value, UnitSystem unitSystem)
+        public Luminosity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -118,19 +114,19 @@ public Luminosity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Luminosity, which is Watt. All conversions go via this value.
+        ///     The base unit of <see cref="Luminosity{T}" />, which is Watt. All conversions go via this value.
         /// </summary>
         public static LuminosityUnit BaseUnit { get; } = LuminosityUnit.Watt;
 
         /// <summary>
-        /// Represents the largest possible value of Luminosity
+        /// Represents the largest possible value of <see cref="Luminosity{T}" />
         /// </summary>
-        public static Luminosity MaxValue { get; } = new Luminosity(double.MaxValue, BaseUnit);
+        public static Luminosity<T> MaxValue { get; } = new Luminosity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Luminosity
+        /// Represents the smallest possible value of <see cref="Luminosity{T}" />
         /// </summary>
-        public static Luminosity MinValue { get; } = new Luminosity(double.MinValue, BaseUnit);
+        public static Luminosity<T> MinValue { get; } = new Luminosity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -139,14 +135,14 @@ public Luminosity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Luminosity;
 
         /// <summary>
-        ///     All units of measurement for the Luminosity quantity.
+        ///     All units of measurement for the <see cref="Luminosity{T}" /> quantity.
         /// </summary>
         public static LuminosityUnit[] Units { get; } = Enum.GetValues(typeof(LuminosityUnit)).Cast<LuminosityUnit>().Except(new LuminosityUnit[]{ LuminosityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Watt.
         /// </summary>
-        public static Luminosity Zero { get; } = new Luminosity(0, BaseUnit);
+        public static Luminosity<T> Zero { get; } = new Luminosity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -155,7 +151,9 @@ public Luminosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -171,86 +169,86 @@ public Luminosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Luminosity.QuantityType;
+        public QuantityType Type => Luminosity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Luminosity.BaseDimensions;
+        public BaseDimensions Dimensions => Luminosity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Luminosity in Decawatts.
+        ///     Get <see cref="Luminosity{T}" /> in Decawatts.
         /// </summary>
-        public double Decawatts => As(LuminosityUnit.Decawatt);
+        public T Decawatts => As(LuminosityUnit.Decawatt);
 
         /// <summary>
-        ///     Get Luminosity in Deciwatts.
+        ///     Get <see cref="Luminosity{T}" /> in Deciwatts.
         /// </summary>
-        public double Deciwatts => As(LuminosityUnit.Deciwatt);
+        public T Deciwatts => As(LuminosityUnit.Deciwatt);
 
         /// <summary>
-        ///     Get Luminosity in Femtowatts.
+        ///     Get <see cref="Luminosity{T}" /> in Femtowatts.
         /// </summary>
-        public double Femtowatts => As(LuminosityUnit.Femtowatt);
+        public T Femtowatts => As(LuminosityUnit.Femtowatt);
 
         /// <summary>
-        ///     Get Luminosity in Gigawatts.
+        ///     Get <see cref="Luminosity{T}" /> in Gigawatts.
         /// </summary>
-        public double Gigawatts => As(LuminosityUnit.Gigawatt);
+        public T Gigawatts => As(LuminosityUnit.Gigawatt);
 
         /// <summary>
-        ///     Get Luminosity in Kilowatts.
+        ///     Get <see cref="Luminosity{T}" /> in Kilowatts.
         /// </summary>
-        public double Kilowatts => As(LuminosityUnit.Kilowatt);
+        public T Kilowatts => As(LuminosityUnit.Kilowatt);
 
         /// <summary>
-        ///     Get Luminosity in Megawatts.
+        ///     Get <see cref="Luminosity{T}" /> in Megawatts.
         /// </summary>
-        public double Megawatts => As(LuminosityUnit.Megawatt);
+        public T Megawatts => As(LuminosityUnit.Megawatt);
 
         /// <summary>
-        ///     Get Luminosity in Microwatts.
+        ///     Get <see cref="Luminosity{T}" /> in Microwatts.
         /// </summary>
-        public double Microwatts => As(LuminosityUnit.Microwatt);
+        public T Microwatts => As(LuminosityUnit.Microwatt);
 
         /// <summary>
-        ///     Get Luminosity in Milliwatts.
+        ///     Get <see cref="Luminosity{T}" /> in Milliwatts.
         /// </summary>
-        public double Milliwatts => As(LuminosityUnit.Milliwatt);
+        public T Milliwatts => As(LuminosityUnit.Milliwatt);
 
         /// <summary>
-        ///     Get Luminosity in Nanowatts.
+        ///     Get <see cref="Luminosity{T}" /> in Nanowatts.
         /// </summary>
-        public double Nanowatts => As(LuminosityUnit.Nanowatt);
+        public T Nanowatts => As(LuminosityUnit.Nanowatt);
 
         /// <summary>
-        ///     Get Luminosity in Petawatts.
+        ///     Get <see cref="Luminosity{T}" /> in Petawatts.
         /// </summary>
-        public double Petawatts => As(LuminosityUnit.Petawatt);
+        public T Petawatts => As(LuminosityUnit.Petawatt);
 
         /// <summary>
-        ///     Get Luminosity in Picowatts.
+        ///     Get <see cref="Luminosity{T}" /> in Picowatts.
         /// </summary>
-        public double Picowatts => As(LuminosityUnit.Picowatt);
+        public T Picowatts => As(LuminosityUnit.Picowatt);
 
         /// <summary>
-        ///     Get Luminosity in SolarLuminosities.
+        ///     Get <see cref="Luminosity{T}" /> in SolarLuminosities.
         /// </summary>
-        public double SolarLuminosities => As(LuminosityUnit.SolarLuminosity);
+        public T SolarLuminosities => As(LuminosityUnit.SolarLuminosity);
 
         /// <summary>
-        ///     Get Luminosity in Terawatts.
+        ///     Get <see cref="Luminosity{T}" /> in Terawatts.
         /// </summary>
-        public double Terawatts => As(LuminosityUnit.Terawatt);
+        public T Terawatts => As(LuminosityUnit.Terawatt);
 
         /// <summary>
-        ///     Get Luminosity in Watts.
+        ///     Get <see cref="Luminosity{T}" /> in Watts.
         /// </summary>
-        public double Watts => As(LuminosityUnit.Watt);
+        public T Watts => As(LuminosityUnit.Watt);
 
         #endregion
 
@@ -282,141 +280,127 @@ public static string GetAbbreviation(LuminosityUnit unit, IFormatProvider? provi
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Luminosity from Decawatts.
+        ///     Get <see cref="Luminosity{T}" /> from Decawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromDecawatts(QuantityValue decawatts)
+        public static Luminosity<T> FromDecawatts(T decawatts)
         {
-            double value = (double) decawatts;
-            return new Luminosity(value, LuminosityUnit.Decawatt);
+            return new Luminosity<T>(decawatts, LuminosityUnit.Decawatt);
         }
         /// <summary>
-        ///     Get Luminosity from Deciwatts.
+        ///     Get <see cref="Luminosity{T}" /> from Deciwatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromDeciwatts(QuantityValue deciwatts)
+        public static Luminosity<T> FromDeciwatts(T deciwatts)
         {
-            double value = (double) deciwatts;
-            return new Luminosity(value, LuminosityUnit.Deciwatt);
+            return new Luminosity<T>(deciwatts, LuminosityUnit.Deciwatt);
         }
         /// <summary>
-        ///     Get Luminosity from Femtowatts.
+        ///     Get <see cref="Luminosity{T}" /> from Femtowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromFemtowatts(QuantityValue femtowatts)
+        public static Luminosity<T> FromFemtowatts(T femtowatts)
         {
-            double value = (double) femtowatts;
-            return new Luminosity(value, LuminosityUnit.Femtowatt);
+            return new Luminosity<T>(femtowatts, LuminosityUnit.Femtowatt);
         }
         /// <summary>
-        ///     Get Luminosity from Gigawatts.
+        ///     Get <see cref="Luminosity{T}" /> from Gigawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromGigawatts(QuantityValue gigawatts)
+        public static Luminosity<T> FromGigawatts(T gigawatts)
         {
-            double value = (double) gigawatts;
-            return new Luminosity(value, LuminosityUnit.Gigawatt);
+            return new Luminosity<T>(gigawatts, LuminosityUnit.Gigawatt);
         }
         /// <summary>
-        ///     Get Luminosity from Kilowatts.
+        ///     Get <see cref="Luminosity{T}" /> from Kilowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromKilowatts(QuantityValue kilowatts)
+        public static Luminosity<T> FromKilowatts(T kilowatts)
         {
-            double value = (double) kilowatts;
-            return new Luminosity(value, LuminosityUnit.Kilowatt);
+            return new Luminosity<T>(kilowatts, LuminosityUnit.Kilowatt);
         }
         /// <summary>
-        ///     Get Luminosity from Megawatts.
+        ///     Get <see cref="Luminosity{T}" /> from Megawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMegawatts(QuantityValue megawatts)
+        public static Luminosity<T> FromMegawatts(T megawatts)
         {
-            double value = (double) megawatts;
-            return new Luminosity(value, LuminosityUnit.Megawatt);
+            return new Luminosity<T>(megawatts, LuminosityUnit.Megawatt);
         }
         /// <summary>
-        ///     Get Luminosity from Microwatts.
+        ///     Get <see cref="Luminosity{T}" /> from Microwatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMicrowatts(QuantityValue microwatts)
+        public static Luminosity<T> FromMicrowatts(T microwatts)
         {
-            double value = (double) microwatts;
-            return new Luminosity(value, LuminosityUnit.Microwatt);
+            return new Luminosity<T>(microwatts, LuminosityUnit.Microwatt);
         }
         /// <summary>
-        ///     Get Luminosity from Milliwatts.
+        ///     Get <see cref="Luminosity{T}" /> from Milliwatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMilliwatts(QuantityValue milliwatts)
+        public static Luminosity<T> FromMilliwatts(T milliwatts)
         {
-            double value = (double) milliwatts;
-            return new Luminosity(value, LuminosityUnit.Milliwatt);
+            return new Luminosity<T>(milliwatts, LuminosityUnit.Milliwatt);
         }
         /// <summary>
-        ///     Get Luminosity from Nanowatts.
+        ///     Get <see cref="Luminosity{T}" /> from Nanowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromNanowatts(QuantityValue nanowatts)
+        public static Luminosity<T> FromNanowatts(T nanowatts)
         {
-            double value = (double) nanowatts;
-            return new Luminosity(value, LuminosityUnit.Nanowatt);
+            return new Luminosity<T>(nanowatts, LuminosityUnit.Nanowatt);
         }
         /// <summary>
-        ///     Get Luminosity from Petawatts.
+        ///     Get <see cref="Luminosity{T}" /> from Petawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromPetawatts(QuantityValue petawatts)
+        public static Luminosity<T> FromPetawatts(T petawatts)
         {
-            double value = (double) petawatts;
-            return new Luminosity(value, LuminosityUnit.Petawatt);
+            return new Luminosity<T>(petawatts, LuminosityUnit.Petawatt);
         }
         /// <summary>
-        ///     Get Luminosity from Picowatts.
+        ///     Get <see cref="Luminosity{T}" /> from Picowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromPicowatts(QuantityValue picowatts)
+        public static Luminosity<T> FromPicowatts(T picowatts)
         {
-            double value = (double) picowatts;
-            return new Luminosity(value, LuminosityUnit.Picowatt);
+            return new Luminosity<T>(picowatts, LuminosityUnit.Picowatt);
         }
         /// <summary>
-        ///     Get Luminosity from SolarLuminosities.
+        ///     Get <see cref="Luminosity{T}" /> from SolarLuminosities.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromSolarLuminosities(QuantityValue solarluminosities)
+        public static Luminosity<T> FromSolarLuminosities(T solarluminosities)
         {
-            double value = (double) solarluminosities;
-            return new Luminosity(value, LuminosityUnit.SolarLuminosity);
+            return new Luminosity<T>(solarluminosities, LuminosityUnit.SolarLuminosity);
         }
         /// <summary>
-        ///     Get Luminosity from Terawatts.
+        ///     Get <see cref="Luminosity{T}" /> from Terawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromTerawatts(QuantityValue terawatts)
+        public static Luminosity<T> FromTerawatts(T terawatts)
         {
-            double value = (double) terawatts;
-            return new Luminosity(value, LuminosityUnit.Terawatt);
+            return new Luminosity<T>(terawatts, LuminosityUnit.Terawatt);
         }
         /// <summary>
-        ///     Get Luminosity from Watts.
+        ///     Get <see cref="Luminosity{T}" /> from Watts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromWatts(QuantityValue watts)
+        public static Luminosity<T> FromWatts(T watts)
         {
-            double value = (double) watts;
-            return new Luminosity(value, LuminosityUnit.Watt);
+            return new Luminosity<T>(watts, LuminosityUnit.Watt);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LuminosityUnit" /> to <see cref="Luminosity" />.
+        ///     Dynamically convert from value and unit enum <see cref="LuminosityUnit" /> to <see cref="Luminosity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Luminosity unit value.</returns>
-        public static Luminosity From(QuantityValue value, LuminosityUnit fromUnit)
+        /// <returns><see cref="Luminosity{T}" /> unit value.</returns>
+        public static Luminosity<T> From(T value, LuminosityUnit fromUnit)
         {
-            return new Luminosity((double)value, fromUnit);
+            return new Luminosity<T>(value, fromUnit);
         }
 
         #endregion
@@ -445,7 +429,7 @@ public static Luminosity From(QuantityValue value, LuminosityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Luminosity Parse(string str)
+        public static Luminosity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -473,9 +457,9 @@ public static Luminosity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Luminosity Parse(string str, IFormatProvider? provider)
+        public static Luminosity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Luminosity, LuminosityUnit>(
+            return QuantityParser.Default.Parse<T, Luminosity<T>, LuminosityUnit>(
                 str,
                 provider,
                 From);
@@ -489,7 +473,7 @@ public static Luminosity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Luminosity result)
+        public static bool TryParse(string? str, out Luminosity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -504,9 +488,9 @@ public static bool TryParse(string? str, out Luminosity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Luminosity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Luminosity<T> result)
         {
-            return QuantityParser.Default.TryParse<Luminosity, LuminosityUnit>(
+            return QuantityParser.Default.TryParse<T, Luminosity<T>, LuminosityUnit>(
                 str,
                 provider,
                 From,
@@ -568,45 +552,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Luminosity operator -(Luminosity right)
+        public static Luminosity<T> operator -(Luminosity<T> right)
         {
-            return new Luminosity(-right.Value, right.Unit);
+            return new Luminosity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Luminosity"/> from adding two <see cref="Luminosity"/>.</summary>
-        public static Luminosity operator +(Luminosity left, Luminosity right)
+        /// <summary>Get <see cref="Luminosity{T}"/> from adding two <see cref="Luminosity{T}"/>.</summary>
+        public static Luminosity<T> operator +(Luminosity<T> left, Luminosity<T> right)
         {
-            return new Luminosity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Luminosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Luminosity"/> from subtracting two <see cref="Luminosity"/>.</summary>
-        public static Luminosity operator -(Luminosity left, Luminosity right)
+        /// <summary>Get <see cref="Luminosity{T}"/> from subtracting two <see cref="Luminosity{T}"/>.</summary>
+        public static Luminosity<T> operator -(Luminosity<T> left, Luminosity<T> right)
         {
-            return new Luminosity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Luminosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Luminosity"/> from multiplying value and <see cref="Luminosity"/>.</summary>
-        public static Luminosity operator *(double left, Luminosity right)
+        /// <summary>Get <see cref="Luminosity{T}"/> from multiplying value and <see cref="Luminosity{T}"/>.</summary>
+        public static Luminosity<T> operator *(T left, Luminosity<T> right)
         {
-            return new Luminosity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Luminosity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Luminosity"/> from multiplying value and <see cref="Luminosity"/>.</summary>
-        public static Luminosity operator *(Luminosity left, double right)
+        /// <summary>Get <see cref="Luminosity{T}"/> from multiplying value and <see cref="Luminosity{T}"/>.</summary>
+        public static Luminosity<T> operator *(Luminosity<T> left, T right)
         {
-            return new Luminosity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Luminosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Luminosity"/> from dividing <see cref="Luminosity"/> by value.</summary>
-        public static Luminosity operator /(Luminosity left, double right)
+        /// <summary>Get <see cref="Luminosity{T}"/> from dividing <see cref="Luminosity{T}"/> by value.</summary>
+        public static Luminosity<T> operator /(Luminosity<T> left, T right)
         {
-            return new Luminosity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Luminosity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Luminosity"/> by <see cref="Luminosity"/>.</summary>
-        public static double operator /(Luminosity left, Luminosity right)
+        /// <summary>Get ratio value from dividing <see cref="Luminosity{T}"/> by <see cref="Luminosity{T}"/>.</summary>
+        public static T operator /(Luminosity<T> left, Luminosity<T> right)
         {
-            return left.Watts / right.Watts;
+            return CompiledLambdas.Divide(left.Watts, right.Watts);
         }
 
         #endregion
@@ -614,39 +603,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Luminosity left, Luminosity right)
+        public static bool operator <=(Luminosity<T> left, Luminosity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Luminosity left, Luminosity right)
+        public static bool operator >=(Luminosity<T> left, Luminosity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Luminosity left, Luminosity right)
+        public static bool operator <(Luminosity<T> left, Luminosity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Luminosity left, Luminosity right)
+        public static bool operator >(Luminosity<T> left, Luminosity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Luminosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Luminosity left, Luminosity right)
+        /// <remarks>Consider using <see cref="Equals(Luminosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Luminosity<T> left, Luminosity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Luminosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Luminosity left, Luminosity right)
+        /// <remarks>Consider using <see cref="Equals(Luminosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Luminosity<T> left, Luminosity<T> right)
         {
             return !(left == right);
         }
@@ -655,37 +644,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Luminosity objLuminosity)) throw new ArgumentException("Expected type Luminosity.", nameof(obj));
+            if(!(obj is Luminosity<T> objLuminosity)) throw new ArgumentException("Expected type Luminosity.", nameof(obj));
 
             return CompareTo(objLuminosity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Luminosity other)
+        public int CompareTo(Luminosity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Luminosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Luminosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Luminosity objLuminosity))
+            if(obj is null || !(obj is Luminosity<T> objLuminosity))
                 return false;
 
             return Equals(objLuminosity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Luminosity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Luminosity other)
+        /// <remarks>Consider using <see cref="Equals(Luminosity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Luminosity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Luminosity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Luminosity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -723,21 +712,19 @@ public bool Equals(Luminosity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Luminosity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Luminosity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Luminosity.</returns>
+        /// <returns>A hash code for the current <see cref="Luminosity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -751,17 +738,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LuminosityUnit unit)
+        public T As(LuminosityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -781,17 +768,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LuminosityUnit unitAsLuminosityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminosityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLuminosityUnit);
+            var asValue = As(unitAsLuminosityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LuminosityUnit>.As(LuminosityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Luminosity to another Luminosity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Luminosity{T}" /> to another <see cref="Luminosity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Luminosity with the specified unit.</returns>
-        public Luminosity ToUnit(LuminosityUnit unit)
+        /// <returns>A <see cref="Luminosity{T}" /> with the specified unit.</returns>
+        public Luminosity<T> ToUnit(LuminosityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Luminosity(convertedValue, unit);
+            return new Luminosity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -804,7 +796,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Luminosity ToUnit(UnitSystem unitSystem)
+        public Luminosity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -824,32 +816,38 @@ public Luminosity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LuminosityUnit> IQuantity<LuminosityUnit>.ToUnit(LuminosityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LuminosityUnit, T> IQuantityT<LuminosityUnit, T>.ToUnit(LuminosityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LuminosityUnit> IQuantity<LuminosityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LuminosityUnit, T> IQuantityT<LuminosityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LuminosityUnit.Decawatt: return (_value) * 1e1d;
-                case LuminosityUnit.Deciwatt: return (_value) * 1e-1d;
-                case LuminosityUnit.Femtowatt: return (_value) * 1e-15d;
-                case LuminosityUnit.Gigawatt: return (_value) * 1e9d;
-                case LuminosityUnit.Kilowatt: return (_value) * 1e3d;
-                case LuminosityUnit.Megawatt: return (_value) * 1e6d;
-                case LuminosityUnit.Microwatt: return (_value) * 1e-6d;
-                case LuminosityUnit.Milliwatt: return (_value) * 1e-3d;
-                case LuminosityUnit.Nanowatt: return (_value) * 1e-9d;
-                case LuminosityUnit.Petawatt: return (_value) * 1e15d;
-                case LuminosityUnit.Picowatt: return (_value) * 1e-12d;
-                case LuminosityUnit.SolarLuminosity: return _value * 3.846e26;
-                case LuminosityUnit.Terawatt: return (_value) * 1e12d;
-                case LuminosityUnit.Watt: return _value;
+                case LuminosityUnit.Decawatt: return (Value) * 1e1d;
+                case LuminosityUnit.Deciwatt: return (Value) * 1e-1d;
+                case LuminosityUnit.Femtowatt: return (Value) * 1e-15d;
+                case LuminosityUnit.Gigawatt: return (Value) * 1e9d;
+                case LuminosityUnit.Kilowatt: return (Value) * 1e3d;
+                case LuminosityUnit.Megawatt: return (Value) * 1e6d;
+                case LuminosityUnit.Microwatt: return (Value) * 1e-6d;
+                case LuminosityUnit.Milliwatt: return (Value) * 1e-3d;
+                case LuminosityUnit.Nanowatt: return (Value) * 1e-9d;
+                case LuminosityUnit.Petawatt: return (Value) * 1e15d;
+                case LuminosityUnit.Picowatt: return (Value) * 1e-12d;
+                case LuminosityUnit.SolarLuminosity: return Value * 3.846e26;
+                case LuminosityUnit.Terawatt: return (Value) * 1e12d;
+                case LuminosityUnit.Watt: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -860,16 +858,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Luminosity ToBaseUnit()
+        internal Luminosity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Luminosity(baseUnitValue, BaseUnit);
+            return new Luminosity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LuminosityUnit unit)
+        private T GetValueAs(LuminosityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -985,57 +983,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Luminosity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Luminosity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Luminosity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Luminosity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Luminosity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Luminosity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1045,33 +1043,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Luminosity))
+            if(conversionType == typeof(Luminosity<T>))
                 return this;
             else if(conversionType == typeof(LuminosityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Luminosity.QuantityType;
+                return Luminosity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Luminosity.Info;
+                return Luminosity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Luminosity.BaseDimensions;
+                return Luminosity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Luminosity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Luminosity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
index 5cabf81677..616789000d 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Luminous_flux
     /// </remarks>
-    public partial struct LuminousFlux : IQuantity<LuminousFluxUnit>, IEquatable<LuminousFlux>, IComparable, IComparable<LuminousFlux>, IConvertible, IFormattable
+    public partial struct LuminousFlux<T> : IQuantityT<LuminousFluxUnit, T>, IEquatable<LuminousFlux<T>>, IComparable, IComparable<LuminousFlux<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static LuminousFlux()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public LuminousFlux(double value, LuminousFluxUnit unit)
+        public LuminousFlux(T value, LuminousFluxUnit unit)
         {
             if(unit == LuminousFluxUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public LuminousFlux(double value, LuminousFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LuminousFlux(double value, UnitSystem unitSystem)
+        public LuminousFlux(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public LuminousFlux(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of LuminousFlux, which is Lumen. All conversions go via this value.
+        ///     The base unit of <see cref="LuminousFlux{T}" />, which is Lumen. All conversions go via this value.
         /// </summary>
         public static LuminousFluxUnit BaseUnit { get; } = LuminousFluxUnit.Lumen;
 
         /// <summary>
-        /// Represents the largest possible value of LuminousFlux
+        /// Represents the largest possible value of <see cref="LuminousFlux{T}" />
         /// </summary>
-        public static LuminousFlux MaxValue { get; } = new LuminousFlux(double.MaxValue, BaseUnit);
+        public static LuminousFlux<T> MaxValue { get; } = new LuminousFlux<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of LuminousFlux
+        /// Represents the smallest possible value of <see cref="LuminousFlux{T}" />
         /// </summary>
-        public static LuminousFlux MinValue { get; } = new LuminousFlux(double.MinValue, BaseUnit);
+        public static LuminousFlux<T> MinValue { get; } = new LuminousFlux<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public LuminousFlux(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.LuminousFlux;
 
         /// <summary>
-        ///     All units of measurement for the LuminousFlux quantity.
+        ///     All units of measurement for the <see cref="LuminousFlux{T}" /> quantity.
         /// </summary>
         public static LuminousFluxUnit[] Units { get; } = Enum.GetValues(typeof(LuminousFluxUnit)).Cast<LuminousFluxUnit>().Except(new LuminousFluxUnit[]{ LuminousFluxUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Lumen.
         /// </summary>
-        public static LuminousFlux Zero { get; } = new LuminousFlux(0, BaseUnit);
+        public static LuminousFlux<T> Zero { get; } = new LuminousFlux<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public LuminousFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public LuminousFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => LuminousFlux.QuantityType;
+        public QuantityType Type => LuminousFlux<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => LuminousFlux.BaseDimensions;
+        public BaseDimensions Dimensions => LuminousFlux<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get LuminousFlux in Lumens.
+        ///     Get <see cref="LuminousFlux{T}" /> in Lumens.
         /// </summary>
-        public double Lumens => As(LuminousFluxUnit.Lumen);
+        public T Lumens => As(LuminousFluxUnit.Lumen);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(LuminousFluxUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get LuminousFlux from Lumens.
+        ///     Get <see cref="LuminousFlux{T}" /> from Lumens.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LuminousFlux FromLumens(QuantityValue lumens)
+        public static LuminousFlux<T> FromLumens(T lumens)
         {
-            double value = (double) lumens;
-            return new LuminousFlux(value, LuminousFluxUnit.Lumen);
+            return new LuminousFlux<T>(lumens, LuminousFluxUnit.Lumen);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LuminousFluxUnit" /> to <see cref="LuminousFlux" />.
+        ///     Dynamically convert from value and unit enum <see cref="LuminousFluxUnit" /> to <see cref="LuminousFlux{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LuminousFlux unit value.</returns>
-        public static LuminousFlux From(QuantityValue value, LuminousFluxUnit fromUnit)
+        /// <returns><see cref="LuminousFlux{T}" /> unit value.</returns>
+        public static LuminousFlux<T> From(T value, LuminousFluxUnit fromUnit)
         {
-            return new LuminousFlux((double)value, fromUnit);
+            return new LuminousFlux<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static LuminousFlux From(QuantityValue value, LuminousFluxUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static LuminousFlux Parse(string str)
+        public static LuminousFlux<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static LuminousFlux Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static LuminousFlux Parse(string str, IFormatProvider? provider)
+        public static LuminousFlux<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<LuminousFlux, LuminousFluxUnit>(
+            return QuantityParser.Default.Parse<T, LuminousFlux<T>, LuminousFluxUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static LuminousFlux Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out LuminousFlux result)
+        public static bool TryParse(string? str, out LuminousFlux<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out LuminousFlux result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out LuminousFlux result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out LuminousFlux<T> result)
         {
-            return QuantityParser.Default.TryParse<LuminousFlux, LuminousFluxUnit>(
+            return QuantityParser.Default.TryParse<T, LuminousFlux<T>, LuminousFluxUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static LuminousFlux operator -(LuminousFlux right)
+        public static LuminousFlux<T> operator -(LuminousFlux<T> right)
         {
-            return new LuminousFlux(-right.Value, right.Unit);
+            return new LuminousFlux<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousFlux"/> from adding two <see cref="LuminousFlux"/>.</summary>
-        public static LuminousFlux operator +(LuminousFlux left, LuminousFlux right)
+        /// <summary>Get <see cref="LuminousFlux{T}"/> from adding two <see cref="LuminousFlux{T}"/>.</summary>
+        public static LuminousFlux<T> operator +(LuminousFlux<T> left, LuminousFlux<T> right)
         {
-            return new LuminousFlux(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new LuminousFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousFlux"/> from subtracting two <see cref="LuminousFlux"/>.</summary>
-        public static LuminousFlux operator -(LuminousFlux left, LuminousFlux right)
+        /// <summary>Get <see cref="LuminousFlux{T}"/> from subtracting two <see cref="LuminousFlux{T}"/>.</summary>
+        public static LuminousFlux<T> operator -(LuminousFlux<T> left, LuminousFlux<T> right)
         {
-            return new LuminousFlux(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new LuminousFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousFlux"/> from multiplying value and <see cref="LuminousFlux"/>.</summary>
-        public static LuminousFlux operator *(double left, LuminousFlux right)
+        /// <summary>Get <see cref="LuminousFlux{T}"/> from multiplying value and <see cref="LuminousFlux{T}"/>.</summary>
+        public static LuminousFlux<T> operator *(T left, LuminousFlux<T> right)
         {
-            return new LuminousFlux(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new LuminousFlux<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousFlux"/> from multiplying value and <see cref="LuminousFlux"/>.</summary>
-        public static LuminousFlux operator *(LuminousFlux left, double right)
+        /// <summary>Get <see cref="LuminousFlux{T}"/> from multiplying value and <see cref="LuminousFlux{T}"/>.</summary>
+        public static LuminousFlux<T> operator *(LuminousFlux<T> left, T right)
         {
-            return new LuminousFlux(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new LuminousFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousFlux"/> from dividing <see cref="LuminousFlux"/> by value.</summary>
-        public static LuminousFlux operator /(LuminousFlux left, double right)
+        /// <summary>Get <see cref="LuminousFlux{T}"/> from dividing <see cref="LuminousFlux{T}"/> by value.</summary>
+        public static LuminousFlux<T> operator /(LuminousFlux<T> left, T right)
         {
-            return new LuminousFlux(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new LuminousFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="LuminousFlux"/> by <see cref="LuminousFlux"/>.</summary>
-        public static double operator /(LuminousFlux left, LuminousFlux right)
+        /// <summary>Get ratio value from dividing <see cref="LuminousFlux{T}"/> by <see cref="LuminousFlux{T}"/>.</summary>
+        public static T operator /(LuminousFlux<T> left, LuminousFlux<T> right)
         {
-            return left.Lumens / right.Lumens;
+            return CompiledLambdas.Divide(left.Lumens, right.Lumens);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(LuminousFlux left, LuminousFlux right)
+        public static bool operator <=(LuminousFlux<T> left, LuminousFlux<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(LuminousFlux left, LuminousFlux right)
+        public static bool operator >=(LuminousFlux<T> left, LuminousFlux<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(LuminousFlux left, LuminousFlux right)
+        public static bool operator <(LuminousFlux<T> left, LuminousFlux<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(LuminousFlux left, LuminousFlux right)
+        public static bool operator >(LuminousFlux<T> left, LuminousFlux<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LuminousFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(LuminousFlux left, LuminousFlux right)
+        /// <remarks>Consider using <see cref="Equals(LuminousFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(LuminousFlux<T> left, LuminousFlux<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LuminousFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(LuminousFlux left, LuminousFlux right)
+        /// <remarks>Consider using <see cref="Equals(LuminousFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(LuminousFlux<T> left, LuminousFlux<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is LuminousFlux objLuminousFlux)) throw new ArgumentException("Expected type LuminousFlux.", nameof(obj));
+            if(!(obj is LuminousFlux<T> objLuminousFlux)) throw new ArgumentException("Expected type LuminousFlux.", nameof(obj));
 
             return CompareTo(objLuminousFlux);
         }
 
         /// <inheritdoc />
-        public int CompareTo(LuminousFlux other)
+        public int CompareTo(LuminousFlux<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LuminousFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(LuminousFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is LuminousFlux objLuminousFlux))
+            if(obj is null || !(obj is LuminousFlux<T> objLuminousFlux))
                 return false;
 
             return Equals(objLuminousFlux);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LuminousFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(LuminousFlux other)
+        /// <remarks>Consider using <see cref="Equals(LuminousFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(LuminousFlux<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another LuminousFlux within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="LuminousFlux{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(LuminousFlux other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(LuminousFlux other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(LuminousFlux<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current LuminousFlux.</returns>
+        /// <returns>A hash code for the current <see cref="LuminousFlux{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LuminousFluxUnit unit)
+        public T As(LuminousFluxUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LuminousFluxUnit unitAsLuminousFluxUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousFluxUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLuminousFluxUnit);
+            var asValue = As(unitAsLuminousFluxUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LuminousFluxUnit>.As(LuminousFluxUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this LuminousFlux to another LuminousFlux with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="LuminousFlux{T}" /> to another <see cref="LuminousFlux{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A LuminousFlux with the specified unit.</returns>
-        public LuminousFlux ToUnit(LuminousFluxUnit unit)
+        /// <returns>A <see cref="LuminousFlux{T}" /> with the specified unit.</returns>
+        public LuminousFlux<T> ToUnit(LuminousFluxUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new LuminousFlux(convertedValue, unit);
+            return new LuminousFlux<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public LuminousFlux ToUnit(UnitSystem unitSystem)
+        public LuminousFlux<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public LuminousFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LuminousFluxUnit> IQuantity<LuminousFluxUnit>.ToUnit(LuminousFluxUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LuminousFluxUnit, T> IQuantityT<LuminousFluxUnit, T>.ToUnit(LuminousFluxUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LuminousFluxUnit> IQuantity<LuminousFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LuminousFluxUnit, T> IQuantityT<LuminousFluxUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LuminousFluxUnit.Lumen: return _value;
+                case LuminousFluxUnit.Lumen: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal LuminousFlux ToBaseUnit()
+        internal LuminousFlux<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new LuminousFlux(baseUnitValue, BaseUnit);
+            return new LuminousFlux<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LuminousFluxUnit unit)
+        private T GetValueAs(LuminousFluxUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LuminousFlux)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LuminousFlux<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LuminousFlux)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LuminousFlux<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LuminousFlux)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LuminousFlux<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(LuminousFlux))
+            if(conversionType == typeof(LuminousFlux<T>))
                 return this;
             else if(conversionType == typeof(LuminousFluxUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return LuminousFlux.QuantityType;
+                return LuminousFlux<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return LuminousFlux.Info;
+                return LuminousFlux<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return LuminousFlux.BaseDimensions;
+                return LuminousFlux<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(LuminousFlux)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(LuminousFlux<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
index f6beb642b7..0fb31ea991 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Luminous_intensity
     /// </remarks>
-    public partial struct LuminousIntensity : IQuantity<LuminousIntensityUnit>, IEquatable<LuminousIntensity>, IComparable, IComparable<LuminousIntensity>, IConvertible, IFormattable
+    public partial struct LuminousIntensity<T> : IQuantityT<LuminousIntensityUnit, T>, IEquatable<LuminousIntensity<T>>, IComparable, IComparable<LuminousIntensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static LuminousIntensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public LuminousIntensity(double value, LuminousIntensityUnit unit)
+        public LuminousIntensity(T value, LuminousIntensityUnit unit)
         {
             if(unit == LuminousIntensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public LuminousIntensity(double value, LuminousIntensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LuminousIntensity(double value, UnitSystem unitSystem)
+        public LuminousIntensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of LuminousIntensity, which is Candela. All conversions go via this value.
+        ///     The base unit of <see cref="LuminousIntensity{T}" />, which is Candela. All conversions go via this value.
         /// </summary>
         public static LuminousIntensityUnit BaseUnit { get; } = LuminousIntensityUnit.Candela;
 
         /// <summary>
-        /// Represents the largest possible value of LuminousIntensity
+        /// Represents the largest possible value of <see cref="LuminousIntensity{T}" />
         /// </summary>
-        public static LuminousIntensity MaxValue { get; } = new LuminousIntensity(double.MaxValue, BaseUnit);
+        public static LuminousIntensity<T> MaxValue { get; } = new LuminousIntensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of LuminousIntensity
+        /// Represents the smallest possible value of <see cref="LuminousIntensity{T}" />
         /// </summary>
-        public static LuminousIntensity MinValue { get; } = new LuminousIntensity(double.MinValue, BaseUnit);
+        public static LuminousIntensity<T> MinValue { get; } = new LuminousIntensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.LuminousIntensity;
 
         /// <summary>
-        ///     All units of measurement for the LuminousIntensity quantity.
+        ///     All units of measurement for the <see cref="LuminousIntensity{T}" /> quantity.
         /// </summary>
         public static LuminousIntensityUnit[] Units { get; } = Enum.GetValues(typeof(LuminousIntensityUnit)).Cast<LuminousIntensityUnit>().Except(new LuminousIntensityUnit[]{ LuminousIntensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Candela.
         /// </summary>
-        public static LuminousIntensity Zero { get; } = new LuminousIntensity(0, BaseUnit);
+        public static LuminousIntensity<T> Zero { get; } = new LuminousIntensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => LuminousIntensity.QuantityType;
+        public QuantityType Type => LuminousIntensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => LuminousIntensity.BaseDimensions;
+        public BaseDimensions Dimensions => LuminousIntensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get LuminousIntensity in Candela.
+        ///     Get <see cref="LuminousIntensity{T}" /> in Candela.
         /// </summary>
-        public double Candela => As(LuminousIntensityUnit.Candela);
+        public T Candela => As(LuminousIntensityUnit.Candela);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(LuminousIntensityUnit unit, IFormatProvider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get LuminousIntensity from Candela.
+        ///     Get <see cref="LuminousIntensity{T}" /> from Candela.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LuminousIntensity FromCandela(QuantityValue candela)
+        public static LuminousIntensity<T> FromCandela(T candela)
         {
-            double value = (double) candela;
-            return new LuminousIntensity(value, LuminousIntensityUnit.Candela);
+            return new LuminousIntensity<T>(candela, LuminousIntensityUnit.Candela);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LuminousIntensityUnit" /> to <see cref="LuminousIntensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="LuminousIntensityUnit" /> to <see cref="LuminousIntensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LuminousIntensity unit value.</returns>
-        public static LuminousIntensity From(QuantityValue value, LuminousIntensityUnit fromUnit)
+        /// <returns><see cref="LuminousIntensity{T}" /> unit value.</returns>
+        public static LuminousIntensity<T> From(T value, LuminousIntensityUnit fromUnit)
         {
-            return new LuminousIntensity((double)value, fromUnit);
+            return new LuminousIntensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static LuminousIntensity From(QuantityValue value, LuminousIntensityUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static LuminousIntensity Parse(string str)
+        public static LuminousIntensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static LuminousIntensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static LuminousIntensity Parse(string str, IFormatProvider? provider)
+        public static LuminousIntensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<LuminousIntensity, LuminousIntensityUnit>(
+            return QuantityParser.Default.Parse<T, LuminousIntensity<T>, LuminousIntensityUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static LuminousIntensity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out LuminousIntensity result)
+        public static bool TryParse(string? str, out LuminousIntensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out LuminousIntensity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out LuminousIntensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out LuminousIntensity<T> result)
         {
-            return QuantityParser.Default.TryParse<LuminousIntensity, LuminousIntensityUnit>(
+            return QuantityParser.Default.TryParse<T, LuminousIntensity<T>, LuminousIntensityUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static LuminousIntensity operator -(LuminousIntensity right)
+        public static LuminousIntensity<T> operator -(LuminousIntensity<T> right)
         {
-            return new LuminousIntensity(-right.Value, right.Unit);
+            return new LuminousIntensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousIntensity"/> from adding two <see cref="LuminousIntensity"/>.</summary>
-        public static LuminousIntensity operator +(LuminousIntensity left, LuminousIntensity right)
+        /// <summary>Get <see cref="LuminousIntensity{T}"/> from adding two <see cref="LuminousIntensity{T}"/>.</summary>
+        public static LuminousIntensity<T> operator +(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
-            return new LuminousIntensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new LuminousIntensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousIntensity"/> from subtracting two <see cref="LuminousIntensity"/>.</summary>
-        public static LuminousIntensity operator -(LuminousIntensity left, LuminousIntensity right)
+        /// <summary>Get <see cref="LuminousIntensity{T}"/> from subtracting two <see cref="LuminousIntensity{T}"/>.</summary>
+        public static LuminousIntensity<T> operator -(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
-            return new LuminousIntensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new LuminousIntensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousIntensity"/> from multiplying value and <see cref="LuminousIntensity"/>.</summary>
-        public static LuminousIntensity operator *(double left, LuminousIntensity right)
+        /// <summary>Get <see cref="LuminousIntensity{T}"/> from multiplying value and <see cref="LuminousIntensity{T}"/>.</summary>
+        public static LuminousIntensity<T> operator *(T left, LuminousIntensity<T> right)
         {
-            return new LuminousIntensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new LuminousIntensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousIntensity"/> from multiplying value and <see cref="LuminousIntensity"/>.</summary>
-        public static LuminousIntensity operator *(LuminousIntensity left, double right)
+        /// <summary>Get <see cref="LuminousIntensity{T}"/> from multiplying value and <see cref="LuminousIntensity{T}"/>.</summary>
+        public static LuminousIntensity<T> operator *(LuminousIntensity<T> left, T right)
         {
-            return new LuminousIntensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new LuminousIntensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="LuminousIntensity"/> from dividing <see cref="LuminousIntensity"/> by value.</summary>
-        public static LuminousIntensity operator /(LuminousIntensity left, double right)
+        /// <summary>Get <see cref="LuminousIntensity{T}"/> from dividing <see cref="LuminousIntensity{T}"/> by value.</summary>
+        public static LuminousIntensity<T> operator /(LuminousIntensity<T> left, T right)
         {
-            return new LuminousIntensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new LuminousIntensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="LuminousIntensity"/> by <see cref="LuminousIntensity"/>.</summary>
-        public static double operator /(LuminousIntensity left, LuminousIntensity right)
+        /// <summary>Get ratio value from dividing <see cref="LuminousIntensity{T}"/> by <see cref="LuminousIntensity{T}"/>.</summary>
+        public static T operator /(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
-            return left.Candela / right.Candela;
+            return CompiledLambdas.Divide(left.Candela, right.Candela);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(LuminousIntensity left, LuminousIntensity right)
+        public static bool operator <=(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(LuminousIntensity left, LuminousIntensity right)
+        public static bool operator >=(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(LuminousIntensity left, LuminousIntensity right)
+        public static bool operator <(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(LuminousIntensity left, LuminousIntensity right)
+        public static bool operator >(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LuminousIntensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(LuminousIntensity left, LuminousIntensity right)
+        /// <remarks>Consider using <see cref="Equals(LuminousIntensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(LuminousIntensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(LuminousIntensity left, LuminousIntensity right)
+        /// <remarks>Consider using <see cref="Equals(LuminousIntensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(LuminousIntensity<T> left, LuminousIntensity<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Lumin
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is LuminousIntensity objLuminousIntensity)) throw new ArgumentException("Expected type LuminousIntensity.", nameof(obj));
+            if(!(obj is LuminousIntensity<T> objLuminousIntensity)) throw new ArgumentException("Expected type LuminousIntensity.", nameof(obj));
 
             return CompareTo(objLuminousIntensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(LuminousIntensity other)
+        public int CompareTo(LuminousIntensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LuminousIntensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(LuminousIntensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is LuminousIntensity objLuminousIntensity))
+            if(obj is null || !(obj is LuminousIntensity<T> objLuminousIntensity))
                 return false;
 
             return Equals(objLuminousIntensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(LuminousIntensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(LuminousIntensity other)
+        /// <remarks>Consider using <see cref="Equals(LuminousIntensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(LuminousIntensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another LuminousIntensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="LuminousIntensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(LuminousIntensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(LuminousIntensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(LuminousIntensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current LuminousIntensity.</returns>
+        /// <returns>A hash code for the current <see cref="LuminousIntensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(LuminousIntensityUnit unit)
+        public T As(LuminousIntensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is LuminousIntensityUnit unitAsLuminousIntensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousIntensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsLuminousIntensityUnit);
+            var asValue = As(unitAsLuminousIntensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<LuminousIntensityUnit>.As(LuminousIntensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this LuminousIntensity to another LuminousIntensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="LuminousIntensity{T}" /> to another <see cref="LuminousIntensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A LuminousIntensity with the specified unit.</returns>
-        public LuminousIntensity ToUnit(LuminousIntensityUnit unit)
+        /// <returns>A <see cref="LuminousIntensity{T}" /> with the specified unit.</returns>
+        public LuminousIntensity<T> ToUnit(LuminousIntensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new LuminousIntensity(convertedValue, unit);
+            return new LuminousIntensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public LuminousIntensity ToUnit(UnitSystem unitSystem)
+        public LuminousIntensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public LuminousIntensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LuminousIntensityUnit> IQuantity<LuminousIntensityUnit>.ToUnit(LuminousIntensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<LuminousIntensityUnit, T> IQuantityT<LuminousIntensityUnit, T>.ToUnit(LuminousIntensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<LuminousIntensityUnit> IQuantity<LuminousIntensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<LuminousIntensityUnit, T> IQuantityT<LuminousIntensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case LuminousIntensityUnit.Candela: return _value;
+                case LuminousIntensityUnit.Candela: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal LuminousIntensity ToBaseUnit()
+        internal LuminousIntensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new LuminousIntensity(baseUnitValue, BaseUnit);
+            return new LuminousIntensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(LuminousIntensityUnit unit)
+        private T GetValueAs(LuminousIntensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LuminousIntensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LuminousIntensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LuminousIntensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LuminousIntensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(LuminousIntensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(LuminousIntensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(LuminousIntensity))
+            if(conversionType == typeof(LuminousIntensity<T>))
                 return this;
             else if(conversionType == typeof(LuminousIntensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return LuminousIntensity.QuantityType;
+                return LuminousIntensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return LuminousIntensity.Info;
+                return LuminousIntensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return LuminousIntensity.BaseDimensions;
+                return LuminousIntensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(LuminousIntensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(LuminousIntensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
index b124240e24..31b1a0f28f 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Magnetic_field
     /// </remarks>
-    public partial struct MagneticField : IQuantity<MagneticFieldUnit>, IEquatable<MagneticField>, IComparable, IComparable<MagneticField>, IConvertible, IFormattable
+    public partial struct MagneticField<T> : IQuantityT<MagneticFieldUnit, T>, IEquatable<MagneticField<T>>, IComparable, IComparable<MagneticField<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -70,12 +66,12 @@ static MagneticField()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MagneticField(double value, MagneticFieldUnit unit)
+        public MagneticField(T value, MagneticFieldUnit unit)
         {
             if(unit == MagneticFieldUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -87,14 +83,14 @@ public MagneticField(double value, MagneticFieldUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MagneticField(double value, UnitSystem unitSystem)
+        public MagneticField(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -109,19 +105,19 @@ public MagneticField(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MagneticField, which is Tesla. All conversions go via this value.
+        ///     The base unit of <see cref="MagneticField{T}" />, which is Tesla. All conversions go via this value.
         /// </summary>
         public static MagneticFieldUnit BaseUnit { get; } = MagneticFieldUnit.Tesla;
 
         /// <summary>
-        /// Represents the largest possible value of MagneticField
+        /// Represents the largest possible value of <see cref="MagneticField{T}" />
         /// </summary>
-        public static MagneticField MaxValue { get; } = new MagneticField(double.MaxValue, BaseUnit);
+        public static MagneticField<T> MaxValue { get; } = new MagneticField<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MagneticField
+        /// Represents the smallest possible value of <see cref="MagneticField{T}" />
         /// </summary>
-        public static MagneticField MinValue { get; } = new MagneticField(double.MinValue, BaseUnit);
+        public static MagneticField<T> MinValue { get; } = new MagneticField<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -130,14 +126,14 @@ public MagneticField(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MagneticField;
 
         /// <summary>
-        ///     All units of measurement for the MagneticField quantity.
+        ///     All units of measurement for the <see cref="MagneticField{T}" /> quantity.
         /// </summary>
         public static MagneticFieldUnit[] Units { get; } = Enum.GetValues(typeof(MagneticFieldUnit)).Cast<MagneticFieldUnit>().Except(new MagneticFieldUnit[]{ MagneticFieldUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Tesla.
         /// </summary>
-        public static MagneticField Zero { get; } = new MagneticField(0, BaseUnit);
+        public static MagneticField<T> Zero { get; } = new MagneticField<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -146,7 +142,9 @@ public MagneticField(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -162,41 +160,41 @@ public MagneticField(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MagneticField.QuantityType;
+        public QuantityType Type => MagneticField<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MagneticField.BaseDimensions;
+        public BaseDimensions Dimensions => MagneticField<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MagneticField in Gausses.
+        ///     Get <see cref="MagneticField{T}" /> in Gausses.
         /// </summary>
-        public double Gausses => As(MagneticFieldUnit.Gauss);
+        public T Gausses => As(MagneticFieldUnit.Gauss);
 
         /// <summary>
-        ///     Get MagneticField in Microteslas.
+        ///     Get <see cref="MagneticField{T}" /> in Microteslas.
         /// </summary>
-        public double Microteslas => As(MagneticFieldUnit.Microtesla);
+        public T Microteslas => As(MagneticFieldUnit.Microtesla);
 
         /// <summary>
-        ///     Get MagneticField in Milliteslas.
+        ///     Get <see cref="MagneticField{T}" /> in Milliteslas.
         /// </summary>
-        public double Milliteslas => As(MagneticFieldUnit.Millitesla);
+        public T Milliteslas => As(MagneticFieldUnit.Millitesla);
 
         /// <summary>
-        ///     Get MagneticField in Nanoteslas.
+        ///     Get <see cref="MagneticField{T}" /> in Nanoteslas.
         /// </summary>
-        public double Nanoteslas => As(MagneticFieldUnit.Nanotesla);
+        public T Nanoteslas => As(MagneticFieldUnit.Nanotesla);
 
         /// <summary>
-        ///     Get MagneticField in Teslas.
+        ///     Get <see cref="MagneticField{T}" /> in Teslas.
         /// </summary>
-        public double Teslas => As(MagneticFieldUnit.Tesla);
+        public T Teslas => As(MagneticFieldUnit.Tesla);
 
         #endregion
 
@@ -228,60 +226,55 @@ public static string GetAbbreviation(MagneticFieldUnit unit, IFormatProvider? pr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MagneticField from Gausses.
+        ///     Get <see cref="MagneticField{T}" /> from Gausses.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromGausses(QuantityValue gausses)
+        public static MagneticField<T> FromGausses(T gausses)
         {
-            double value = (double) gausses;
-            return new MagneticField(value, MagneticFieldUnit.Gauss);
+            return new MagneticField<T>(gausses, MagneticFieldUnit.Gauss);
         }
         /// <summary>
-        ///     Get MagneticField from Microteslas.
+        ///     Get <see cref="MagneticField{T}" /> from Microteslas.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMicroteslas(QuantityValue microteslas)
+        public static MagneticField<T> FromMicroteslas(T microteslas)
         {
-            double value = (double) microteslas;
-            return new MagneticField(value, MagneticFieldUnit.Microtesla);
+            return new MagneticField<T>(microteslas, MagneticFieldUnit.Microtesla);
         }
         /// <summary>
-        ///     Get MagneticField from Milliteslas.
+        ///     Get <see cref="MagneticField{T}" /> from Milliteslas.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMilliteslas(QuantityValue milliteslas)
+        public static MagneticField<T> FromMilliteslas(T milliteslas)
         {
-            double value = (double) milliteslas;
-            return new MagneticField(value, MagneticFieldUnit.Millitesla);
+            return new MagneticField<T>(milliteslas, MagneticFieldUnit.Millitesla);
         }
         /// <summary>
-        ///     Get MagneticField from Nanoteslas.
+        ///     Get <see cref="MagneticField{T}" /> from Nanoteslas.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromNanoteslas(QuantityValue nanoteslas)
+        public static MagneticField<T> FromNanoteslas(T nanoteslas)
         {
-            double value = (double) nanoteslas;
-            return new MagneticField(value, MagneticFieldUnit.Nanotesla);
+            return new MagneticField<T>(nanoteslas, MagneticFieldUnit.Nanotesla);
         }
         /// <summary>
-        ///     Get MagneticField from Teslas.
+        ///     Get <see cref="MagneticField{T}" /> from Teslas.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromTeslas(QuantityValue teslas)
+        public static MagneticField<T> FromTeslas(T teslas)
         {
-            double value = (double) teslas;
-            return new MagneticField(value, MagneticFieldUnit.Tesla);
+            return new MagneticField<T>(teslas, MagneticFieldUnit.Tesla);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MagneticFieldUnit" /> to <see cref="MagneticField" />.
+        ///     Dynamically convert from value and unit enum <see cref="MagneticFieldUnit" /> to <see cref="MagneticField{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MagneticField unit value.</returns>
-        public static MagneticField From(QuantityValue value, MagneticFieldUnit fromUnit)
+        /// <returns><see cref="MagneticField{T}" /> unit value.</returns>
+        public static MagneticField<T> From(T value, MagneticFieldUnit fromUnit)
         {
-            return new MagneticField((double)value, fromUnit);
+            return new MagneticField<T>(value, fromUnit);
         }
 
         #endregion
@@ -310,7 +303,7 @@ public static MagneticField From(QuantityValue value, MagneticFieldUnit fromUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MagneticField Parse(string str)
+        public static MagneticField<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -338,9 +331,9 @@ public static MagneticField Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MagneticField Parse(string str, IFormatProvider? provider)
+        public static MagneticField<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MagneticField, MagneticFieldUnit>(
+            return QuantityParser.Default.Parse<T, MagneticField<T>, MagneticFieldUnit>(
                 str,
                 provider,
                 From);
@@ -354,7 +347,7 @@ public static MagneticField Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MagneticField result)
+        public static bool TryParse(string? str, out MagneticField<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -369,9 +362,9 @@ public static bool TryParse(string? str, out MagneticField result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MagneticField result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MagneticField<T> result)
         {
-            return QuantityParser.Default.TryParse<MagneticField, MagneticFieldUnit>(
+            return QuantityParser.Default.TryParse<T, MagneticField<T>, MagneticFieldUnit>(
                 str,
                 provider,
                 From,
@@ -433,45 +426,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MagneticField operator -(MagneticField right)
+        public static MagneticField<T> operator -(MagneticField<T> right)
         {
-            return new MagneticField(-right.Value, right.Unit);
+            return new MagneticField<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticField"/> from adding two <see cref="MagneticField"/>.</summary>
-        public static MagneticField operator +(MagneticField left, MagneticField right)
+        /// <summary>Get <see cref="MagneticField{T}"/> from adding two <see cref="MagneticField{T}"/>.</summary>
+        public static MagneticField<T> operator +(MagneticField<T> left, MagneticField<T> right)
         {
-            return new MagneticField(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MagneticField<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticField"/> from subtracting two <see cref="MagneticField"/>.</summary>
-        public static MagneticField operator -(MagneticField left, MagneticField right)
+        /// <summary>Get <see cref="MagneticField{T}"/> from subtracting two <see cref="MagneticField{T}"/>.</summary>
+        public static MagneticField<T> operator -(MagneticField<T> left, MagneticField<T> right)
         {
-            return new MagneticField(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MagneticField<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticField"/> from multiplying value and <see cref="MagneticField"/>.</summary>
-        public static MagneticField operator *(double left, MagneticField right)
+        /// <summary>Get <see cref="MagneticField{T}"/> from multiplying value and <see cref="MagneticField{T}"/>.</summary>
+        public static MagneticField<T> operator *(T left, MagneticField<T> right)
         {
-            return new MagneticField(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MagneticField<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticField"/> from multiplying value and <see cref="MagneticField"/>.</summary>
-        public static MagneticField operator *(MagneticField left, double right)
+        /// <summary>Get <see cref="MagneticField{T}"/> from multiplying value and <see cref="MagneticField{T}"/>.</summary>
+        public static MagneticField<T> operator *(MagneticField<T> left, T right)
         {
-            return new MagneticField(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MagneticField<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticField"/> from dividing <see cref="MagneticField"/> by value.</summary>
-        public static MagneticField operator /(MagneticField left, double right)
+        /// <summary>Get <see cref="MagneticField{T}"/> from dividing <see cref="MagneticField{T}"/> by value.</summary>
+        public static MagneticField<T> operator /(MagneticField<T> left, T right)
         {
-            return new MagneticField(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MagneticField<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MagneticField"/> by <see cref="MagneticField"/>.</summary>
-        public static double operator /(MagneticField left, MagneticField right)
+        /// <summary>Get ratio value from dividing <see cref="MagneticField{T}"/> by <see cref="MagneticField{T}"/>.</summary>
+        public static T operator /(MagneticField<T> left, MagneticField<T> right)
         {
-            return left.Teslas / right.Teslas;
+            return CompiledLambdas.Divide(left.Teslas, right.Teslas);
         }
 
         #endregion
@@ -479,39 +477,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MagneticField left, MagneticField right)
+        public static bool operator <=(MagneticField<T> left, MagneticField<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MagneticField left, MagneticField right)
+        public static bool operator >=(MagneticField<T> left, MagneticField<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MagneticField left, MagneticField right)
+        public static bool operator <(MagneticField<T> left, MagneticField<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MagneticField left, MagneticField right)
+        public static bool operator >(MagneticField<T> left, MagneticField<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MagneticField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MagneticField left, MagneticField right)
+        /// <remarks>Consider using <see cref="Equals(MagneticField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MagneticField<T> left, MagneticField<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MagneticField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MagneticField left, MagneticField right)
+        /// <remarks>Consider using <see cref="Equals(MagneticField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MagneticField<T> left, MagneticField<T> right)
         {
             return !(left == right);
         }
@@ -520,37 +518,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MagneticField objMagneticField)) throw new ArgumentException("Expected type MagneticField.", nameof(obj));
+            if(!(obj is MagneticField<T> objMagneticField)) throw new ArgumentException("Expected type MagneticField.", nameof(obj));
 
             return CompareTo(objMagneticField);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MagneticField other)
+        public int CompareTo(MagneticField<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MagneticField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MagneticField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MagneticField objMagneticField))
+            if(obj is null || !(obj is MagneticField<T> objMagneticField))
                 return false;
 
             return Equals(objMagneticField);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MagneticField, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MagneticField other)
+        /// <remarks>Consider using <see cref="Equals(MagneticField{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MagneticField<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MagneticField within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MagneticField{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -588,21 +586,19 @@ public bool Equals(MagneticField other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MagneticField other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MagneticField<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MagneticField.</returns>
+        /// <returns>A hash code for the current <see cref="MagneticField{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -616,17 +612,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MagneticFieldUnit unit)
+        public T As(MagneticFieldUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -646,17 +642,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MagneticFieldUnit unitAsMagneticFieldUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFieldUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMagneticFieldUnit);
+            var asValue = As(unitAsMagneticFieldUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MagneticFieldUnit>.As(MagneticFieldUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MagneticField to another MagneticField with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MagneticField{T}" /> to another <see cref="MagneticField{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MagneticField with the specified unit.</returns>
-        public MagneticField ToUnit(MagneticFieldUnit unit)
+        /// <returns>A <see cref="MagneticField{T}" /> with the specified unit.</returns>
+        public MagneticField<T> ToUnit(MagneticFieldUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MagneticField(convertedValue, unit);
+            return new MagneticField<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -669,7 +670,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MagneticField ToUnit(UnitSystem unitSystem)
+        public MagneticField<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -689,23 +690,29 @@ public MagneticField ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MagneticFieldUnit> IQuantity<MagneticFieldUnit>.ToUnit(MagneticFieldUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MagneticFieldUnit, T> IQuantityT<MagneticFieldUnit, T>.ToUnit(MagneticFieldUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MagneticFieldUnit> IQuantity<MagneticFieldUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MagneticFieldUnit, T> IQuantityT<MagneticFieldUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MagneticFieldUnit.Gauss: return _value/1e4;
-                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;
+                case MagneticFieldUnit.Gauss: return Value/1e4;
+                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.");
             }
@@ -716,16 +723,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MagneticField ToBaseUnit()
+        internal MagneticField<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MagneticField(baseUnitValue, BaseUnit);
+            return new MagneticField<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MagneticFieldUnit unit)
+        private T GetValueAs(MagneticFieldUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -832,57 +839,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MagneticField)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MagneticField<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MagneticField)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MagneticField<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MagneticField)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MagneticField<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -892,33 +899,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MagneticField))
+            if(conversionType == typeof(MagneticField<T>))
                 return this;
             else if(conversionType == typeof(MagneticFieldUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MagneticField.QuantityType;
+                return MagneticField<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MagneticField.Info;
+                return MagneticField<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MagneticField.BaseDimensions;
+                return MagneticField<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MagneticField)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MagneticField<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
index 2fc322f19f..018672c2cd 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Magnetic_flux
     /// </remarks>
-    public partial struct MagneticFlux : IQuantity<MagneticFluxUnit>, IEquatable<MagneticFlux>, IComparable, IComparable<MagneticFlux>, IConvertible, IFormattable
+    public partial struct MagneticFlux<T> : IQuantityT<MagneticFluxUnit, T>, IEquatable<MagneticFlux<T>>, IComparable, IComparable<MagneticFlux<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static MagneticFlux()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MagneticFlux(double value, MagneticFluxUnit unit)
+        public MagneticFlux(T value, MagneticFluxUnit unit)
         {
             if(unit == MagneticFluxUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public MagneticFlux(double value, MagneticFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MagneticFlux(double value, UnitSystem unitSystem)
+        public MagneticFlux(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public MagneticFlux(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MagneticFlux, which is Weber. All conversions go via this value.
+        ///     The base unit of <see cref="MagneticFlux{T}" />, which is Weber. All conversions go via this value.
         /// </summary>
         public static MagneticFluxUnit BaseUnit { get; } = MagneticFluxUnit.Weber;
 
         /// <summary>
-        /// Represents the largest possible value of MagneticFlux
+        /// Represents the largest possible value of <see cref="MagneticFlux{T}" />
         /// </summary>
-        public static MagneticFlux MaxValue { get; } = new MagneticFlux(double.MaxValue, BaseUnit);
+        public static MagneticFlux<T> MaxValue { get; } = new MagneticFlux<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MagneticFlux
+        /// Represents the smallest possible value of <see cref="MagneticFlux{T}" />
         /// </summary>
-        public static MagneticFlux MinValue { get; } = new MagneticFlux(double.MinValue, BaseUnit);
+        public static MagneticFlux<T> MinValue { get; } = new MagneticFlux<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public MagneticFlux(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MagneticFlux;
 
         /// <summary>
-        ///     All units of measurement for the MagneticFlux quantity.
+        ///     All units of measurement for the <see cref="MagneticFlux{T}" /> quantity.
         /// </summary>
         public static MagneticFluxUnit[] Units { get; } = Enum.GetValues(typeof(MagneticFluxUnit)).Cast<MagneticFluxUnit>().Except(new MagneticFluxUnit[]{ MagneticFluxUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Weber.
         /// </summary>
-        public static MagneticFlux Zero { get; } = new MagneticFlux(0, BaseUnit);
+        public static MagneticFlux<T> Zero { get; } = new MagneticFlux<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public MagneticFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public MagneticFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MagneticFlux.QuantityType;
+        public QuantityType Type => MagneticFlux<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MagneticFlux.BaseDimensions;
+        public BaseDimensions Dimensions => MagneticFlux<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MagneticFlux in Webers.
+        ///     Get <see cref="MagneticFlux{T}" /> in Webers.
         /// </summary>
-        public double Webers => As(MagneticFluxUnit.Weber);
+        public T Webers => As(MagneticFluxUnit.Weber);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(MagneticFluxUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MagneticFlux from Webers.
+        ///     Get <see cref="MagneticFlux{T}" /> from Webers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticFlux FromWebers(QuantityValue webers)
+        public static MagneticFlux<T> FromWebers(T webers)
         {
-            double value = (double) webers;
-            return new MagneticFlux(value, MagneticFluxUnit.Weber);
+            return new MagneticFlux<T>(webers, MagneticFluxUnit.Weber);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MagneticFluxUnit" /> to <see cref="MagneticFlux" />.
+        ///     Dynamically convert from value and unit enum <see cref="MagneticFluxUnit" /> to <see cref="MagneticFlux{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MagneticFlux unit value.</returns>
-        public static MagneticFlux From(QuantityValue value, MagneticFluxUnit fromUnit)
+        /// <returns><see cref="MagneticFlux{T}" /> unit value.</returns>
+        public static MagneticFlux<T> From(T value, MagneticFluxUnit fromUnit)
         {
-            return new MagneticFlux((double)value, fromUnit);
+            return new MagneticFlux<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static MagneticFlux From(QuantityValue value, MagneticFluxUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MagneticFlux Parse(string str)
+        public static MagneticFlux<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static MagneticFlux Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MagneticFlux Parse(string str, IFormatProvider? provider)
+        public static MagneticFlux<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MagneticFlux, MagneticFluxUnit>(
+            return QuantityParser.Default.Parse<T, MagneticFlux<T>, MagneticFluxUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static MagneticFlux Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MagneticFlux result)
+        public static bool TryParse(string? str, out MagneticFlux<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out MagneticFlux result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MagneticFlux result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MagneticFlux<T> result)
         {
-            return QuantityParser.Default.TryParse<MagneticFlux, MagneticFluxUnit>(
+            return QuantityParser.Default.TryParse<T, MagneticFlux<T>, MagneticFluxUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MagneticFlux operator -(MagneticFlux right)
+        public static MagneticFlux<T> operator -(MagneticFlux<T> right)
         {
-            return new MagneticFlux(-right.Value, right.Unit);
+            return new MagneticFlux<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticFlux"/> from adding two <see cref="MagneticFlux"/>.</summary>
-        public static MagneticFlux operator +(MagneticFlux left, MagneticFlux right)
+        /// <summary>Get <see cref="MagneticFlux{T}"/> from adding two <see cref="MagneticFlux{T}"/>.</summary>
+        public static MagneticFlux<T> operator +(MagneticFlux<T> left, MagneticFlux<T> right)
         {
-            return new MagneticFlux(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MagneticFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticFlux"/> from subtracting two <see cref="MagneticFlux"/>.</summary>
-        public static MagneticFlux operator -(MagneticFlux left, MagneticFlux right)
+        /// <summary>Get <see cref="MagneticFlux{T}"/> from subtracting two <see cref="MagneticFlux{T}"/>.</summary>
+        public static MagneticFlux<T> operator -(MagneticFlux<T> left, MagneticFlux<T> right)
         {
-            return new MagneticFlux(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MagneticFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticFlux"/> from multiplying value and <see cref="MagneticFlux"/>.</summary>
-        public static MagneticFlux operator *(double left, MagneticFlux right)
+        /// <summary>Get <see cref="MagneticFlux{T}"/> from multiplying value and <see cref="MagneticFlux{T}"/>.</summary>
+        public static MagneticFlux<T> operator *(T left, MagneticFlux<T> right)
         {
-            return new MagneticFlux(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MagneticFlux<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticFlux"/> from multiplying value and <see cref="MagneticFlux"/>.</summary>
-        public static MagneticFlux operator *(MagneticFlux left, double right)
+        /// <summary>Get <see cref="MagneticFlux{T}"/> from multiplying value and <see cref="MagneticFlux{T}"/>.</summary>
+        public static MagneticFlux<T> operator *(MagneticFlux<T> left, T right)
         {
-            return new MagneticFlux(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MagneticFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MagneticFlux"/> from dividing <see cref="MagneticFlux"/> by value.</summary>
-        public static MagneticFlux operator /(MagneticFlux left, double right)
+        /// <summary>Get <see cref="MagneticFlux{T}"/> from dividing <see cref="MagneticFlux{T}"/> by value.</summary>
+        public static MagneticFlux<T> operator /(MagneticFlux<T> left, T right)
         {
-            return new MagneticFlux(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MagneticFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MagneticFlux"/> by <see cref="MagneticFlux"/>.</summary>
-        public static double operator /(MagneticFlux left, MagneticFlux right)
+        /// <summary>Get ratio value from dividing <see cref="MagneticFlux{T}"/> by <see cref="MagneticFlux{T}"/>.</summary>
+        public static T operator /(MagneticFlux<T> left, MagneticFlux<T> right)
         {
-            return left.Webers / right.Webers;
+            return CompiledLambdas.Divide(left.Webers, right.Webers);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MagneticFlux left, MagneticFlux right)
+        public static bool operator <=(MagneticFlux<T> left, MagneticFlux<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MagneticFlux left, MagneticFlux right)
+        public static bool operator >=(MagneticFlux<T> left, MagneticFlux<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MagneticFlux left, MagneticFlux right)
+        public static bool operator <(MagneticFlux<T> left, MagneticFlux<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MagneticFlux left, MagneticFlux right)
+        public static bool operator >(MagneticFlux<T> left, MagneticFlux<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MagneticFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MagneticFlux left, MagneticFlux right)
+        /// <remarks>Consider using <see cref="Equals(MagneticFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MagneticFlux<T> left, MagneticFlux<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MagneticFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MagneticFlux left, MagneticFlux right)
+        /// <remarks>Consider using <see cref="Equals(MagneticFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MagneticFlux<T> left, MagneticFlux<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MagneticFlux objMagneticFlux)) throw new ArgumentException("Expected type MagneticFlux.", nameof(obj));
+            if(!(obj is MagneticFlux<T> objMagneticFlux)) throw new ArgumentException("Expected type MagneticFlux.", nameof(obj));
 
             return CompareTo(objMagneticFlux);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MagneticFlux other)
+        public int CompareTo(MagneticFlux<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MagneticFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MagneticFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MagneticFlux objMagneticFlux))
+            if(obj is null || !(obj is MagneticFlux<T> objMagneticFlux))
                 return false;
 
             return Equals(objMagneticFlux);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MagneticFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MagneticFlux other)
+        /// <remarks>Consider using <see cref="Equals(MagneticFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MagneticFlux<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MagneticFlux within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MagneticFlux{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(MagneticFlux other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MagneticFlux other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MagneticFlux<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MagneticFlux.</returns>
+        /// <returns>A hash code for the current <see cref="MagneticFlux{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MagneticFluxUnit unit)
+        public T As(MagneticFluxUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MagneticFluxUnit unitAsMagneticFluxUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFluxUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMagneticFluxUnit);
+            var asValue = As(unitAsMagneticFluxUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MagneticFluxUnit>.As(MagneticFluxUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MagneticFlux to another MagneticFlux with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MagneticFlux{T}" /> to another <see cref="MagneticFlux{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MagneticFlux with the specified unit.</returns>
-        public MagneticFlux ToUnit(MagneticFluxUnit unit)
+        /// <returns>A <see cref="MagneticFlux{T}" /> with the specified unit.</returns>
+        public MagneticFlux<T> ToUnit(MagneticFluxUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MagneticFlux(convertedValue, unit);
+            return new MagneticFlux<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MagneticFlux ToUnit(UnitSystem unitSystem)
+        public MagneticFlux<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public MagneticFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MagneticFluxUnit> IQuantity<MagneticFluxUnit>.ToUnit(MagneticFluxUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MagneticFluxUnit, T> IQuantityT<MagneticFluxUnit, T>.ToUnit(MagneticFluxUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MagneticFluxUnit> IQuantity<MagneticFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MagneticFluxUnit, T> IQuantityT<MagneticFluxUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MagneticFluxUnit.Weber: return _value;
+                case MagneticFluxUnit.Weber: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MagneticFlux ToBaseUnit()
+        internal MagneticFlux<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MagneticFlux(baseUnitValue, BaseUnit);
+            return new MagneticFlux<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MagneticFluxUnit unit)
+        private T GetValueAs(MagneticFluxUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MagneticFlux)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MagneticFlux<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MagneticFlux)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MagneticFlux<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MagneticFlux)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MagneticFlux<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MagneticFlux))
+            if(conversionType == typeof(MagneticFlux<T>))
                 return this;
             else if(conversionType == typeof(MagneticFluxUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MagneticFlux.QuantityType;
+                return MagneticFlux<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MagneticFlux.Info;
+                return MagneticFlux<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MagneticFlux.BaseDimensions;
+                return MagneticFlux<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MagneticFlux)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MagneticFlux<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
index 1fede64248..8a124dc347 100644
--- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Magnetization
     /// </remarks>
-    public partial struct Magnetization : IQuantity<MagnetizationUnit>, IEquatable<Magnetization>, IComparable, IComparable<Magnetization>, IConvertible, IFormattable
+    public partial struct Magnetization<T> : IQuantityT<MagnetizationUnit, T>, IEquatable<Magnetization<T>>, IComparable, IComparable<Magnetization<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static Magnetization()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Magnetization(double value, MagnetizationUnit unit)
+        public Magnetization(T value, MagnetizationUnit unit)
         {
             if(unit == MagnetizationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public Magnetization(double value, MagnetizationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Magnetization(double value, UnitSystem unitSystem)
+        public Magnetization(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public Magnetization(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Magnetization, which is AmperePerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Magnetization{T}" />, which is AmperePerMeter. All conversions go via this value.
         /// </summary>
         public static MagnetizationUnit BaseUnit { get; } = MagnetizationUnit.AmperePerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Magnetization
+        /// Represents the largest possible value of <see cref="Magnetization{T}" />
         /// </summary>
-        public static Magnetization MaxValue { get; } = new Magnetization(double.MaxValue, BaseUnit);
+        public static Magnetization<T> MaxValue { get; } = new Magnetization<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Magnetization
+        /// Represents the smallest possible value of <see cref="Magnetization{T}" />
         /// </summary>
-        public static Magnetization MinValue { get; } = new Magnetization(double.MinValue, BaseUnit);
+        public static Magnetization<T> MinValue { get; } = new Magnetization<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public Magnetization(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Magnetization;
 
         /// <summary>
-        ///     All units of measurement for the Magnetization quantity.
+        ///     All units of measurement for the <see cref="Magnetization{T}" /> quantity.
         /// </summary>
         public static MagnetizationUnit[] Units { get; } = Enum.GetValues(typeof(MagnetizationUnit)).Cast<MagnetizationUnit>().Except(new MagnetizationUnit[]{ MagnetizationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit AmperePerMeter.
         /// </summary>
-        public static Magnetization Zero { get; } = new Magnetization(0, BaseUnit);
+        public static Magnetization<T> Zero { get; } = new Magnetization<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public Magnetization(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public Magnetization(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Magnetization.QuantityType;
+        public QuantityType Type => Magnetization<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Magnetization.BaseDimensions;
+        public BaseDimensions Dimensions => Magnetization<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Magnetization in AmperesPerMeter.
+        ///     Get <see cref="Magnetization{T}" /> in AmperesPerMeter.
         /// </summary>
-        public double AmperesPerMeter => As(MagnetizationUnit.AmperePerMeter);
+        public T AmperesPerMeter => As(MagnetizationUnit.AmperePerMeter);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(MagnetizationUnit unit, IFormatProvider? pr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Magnetization from AmperesPerMeter.
+        ///     Get <see cref="Magnetization{T}" /> from AmperesPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Magnetization FromAmperesPerMeter(QuantityValue amperespermeter)
+        public static Magnetization<T> FromAmperesPerMeter(T amperespermeter)
         {
-            double value = (double) amperespermeter;
-            return new Magnetization(value, MagnetizationUnit.AmperePerMeter);
+            return new Magnetization<T>(amperespermeter, MagnetizationUnit.AmperePerMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MagnetizationUnit" /> to <see cref="Magnetization" />.
+        ///     Dynamically convert from value and unit enum <see cref="MagnetizationUnit" /> to <see cref="Magnetization{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Magnetization unit value.</returns>
-        public static Magnetization From(QuantityValue value, MagnetizationUnit fromUnit)
+        /// <returns><see cref="Magnetization{T}" /> unit value.</returns>
+        public static Magnetization<T> From(T value, MagnetizationUnit fromUnit)
         {
-            return new Magnetization((double)value, fromUnit);
+            return new Magnetization<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static Magnetization From(QuantityValue value, MagnetizationUnit fromUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Magnetization Parse(string str)
+        public static Magnetization<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static Magnetization Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Magnetization Parse(string str, IFormatProvider? provider)
+        public static Magnetization<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Magnetization, MagnetizationUnit>(
+            return QuantityParser.Default.Parse<T, Magnetization<T>, MagnetizationUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static Magnetization Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Magnetization result)
+        public static bool TryParse(string? str, out Magnetization<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out Magnetization result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Magnetization result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Magnetization<T> result)
         {
-            return QuantityParser.Default.TryParse<Magnetization, MagnetizationUnit>(
+            return QuantityParser.Default.TryParse<T, Magnetization<T>, MagnetizationUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Magnetization operator -(Magnetization right)
+        public static Magnetization<T> operator -(Magnetization<T> right)
         {
-            return new Magnetization(-right.Value, right.Unit);
+            return new Magnetization<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Magnetization"/> from adding two <see cref="Magnetization"/>.</summary>
-        public static Magnetization operator +(Magnetization left, Magnetization right)
+        /// <summary>Get <see cref="Magnetization{T}"/> from adding two <see cref="Magnetization{T}"/>.</summary>
+        public static Magnetization<T> operator +(Magnetization<T> left, Magnetization<T> right)
         {
-            return new Magnetization(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Magnetization<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Magnetization"/> from subtracting two <see cref="Magnetization"/>.</summary>
-        public static Magnetization operator -(Magnetization left, Magnetization right)
+        /// <summary>Get <see cref="Magnetization{T}"/> from subtracting two <see cref="Magnetization{T}"/>.</summary>
+        public static Magnetization<T> operator -(Magnetization<T> left, Magnetization<T> right)
         {
-            return new Magnetization(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Magnetization<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Magnetization"/> from multiplying value and <see cref="Magnetization"/>.</summary>
-        public static Magnetization operator *(double left, Magnetization right)
+        /// <summary>Get <see cref="Magnetization{T}"/> from multiplying value and <see cref="Magnetization{T}"/>.</summary>
+        public static Magnetization<T> operator *(T left, Magnetization<T> right)
         {
-            return new Magnetization(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Magnetization<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Magnetization"/> from multiplying value and <see cref="Magnetization"/>.</summary>
-        public static Magnetization operator *(Magnetization left, double right)
+        /// <summary>Get <see cref="Magnetization{T}"/> from multiplying value and <see cref="Magnetization{T}"/>.</summary>
+        public static Magnetization<T> operator *(Magnetization<T> left, T right)
         {
-            return new Magnetization(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Magnetization<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Magnetization"/> from dividing <see cref="Magnetization"/> by value.</summary>
-        public static Magnetization operator /(Magnetization left, double right)
+        /// <summary>Get <see cref="Magnetization{T}"/> from dividing <see cref="Magnetization{T}"/> by value.</summary>
+        public static Magnetization<T> operator /(Magnetization<T> left, T right)
         {
-            return new Magnetization(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Magnetization<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Magnetization"/> by <see cref="Magnetization"/>.</summary>
-        public static double operator /(Magnetization left, Magnetization right)
+        /// <summary>Get ratio value from dividing <see cref="Magnetization{T}"/> by <see cref="Magnetization{T}"/>.</summary>
+        public static T operator /(Magnetization<T> left, Magnetization<T> right)
         {
-            return left.AmperesPerMeter / right.AmperesPerMeter;
+            return CompiledLambdas.Divide(left.AmperesPerMeter, right.AmperesPerMeter);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Magnetization left, Magnetization right)
+        public static bool operator <=(Magnetization<T> left, Magnetization<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Magnetization left, Magnetization right)
+        public static bool operator >=(Magnetization<T> left, Magnetization<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Magnetization left, Magnetization right)
+        public static bool operator <(Magnetization<T> left, Magnetization<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Magnetization left, Magnetization right)
+        public static bool operator >(Magnetization<T> left, Magnetization<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Magnetization, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Magnetization left, Magnetization right)
+        /// <remarks>Consider using <see cref="Equals(Magnetization{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Magnetization<T> left, Magnetization<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Magnetization, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Magnetization left, Magnetization right)
+        /// <remarks>Consider using <see cref="Equals(Magnetization{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Magnetization<T> left, Magnetization<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Magne
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Magnetization objMagnetization)) throw new ArgumentException("Expected type Magnetization.", nameof(obj));
+            if(!(obj is Magnetization<T> objMagnetization)) throw new ArgumentException("Expected type Magnetization.", nameof(obj));
 
             return CompareTo(objMagnetization);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Magnetization other)
+        public int CompareTo(Magnetization<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Magnetization, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Magnetization{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Magnetization objMagnetization))
+            if(obj is null || !(obj is Magnetization<T> objMagnetization))
                 return false;
 
             return Equals(objMagnetization);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Magnetization, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Magnetization other)
+        /// <remarks>Consider using <see cref="Equals(Magnetization{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Magnetization<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Magnetization within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Magnetization{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(Magnetization other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Magnetization other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Magnetization<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Magnetization.</returns>
+        /// <returns>A hash code for the current <see cref="Magnetization{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MagnetizationUnit unit)
+        public T As(MagnetizationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MagnetizationUnit unitAsMagnetizationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagnetizationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMagnetizationUnit);
+            var asValue = As(unitAsMagnetizationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MagnetizationUnit>.As(MagnetizationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Magnetization to another Magnetization with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Magnetization{T}" /> to another <see cref="Magnetization{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Magnetization with the specified unit.</returns>
-        public Magnetization ToUnit(MagnetizationUnit unit)
+        /// <returns>A <see cref="Magnetization{T}" /> with the specified unit.</returns>
+        public Magnetization<T> ToUnit(MagnetizationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Magnetization(convertedValue, unit);
+            return new Magnetization<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Magnetization ToUnit(UnitSystem unitSystem)
+        public Magnetization<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public Magnetization ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MagnetizationUnit> IQuantity<MagnetizationUnit>.ToUnit(MagnetizationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MagnetizationUnit, T> IQuantityT<MagnetizationUnit, T>.ToUnit(MagnetizationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MagnetizationUnit> IQuantity<MagnetizationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MagnetizationUnit, T> IQuantityT<MagnetizationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MagnetizationUnit.AmperePerMeter: return _value;
+                case MagnetizationUnit.AmperePerMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Magnetization ToBaseUnit()
+        internal Magnetization<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Magnetization(baseUnitValue, BaseUnit);
+            return new Magnetization<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MagnetizationUnit unit)
+        private T GetValueAs(MagnetizationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Magnetization)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Magnetization<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Magnetization)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Magnetization<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Magnetization)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Magnetization<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Magnetization))
+            if(conversionType == typeof(Magnetization<T>))
                 return this;
             else if(conversionType == typeof(MagnetizationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Magnetization.QuantityType;
+                return Magnetization<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Magnetization.Info;
+                return Magnetization<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Magnetization.BaseDimensions;
+                return Magnetization<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Magnetization)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Magnetization<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
index 9056e68f35..d0a48a4737 100644
--- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In physics, mass (from Greek μᾶζα "barley cake, lump [of dough]") is a property of a physical system or body, giving rise to the phenomena of the body's resistance to being accelerated by a force and the strength of its mutual gravitational attraction with other bodies. Instruments such as mass balances or scales use those phenomena to measure mass. The SI unit of mass is the kilogram (kg).
     /// </summary>
-    public partial struct Mass : IQuantity<MassUnit>, IEquatable<Mass>, IComparable, IComparable<Mass>, IConvertible, IFormattable
+    public partial struct Mass<T> : IQuantityT<MassUnit, T>, IEquatable<Mass<T>>, IComparable, IComparable<Mass<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -87,12 +83,12 @@ static Mass()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Mass(double value, MassUnit unit)
+        public Mass(T value, MassUnit unit)
         {
             if(unit == MassUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -104,14 +100,14 @@ public Mass(double value, MassUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Mass(double value, UnitSystem unitSystem)
+        public Mass(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -126,19 +122,19 @@ public Mass(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Mass, which is Kilogram. All conversions go via this value.
+        ///     The base unit of <see cref="Mass{T}" />, which is Kilogram. All conversions go via this value.
         /// </summary>
         public static MassUnit BaseUnit { get; } = MassUnit.Kilogram;
 
         /// <summary>
-        /// Represents the largest possible value of Mass
+        /// Represents the largest possible value of <see cref="Mass{T}" />
         /// </summary>
-        public static Mass MaxValue { get; } = new Mass(double.MaxValue, BaseUnit);
+        public static Mass<T> MaxValue { get; } = new Mass<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Mass
+        /// Represents the smallest possible value of <see cref="Mass{T}" />
         /// </summary>
-        public static Mass MinValue { get; } = new Mass(double.MinValue, BaseUnit);
+        public static Mass<T> MinValue { get; } = new Mass<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -147,14 +143,14 @@ public Mass(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Mass;
 
         /// <summary>
-        ///     All units of measurement for the Mass quantity.
+        ///     All units of measurement for the <see cref="Mass{T}" /> quantity.
         /// </summary>
         public static MassUnit[] Units { get; } = Enum.GetValues(typeof(MassUnit)).Cast<MassUnit>().Except(new MassUnit[]{ MassUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Kilogram.
         /// </summary>
-        public static Mass Zero { get; } = new Mass(0, BaseUnit);
+        public static Mass<T> Zero { get; } = new Mass<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -163,7 +159,9 @@ public Mass(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -179,141 +177,141 @@ public Mass(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Mass.QuantityType;
+        public QuantityType Type => Mass<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Mass.BaseDimensions;
+        public BaseDimensions Dimensions => Mass<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Mass in Centigrams.
+        ///     Get <see cref="Mass{T}" /> in Centigrams.
         /// </summary>
-        public double Centigrams => As(MassUnit.Centigram);
+        public T Centigrams => As(MassUnit.Centigram);
 
         /// <summary>
-        ///     Get Mass in Decagrams.
+        ///     Get <see cref="Mass{T}" /> in Decagrams.
         /// </summary>
-        public double Decagrams => As(MassUnit.Decagram);
+        public T Decagrams => As(MassUnit.Decagram);
 
         /// <summary>
-        ///     Get Mass in Decigrams.
+        ///     Get <see cref="Mass{T}" /> in Decigrams.
         /// </summary>
-        public double Decigrams => As(MassUnit.Decigram);
+        public T Decigrams => As(MassUnit.Decigram);
 
         /// <summary>
-        ///     Get Mass in EarthMasses.
+        ///     Get <see cref="Mass{T}" /> in EarthMasses.
         /// </summary>
-        public double EarthMasses => As(MassUnit.EarthMass);
+        public T EarthMasses => As(MassUnit.EarthMass);
 
         /// <summary>
-        ///     Get Mass in Grains.
+        ///     Get <see cref="Mass{T}" /> in Grains.
         /// </summary>
-        public double Grains => As(MassUnit.Grain);
+        public T Grains => As(MassUnit.Grain);
 
         /// <summary>
-        ///     Get Mass in Grams.
+        ///     Get <see cref="Mass{T}" /> in Grams.
         /// </summary>
-        public double Grams => As(MassUnit.Gram);
+        public T Grams => As(MassUnit.Gram);
 
         /// <summary>
-        ///     Get Mass in Hectograms.
+        ///     Get <see cref="Mass{T}" /> in Hectograms.
         /// </summary>
-        public double Hectograms => As(MassUnit.Hectogram);
+        public T Hectograms => As(MassUnit.Hectogram);
 
         /// <summary>
-        ///     Get Mass in Kilograms.
+        ///     Get <see cref="Mass{T}" /> in Kilograms.
         /// </summary>
-        public double Kilograms => As(MassUnit.Kilogram);
+        public T Kilograms => As(MassUnit.Kilogram);
 
         /// <summary>
-        ///     Get Mass in Kilopounds.
+        ///     Get <see cref="Mass{T}" /> in Kilopounds.
         /// </summary>
-        public double Kilopounds => As(MassUnit.Kilopound);
+        public T Kilopounds => As(MassUnit.Kilopound);
 
         /// <summary>
-        ///     Get Mass in Kilotonnes.
+        ///     Get <see cref="Mass{T}" /> in Kilotonnes.
         /// </summary>
-        public double Kilotonnes => As(MassUnit.Kilotonne);
+        public T Kilotonnes => As(MassUnit.Kilotonne);
 
         /// <summary>
-        ///     Get Mass in LongHundredweight.
+        ///     Get <see cref="Mass{T}" /> in LongHundredweight.
         /// </summary>
-        public double LongHundredweight => As(MassUnit.LongHundredweight);
+        public T LongHundredweight => As(MassUnit.LongHundredweight);
 
         /// <summary>
-        ///     Get Mass in LongTons.
+        ///     Get <see cref="Mass{T}" /> in LongTons.
         /// </summary>
-        public double LongTons => As(MassUnit.LongTon);
+        public T LongTons => As(MassUnit.LongTon);
 
         /// <summary>
-        ///     Get Mass in Megapounds.
+        ///     Get <see cref="Mass{T}" /> in Megapounds.
         /// </summary>
-        public double Megapounds => As(MassUnit.Megapound);
+        public T Megapounds => As(MassUnit.Megapound);
 
         /// <summary>
-        ///     Get Mass in Megatonnes.
+        ///     Get <see cref="Mass{T}" /> in Megatonnes.
         /// </summary>
-        public double Megatonnes => As(MassUnit.Megatonne);
+        public T Megatonnes => As(MassUnit.Megatonne);
 
         /// <summary>
-        ///     Get Mass in Micrograms.
+        ///     Get <see cref="Mass{T}" /> in Micrograms.
         /// </summary>
-        public double Micrograms => As(MassUnit.Microgram);
+        public T Micrograms => As(MassUnit.Microgram);
 
         /// <summary>
-        ///     Get Mass in Milligrams.
+        ///     Get <see cref="Mass{T}" /> in Milligrams.
         /// </summary>
-        public double Milligrams => As(MassUnit.Milligram);
+        public T Milligrams => As(MassUnit.Milligram);
 
         /// <summary>
-        ///     Get Mass in Nanograms.
+        ///     Get <see cref="Mass{T}" /> in Nanograms.
         /// </summary>
-        public double Nanograms => As(MassUnit.Nanogram);
+        public T Nanograms => As(MassUnit.Nanogram);
 
         /// <summary>
-        ///     Get Mass in Ounces.
+        ///     Get <see cref="Mass{T}" /> in Ounces.
         /// </summary>
-        public double Ounces => As(MassUnit.Ounce);
+        public T Ounces => As(MassUnit.Ounce);
 
         /// <summary>
-        ///     Get Mass in Pounds.
+        ///     Get <see cref="Mass{T}" /> in Pounds.
         /// </summary>
-        public double Pounds => As(MassUnit.Pound);
+        public T Pounds => As(MassUnit.Pound);
 
         /// <summary>
-        ///     Get Mass in ShortHundredweight.
+        ///     Get <see cref="Mass{T}" /> in ShortHundredweight.
         /// </summary>
-        public double ShortHundredweight => As(MassUnit.ShortHundredweight);
+        public T ShortHundredweight => As(MassUnit.ShortHundredweight);
 
         /// <summary>
-        ///     Get Mass in ShortTons.
+        ///     Get <see cref="Mass{T}" /> in ShortTons.
         /// </summary>
-        public double ShortTons => As(MassUnit.ShortTon);
+        public T ShortTons => As(MassUnit.ShortTon);
 
         /// <summary>
-        ///     Get Mass in Slugs.
+        ///     Get <see cref="Mass{T}" /> in Slugs.
         /// </summary>
-        public double Slugs => As(MassUnit.Slug);
+        public T Slugs => As(MassUnit.Slug);
 
         /// <summary>
-        ///     Get Mass in SolarMasses.
+        ///     Get <see cref="Mass{T}" /> in SolarMasses.
         /// </summary>
-        public double SolarMasses => As(MassUnit.SolarMass);
+        public T SolarMasses => As(MassUnit.SolarMass);
 
         /// <summary>
-        ///     Get Mass in Stone.
+        ///     Get <see cref="Mass{T}" /> in Stone.
         /// </summary>
-        public double Stone => As(MassUnit.Stone);
+        public T Stone => As(MassUnit.Stone);
 
         /// <summary>
-        ///     Get Mass in Tonnes.
+        ///     Get <see cref="Mass{T}" /> in Tonnes.
         /// </summary>
-        public double Tonnes => As(MassUnit.Tonne);
+        public T Tonnes => As(MassUnit.Tonne);
 
         #endregion
 
@@ -345,240 +343,215 @@ public static string GetAbbreviation(MassUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Mass from Centigrams.
+        ///     Get <see cref="Mass{T}" /> from Centigrams.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromCentigrams(QuantityValue centigrams)
+        public static Mass<T> FromCentigrams(T centigrams)
         {
-            double value = (double) centigrams;
-            return new Mass(value, MassUnit.Centigram);
+            return new Mass<T>(centigrams, MassUnit.Centigram);
         }
         /// <summary>
-        ///     Get Mass from Decagrams.
+        ///     Get <see cref="Mass{T}" /> from Decagrams.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromDecagrams(QuantityValue decagrams)
+        public static Mass<T> FromDecagrams(T decagrams)
         {
-            double value = (double) decagrams;
-            return new Mass(value, MassUnit.Decagram);
+            return new Mass<T>(decagrams, MassUnit.Decagram);
         }
         /// <summary>
-        ///     Get Mass from Decigrams.
+        ///     Get <see cref="Mass{T}" /> from Decigrams.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromDecigrams(QuantityValue decigrams)
+        public static Mass<T> FromDecigrams(T decigrams)
         {
-            double value = (double) decigrams;
-            return new Mass(value, MassUnit.Decigram);
+            return new Mass<T>(decigrams, MassUnit.Decigram);
         }
         /// <summary>
-        ///     Get Mass from EarthMasses.
+        ///     Get <see cref="Mass{T}" /> from EarthMasses.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromEarthMasses(QuantityValue earthmasses)
+        public static Mass<T> FromEarthMasses(T earthmasses)
         {
-            double value = (double) earthmasses;
-            return new Mass(value, MassUnit.EarthMass);
+            return new Mass<T>(earthmasses, MassUnit.EarthMass);
         }
         /// <summary>
-        ///     Get Mass from Grains.
+        ///     Get <see cref="Mass{T}" /> from Grains.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromGrains(QuantityValue grains)
+        public static Mass<T> FromGrains(T grains)
         {
-            double value = (double) grains;
-            return new Mass(value, MassUnit.Grain);
+            return new Mass<T>(grains, MassUnit.Grain);
         }
         /// <summary>
-        ///     Get Mass from Grams.
+        ///     Get <see cref="Mass{T}" /> from Grams.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromGrams(QuantityValue grams)
+        public static Mass<T> FromGrams(T grams)
         {
-            double value = (double) grams;
-            return new Mass(value, MassUnit.Gram);
+            return new Mass<T>(grams, MassUnit.Gram);
         }
         /// <summary>
-        ///     Get Mass from Hectograms.
+        ///     Get <see cref="Mass{T}" /> from Hectograms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromHectograms(QuantityValue hectograms)
+        public static Mass<T> FromHectograms(T hectograms)
         {
-            double value = (double) hectograms;
-            return new Mass(value, MassUnit.Hectogram);
+            return new Mass<T>(hectograms, MassUnit.Hectogram);
         }
         /// <summary>
-        ///     Get Mass from Kilograms.
+        ///     Get <see cref="Mass{T}" /> from Kilograms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilograms(QuantityValue kilograms)
+        public static Mass<T> FromKilograms(T kilograms)
         {
-            double value = (double) kilograms;
-            return new Mass(value, MassUnit.Kilogram);
+            return new Mass<T>(kilograms, MassUnit.Kilogram);
         }
         /// <summary>
-        ///     Get Mass from Kilopounds.
+        ///     Get <see cref="Mass{T}" /> from Kilopounds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilopounds(QuantityValue kilopounds)
+        public static Mass<T> FromKilopounds(T kilopounds)
         {
-            double value = (double) kilopounds;
-            return new Mass(value, MassUnit.Kilopound);
+            return new Mass<T>(kilopounds, MassUnit.Kilopound);
         }
         /// <summary>
-        ///     Get Mass from Kilotonnes.
+        ///     Get <see cref="Mass{T}" /> from Kilotonnes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilotonnes(QuantityValue kilotonnes)
+        public static Mass<T> FromKilotonnes(T kilotonnes)
         {
-            double value = (double) kilotonnes;
-            return new Mass(value, MassUnit.Kilotonne);
+            return new Mass<T>(kilotonnes, MassUnit.Kilotonne);
         }
         /// <summary>
-        ///     Get Mass from LongHundredweight.
+        ///     Get <see cref="Mass{T}" /> from LongHundredweight.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromLongHundredweight(QuantityValue longhundredweight)
+        public static Mass<T> FromLongHundredweight(T longhundredweight)
         {
-            double value = (double) longhundredweight;
-            return new Mass(value, MassUnit.LongHundredweight);
+            return new Mass<T>(longhundredweight, MassUnit.LongHundredweight);
         }
         /// <summary>
-        ///     Get Mass from LongTons.
+        ///     Get <see cref="Mass{T}" /> from LongTons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromLongTons(QuantityValue longtons)
+        public static Mass<T> FromLongTons(T longtons)
         {
-            double value = (double) longtons;
-            return new Mass(value, MassUnit.LongTon);
+            return new Mass<T>(longtons, MassUnit.LongTon);
         }
         /// <summary>
-        ///     Get Mass from Megapounds.
+        ///     Get <see cref="Mass{T}" /> from Megapounds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMegapounds(QuantityValue megapounds)
+        public static Mass<T> FromMegapounds(T megapounds)
         {
-            double value = (double) megapounds;
-            return new Mass(value, MassUnit.Megapound);
+            return new Mass<T>(megapounds, MassUnit.Megapound);
         }
         /// <summary>
-        ///     Get Mass from Megatonnes.
+        ///     Get <see cref="Mass{T}" /> from Megatonnes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMegatonnes(QuantityValue megatonnes)
+        public static Mass<T> FromMegatonnes(T megatonnes)
         {
-            double value = (double) megatonnes;
-            return new Mass(value, MassUnit.Megatonne);
+            return new Mass<T>(megatonnes, MassUnit.Megatonne);
         }
         /// <summary>
-        ///     Get Mass from Micrograms.
+        ///     Get <see cref="Mass{T}" /> from Micrograms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMicrograms(QuantityValue micrograms)
+        public static Mass<T> FromMicrograms(T micrograms)
         {
-            double value = (double) micrograms;
-            return new Mass(value, MassUnit.Microgram);
+            return new Mass<T>(micrograms, MassUnit.Microgram);
         }
         /// <summary>
-        ///     Get Mass from Milligrams.
+        ///     Get <see cref="Mass{T}" /> from Milligrams.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMilligrams(QuantityValue milligrams)
+        public static Mass<T> FromMilligrams(T milligrams)
         {
-            double value = (double) milligrams;
-            return new Mass(value, MassUnit.Milligram);
+            return new Mass<T>(milligrams, MassUnit.Milligram);
         }
         /// <summary>
-        ///     Get Mass from Nanograms.
+        ///     Get <see cref="Mass{T}" /> from Nanograms.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromNanograms(QuantityValue nanograms)
+        public static Mass<T> FromNanograms(T nanograms)
         {
-            double value = (double) nanograms;
-            return new Mass(value, MassUnit.Nanogram);
+            return new Mass<T>(nanograms, MassUnit.Nanogram);
         }
         /// <summary>
-        ///     Get Mass from Ounces.
+        ///     Get <see cref="Mass{T}" /> from Ounces.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromOunces(QuantityValue ounces)
+        public static Mass<T> FromOunces(T ounces)
         {
-            double value = (double) ounces;
-            return new Mass(value, MassUnit.Ounce);
+            return new Mass<T>(ounces, MassUnit.Ounce);
         }
         /// <summary>
-        ///     Get Mass from Pounds.
+        ///     Get <see cref="Mass{T}" /> from Pounds.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromPounds(QuantityValue pounds)
+        public static Mass<T> FromPounds(T pounds)
         {
-            double value = (double) pounds;
-            return new Mass(value, MassUnit.Pound);
+            return new Mass<T>(pounds, MassUnit.Pound);
         }
         /// <summary>
-        ///     Get Mass from ShortHundredweight.
+        ///     Get <see cref="Mass{T}" /> from ShortHundredweight.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromShortHundredweight(QuantityValue shorthundredweight)
+        public static Mass<T> FromShortHundredweight(T shorthundredweight)
         {
-            double value = (double) shorthundredweight;
-            return new Mass(value, MassUnit.ShortHundredweight);
+            return new Mass<T>(shorthundredweight, MassUnit.ShortHundredweight);
         }
         /// <summary>
-        ///     Get Mass from ShortTons.
+        ///     Get <see cref="Mass{T}" /> from ShortTons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromShortTons(QuantityValue shorttons)
+        public static Mass<T> FromShortTons(T shorttons)
         {
-            double value = (double) shorttons;
-            return new Mass(value, MassUnit.ShortTon);
+            return new Mass<T>(shorttons, MassUnit.ShortTon);
         }
         /// <summary>
-        ///     Get Mass from Slugs.
+        ///     Get <see cref="Mass{T}" /> from Slugs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromSlugs(QuantityValue slugs)
+        public static Mass<T> FromSlugs(T slugs)
         {
-            double value = (double) slugs;
-            return new Mass(value, MassUnit.Slug);
+            return new Mass<T>(slugs, MassUnit.Slug);
         }
         /// <summary>
-        ///     Get Mass from SolarMasses.
+        ///     Get <see cref="Mass{T}" /> from SolarMasses.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromSolarMasses(QuantityValue solarmasses)
+        public static Mass<T> FromSolarMasses(T solarmasses)
         {
-            double value = (double) solarmasses;
-            return new Mass(value, MassUnit.SolarMass);
+            return new Mass<T>(solarmasses, MassUnit.SolarMass);
         }
         /// <summary>
-        ///     Get Mass from Stone.
+        ///     Get <see cref="Mass{T}" /> from Stone.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromStone(QuantityValue stone)
+        public static Mass<T> FromStone(T stone)
         {
-            double value = (double) stone;
-            return new Mass(value, MassUnit.Stone);
+            return new Mass<T>(stone, MassUnit.Stone);
         }
         /// <summary>
-        ///     Get Mass from Tonnes.
+        ///     Get <see cref="Mass{T}" /> from Tonnes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromTonnes(QuantityValue tonnes)
+        public static Mass<T> FromTonnes(T tonnes)
         {
-            double value = (double) tonnes;
-            return new Mass(value, MassUnit.Tonne);
+            return new Mass<T>(tonnes, MassUnit.Tonne);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassUnit" /> to <see cref="Mass" />.
+        ///     Dynamically convert from value and unit enum <see cref="MassUnit" /> to <see cref="Mass{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Mass unit value.</returns>
-        public static Mass From(QuantityValue value, MassUnit fromUnit)
+        /// <returns><see cref="Mass{T}" /> unit value.</returns>
+        public static Mass<T> From(T value, MassUnit fromUnit)
         {
-            return new Mass((double)value, fromUnit);
+            return new Mass<T>(value, fromUnit);
         }
 
         #endregion
@@ -607,7 +580,7 @@ public static Mass From(QuantityValue value, MassUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Mass Parse(string str)
+        public static Mass<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -635,9 +608,9 @@ public static Mass Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Mass Parse(string str, IFormatProvider? provider)
+        public static Mass<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Mass, MassUnit>(
+            return QuantityParser.Default.Parse<T, Mass<T>, MassUnit>(
                 str,
                 provider,
                 From);
@@ -651,7 +624,7 @@ public static Mass Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Mass result)
+        public static bool TryParse(string? str, out Mass<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -666,9 +639,9 @@ public static bool TryParse(string? str, out Mass result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Mass result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Mass<T> result)
         {
-            return QuantityParser.Default.TryParse<Mass, MassUnit>(
+            return QuantityParser.Default.TryParse<T, Mass<T>, MassUnit>(
                 str,
                 provider,
                 From,
@@ -730,45 +703,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassU
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Mass operator -(Mass right)
+        public static Mass<T> operator -(Mass<T> right)
         {
-            return new Mass(-right.Value, right.Unit);
+            return new Mass<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Mass"/> from adding two <see cref="Mass"/>.</summary>
-        public static Mass operator +(Mass left, Mass right)
+        /// <summary>Get <see cref="Mass{T}"/> from adding two <see cref="Mass{T}"/>.</summary>
+        public static Mass<T> operator +(Mass<T> left, Mass<T> right)
         {
-            return new Mass(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Mass<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Mass"/> from subtracting two <see cref="Mass"/>.</summary>
-        public static Mass operator -(Mass left, Mass right)
+        /// <summary>Get <see cref="Mass{T}"/> from subtracting two <see cref="Mass{T}"/>.</summary>
+        public static Mass<T> operator -(Mass<T> left, Mass<T> right)
         {
-            return new Mass(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Mass<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Mass"/> from multiplying value and <see cref="Mass"/>.</summary>
-        public static Mass operator *(double left, Mass right)
+        /// <summary>Get <see cref="Mass{T}"/> from multiplying value and <see cref="Mass{T}"/>.</summary>
+        public static Mass<T> operator *(T left, Mass<T> right)
         {
-            return new Mass(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Mass<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Mass"/> from multiplying value and <see cref="Mass"/>.</summary>
-        public static Mass operator *(Mass left, double right)
+        /// <summary>Get <see cref="Mass{T}"/> from multiplying value and <see cref="Mass{T}"/>.</summary>
+        public static Mass<T> operator *(Mass<T> left, T right)
         {
-            return new Mass(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Mass<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Mass"/> from dividing <see cref="Mass"/> by value.</summary>
-        public static Mass operator /(Mass left, double right)
+        /// <summary>Get <see cref="Mass{T}"/> from dividing <see cref="Mass{T}"/> by value.</summary>
+        public static Mass<T> operator /(Mass<T> left, T right)
         {
-            return new Mass(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Mass<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Mass"/> by <see cref="Mass"/>.</summary>
-        public static double operator /(Mass left, Mass right)
+        /// <summary>Get ratio value from dividing <see cref="Mass{T}"/> by <see cref="Mass{T}"/>.</summary>
+        public static T operator /(Mass<T> left, Mass<T> right)
         {
-            return left.Kilograms / right.Kilograms;
+            return CompiledLambdas.Divide(left.Kilograms, right.Kilograms);
         }
 
         #endregion
@@ -776,39 +754,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassU
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Mass left, Mass right)
+        public static bool operator <=(Mass<T> left, Mass<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Mass left, Mass right)
+        public static bool operator >=(Mass<T> left, Mass<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Mass left, Mass right)
+        public static bool operator <(Mass<T> left, Mass<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Mass left, Mass right)
+        public static bool operator >(Mass<T> left, Mass<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Mass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Mass left, Mass right)
+        /// <remarks>Consider using <see cref="Equals(Mass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Mass<T> left, Mass<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Mass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Mass left, Mass right)
+        /// <remarks>Consider using <see cref="Equals(Mass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Mass<T> left, Mass<T> right)
         {
             return !(left == right);
         }
@@ -817,37 +795,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassU
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Mass objMass)) throw new ArgumentException("Expected type Mass.", nameof(obj));
+            if(!(obj is Mass<T> objMass)) throw new ArgumentException("Expected type Mass.", nameof(obj));
 
             return CompareTo(objMass);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Mass other)
+        public int CompareTo(Mass<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Mass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Mass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Mass objMass))
+            if(obj is null || !(obj is Mass<T> objMass))
                 return false;
 
             return Equals(objMass);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Mass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Mass other)
+        /// <remarks>Consider using <see cref="Equals(Mass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Mass<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Mass within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Mass{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -885,21 +863,19 @@ public bool Equals(Mass other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Mass other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Mass<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Mass.</returns>
+        /// <returns>A hash code for the current <see cref="Mass{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -913,17 +889,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassUnit unit)
+        public T As(MassUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -943,17 +919,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MassUnit unitAsMassUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMassUnit);
+            var asValue = As(unitAsMassUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MassUnit>.As(MassUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Mass to another Mass with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Mass{T}" /> to another <see cref="Mass{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Mass with the specified unit.</returns>
-        public Mass ToUnit(MassUnit unit)
+        /// <returns>A <see cref="Mass{T}" /> with the specified unit.</returns>
+        public Mass<T> ToUnit(MassUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Mass(convertedValue, unit);
+            return new Mass<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -966,7 +947,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Mass ToUnit(UnitSystem unitSystem)
+        public Mass<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -986,43 +967,49 @@ public Mass ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassUnit> IQuantity<MassUnit>.ToUnit(MassUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MassUnit, T> IQuantityT<MassUnit, T>.ToUnit(MassUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MassUnit> IQuantity<MassUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MassUnit, T> IQuantityT<MassUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MassUnit.Centigram: return (_value/1e3) * 1e-2d;
-                case MassUnit.Decagram: return (_value/1e3) * 1e1d;
-                case MassUnit.Decigram: return (_value/1e3) * 1e-1d;
-                case MassUnit.EarthMass: return _value * 5.9722E+24;
-                case MassUnit.Grain: return _value/15432.358352941431;
-                case MassUnit.Gram: return _value/1e3;
-                case MassUnit.Hectogram: return (_value/1e3) * 1e2d;
-                case MassUnit.Kilogram: return (_value/1e3) * 1e3d;
-                case MassUnit.Kilopound: return (_value*0.45359237) * 1e3d;
-                case MassUnit.Kilotonne: return (_value*1e3) * 1e3d;
-                case MassUnit.LongHundredweight: return _value/0.01968413055222121;
-                case MassUnit.LongTon: return _value*1.0160469088e3;
-                case MassUnit.Megapound: return (_value*0.45359237) * 1e6d;
-                case MassUnit.Megatonne: return (_value*1e3) * 1e6d;
-                case MassUnit.Microgram: return (_value/1e3) * 1e-6d;
-                case MassUnit.Milligram: return (_value/1e3) * 1e-3d;
-                case MassUnit.Nanogram: return (_value/1e3) * 1e-9d;
-                case MassUnit.Ounce: return _value/35.2739619;
-                case MassUnit.Pound: return _value*0.45359237;
-                case MassUnit.ShortHundredweight: return _value/0.022046226218487758;
-                case MassUnit.ShortTon: return _value*9.0718474e2;
-                case MassUnit.Slug: return _value/6.852176556196105e-2;
-                case MassUnit.SolarMass: return _value * 1.98947e30;
-                case MassUnit.Stone: return _value/0.1574731728702698;
-                case MassUnit.Tonne: return _value*1e3;
+                case MassUnit.Centigram: return (Value/1e3) * 1e-2d;
+                case MassUnit.Decagram: return (Value/1e3) * 1e1d;
+                case MassUnit.Decigram: return (Value/1e3) * 1e-1d;
+                case MassUnit.EarthMass: return Value * 5.9722E+24;
+                case MassUnit.Grain: return Value/15432.358352941431;
+                case MassUnit.Gram: return Value/1e3;
+                case MassUnit.Hectogram: return (Value/1e3) * 1e2d;
+                case MassUnit.Kilogram: return (Value/1e3) * 1e3d;
+                case MassUnit.Kilopound: return (Value*0.45359237) * 1e3d;
+                case MassUnit.Kilotonne: return (Value*1e3) * 1e3d;
+                case MassUnit.LongHundredweight: return Value/0.01968413055222121;
+                case MassUnit.LongTon: return Value*1.0160469088e3;
+                case MassUnit.Megapound: return (Value*0.45359237) * 1e6d;
+                case MassUnit.Megatonne: return (Value*1e3) * 1e6d;
+                case MassUnit.Microgram: return (Value/1e3) * 1e-6d;
+                case MassUnit.Milligram: return (Value/1e3) * 1e-3d;
+                case MassUnit.Nanogram: return (Value/1e3) * 1e-9d;
+                case MassUnit.Ounce: return Value/35.2739619;
+                case MassUnit.Pound: return Value*0.45359237;
+                case MassUnit.ShortHundredweight: return Value/0.022046226218487758;
+                case MassUnit.ShortTon: return Value*9.0718474e2;
+                case MassUnit.Slug: return Value/6.852176556196105e-2;
+                case MassUnit.SolarMass: return Value * 1.98947e30;
+                case MassUnit.Stone: return Value/0.1574731728702698;
+                case MassUnit.Tonne: return Value*1e3;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1033,16 +1020,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Mass ToBaseUnit()
+        internal Mass<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Mass(baseUnitValue, BaseUnit);
+            return new Mass<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MassUnit unit)
+        private T GetValueAs(MassUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1169,57 +1156,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Mass)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Mass<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Mass)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Mass<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Mass)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Mass<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1229,33 +1216,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Mass))
+            if(conversionType == typeof(Mass<T>))
                 return this;
             else if(conversionType == typeof(MassUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Mass.QuantityType;
+                return Mass<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Mass.Info;
+                return Mass<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Mass.BaseDimensions;
+                return Mass<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Mass)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Mass<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
index 0118358461..9a1a8a53ef 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Mass_concentration_(chemistry)
     /// </remarks>
-    public partial struct MassConcentration : IQuantity<MassConcentrationUnit>, IEquatable<MassConcentration>, IComparable, IComparable<MassConcentration>, IConvertible, IFormattable
+    public partial struct MassConcentration<T> : IQuantityT<MassConcentrationUnit, T>, IEquatable<MassConcentration<T>>, IComparable, IComparable<MassConcentration<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -112,12 +108,12 @@ static MassConcentration()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MassConcentration(double value, MassConcentrationUnit unit)
+        public MassConcentration(T value, MassConcentrationUnit unit)
         {
             if(unit == MassConcentrationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -129,14 +125,14 @@ public MassConcentration(double value, MassConcentrationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassConcentration(double value, UnitSystem unitSystem)
+        public MassConcentration(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -151,19 +147,19 @@ public MassConcentration(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MassConcentration, which is KilogramPerCubicMeter. All conversions go via this value.
+        ///     The base unit of <see cref="MassConcentration{T}" />, which is KilogramPerCubicMeter. All conversions go via this value.
         /// </summary>
         public static MassConcentrationUnit BaseUnit { get; } = MassConcentrationUnit.KilogramPerCubicMeter;
 
         /// <summary>
-        /// Represents the largest possible value of MassConcentration
+        /// Represents the largest possible value of <see cref="MassConcentration{T}" />
         /// </summary>
-        public static MassConcentration MaxValue { get; } = new MassConcentration(double.MaxValue, BaseUnit);
+        public static MassConcentration<T> MaxValue { get; } = new MassConcentration<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MassConcentration
+        /// Represents the smallest possible value of <see cref="MassConcentration{T}" />
         /// </summary>
-        public static MassConcentration MinValue { get; } = new MassConcentration(double.MinValue, BaseUnit);
+        public static MassConcentration<T> MinValue { get; } = new MassConcentration<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -172,14 +168,14 @@ public MassConcentration(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MassConcentration;
 
         /// <summary>
-        ///     All units of measurement for the MassConcentration quantity.
+        ///     All units of measurement for the <see cref="MassConcentration{T}" /> quantity.
         /// </summary>
         public static MassConcentrationUnit[] Units { get; } = Enum.GetValues(typeof(MassConcentrationUnit)).Cast<MassConcentrationUnit>().Except(new MassConcentrationUnit[]{ MassConcentrationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramPerCubicMeter.
         /// </summary>
-        public static MassConcentration Zero { get; } = new MassConcentration(0, BaseUnit);
+        public static MassConcentration<T> Zero { get; } = new MassConcentration<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -188,7 +184,9 @@ public MassConcentration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -204,251 +202,251 @@ public MassConcentration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MassConcentration.QuantityType;
+        public QuantityType Type => MassConcentration<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MassConcentration.BaseDimensions;
+        public BaseDimensions Dimensions => MassConcentration<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MassConcentration in CentigramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> in CentigramsPerDeciliter.
         /// </summary>
-        public double CentigramsPerDeciliter => As(MassConcentrationUnit.CentigramPerDeciliter);
+        public T CentigramsPerDeciliter => As(MassConcentrationUnit.CentigramPerDeciliter);
 
         /// <summary>
-        ///     Get MassConcentration in CentigramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in CentigramsPerLiter.
         /// </summary>
-        public double CentigramsPerLiter => As(MassConcentrationUnit.CentigramPerLiter);
+        public T CentigramsPerLiter => As(MassConcentrationUnit.CentigramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in CentigramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> in CentigramsPerMicroliter.
         /// </summary>
-        public double CentigramsPerMicroliter => As(MassConcentrationUnit.CentigramPerMicroliter);
+        public T CentigramsPerMicroliter => As(MassConcentrationUnit.CentigramPerMicroliter);
 
         /// <summary>
-        ///     Get MassConcentration in CentigramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> in CentigramsPerMilliliter.
         /// </summary>
-        public double CentigramsPerMilliliter => As(MassConcentrationUnit.CentigramPerMilliliter);
+        public T CentigramsPerMilliliter => As(MassConcentrationUnit.CentigramPerMilliliter);
 
         /// <summary>
-        ///     Get MassConcentration in DecigramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> in DecigramsPerDeciliter.
         /// </summary>
-        public double DecigramsPerDeciliter => As(MassConcentrationUnit.DecigramPerDeciliter);
+        public T DecigramsPerDeciliter => As(MassConcentrationUnit.DecigramPerDeciliter);
 
         /// <summary>
-        ///     Get MassConcentration in DecigramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in DecigramsPerLiter.
         /// </summary>
-        public double DecigramsPerLiter => As(MassConcentrationUnit.DecigramPerLiter);
+        public T DecigramsPerLiter => As(MassConcentrationUnit.DecigramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in DecigramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> in DecigramsPerMicroliter.
         /// </summary>
-        public double DecigramsPerMicroliter => As(MassConcentrationUnit.DecigramPerMicroliter);
+        public T DecigramsPerMicroliter => As(MassConcentrationUnit.DecigramPerMicroliter);
 
         /// <summary>
-        ///     Get MassConcentration in DecigramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> in DecigramsPerMilliliter.
         /// </summary>
-        public double DecigramsPerMilliliter => As(MassConcentrationUnit.DecigramPerMilliliter);
+        public T DecigramsPerMilliliter => As(MassConcentrationUnit.DecigramPerMilliliter);
 
         /// <summary>
-        ///     Get MassConcentration in GramsPerCubicCentimeter.
+        ///     Get <see cref="MassConcentration{T}" /> in GramsPerCubicCentimeter.
         /// </summary>
-        public double GramsPerCubicCentimeter => As(MassConcentrationUnit.GramPerCubicCentimeter);
+        public T GramsPerCubicCentimeter => As(MassConcentrationUnit.GramPerCubicCentimeter);
 
         /// <summary>
-        ///     Get MassConcentration in GramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> in GramsPerCubicMeter.
         /// </summary>
-        public double GramsPerCubicMeter => As(MassConcentrationUnit.GramPerCubicMeter);
+        public T GramsPerCubicMeter => As(MassConcentrationUnit.GramPerCubicMeter);
 
         /// <summary>
-        ///     Get MassConcentration in GramsPerCubicMillimeter.
+        ///     Get <see cref="MassConcentration{T}" /> in GramsPerCubicMillimeter.
         /// </summary>
-        public double GramsPerCubicMillimeter => As(MassConcentrationUnit.GramPerCubicMillimeter);
+        public T GramsPerCubicMillimeter => As(MassConcentrationUnit.GramPerCubicMillimeter);
 
         /// <summary>
-        ///     Get MassConcentration in GramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> in GramsPerDeciliter.
         /// </summary>
-        public double GramsPerDeciliter => As(MassConcentrationUnit.GramPerDeciliter);
+        public T GramsPerDeciliter => As(MassConcentrationUnit.GramPerDeciliter);
 
         /// <summary>
-        ///     Get MassConcentration in GramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in GramsPerLiter.
         /// </summary>
-        public double GramsPerLiter => As(MassConcentrationUnit.GramPerLiter);
+        public T GramsPerLiter => As(MassConcentrationUnit.GramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in GramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> in GramsPerMicroliter.
         /// </summary>
-        public double GramsPerMicroliter => As(MassConcentrationUnit.GramPerMicroliter);
+        public T GramsPerMicroliter => As(MassConcentrationUnit.GramPerMicroliter);
 
         /// <summary>
-        ///     Get MassConcentration in GramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> in GramsPerMilliliter.
         /// </summary>
-        public double GramsPerMilliliter => As(MassConcentrationUnit.GramPerMilliliter);
+        public T GramsPerMilliliter => As(MassConcentrationUnit.GramPerMilliliter);
 
         /// <summary>
-        ///     Get MassConcentration in KilogramsPerCubicCentimeter.
+        ///     Get <see cref="MassConcentration{T}" /> in KilogramsPerCubicCentimeter.
         /// </summary>
-        public double KilogramsPerCubicCentimeter => As(MassConcentrationUnit.KilogramPerCubicCentimeter);
+        public T KilogramsPerCubicCentimeter => As(MassConcentrationUnit.KilogramPerCubicCentimeter);
 
         /// <summary>
-        ///     Get MassConcentration in KilogramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> in KilogramsPerCubicMeter.
         /// </summary>
-        public double KilogramsPerCubicMeter => As(MassConcentrationUnit.KilogramPerCubicMeter);
+        public T KilogramsPerCubicMeter => As(MassConcentrationUnit.KilogramPerCubicMeter);
 
         /// <summary>
-        ///     Get MassConcentration in KilogramsPerCubicMillimeter.
+        ///     Get <see cref="MassConcentration{T}" /> in KilogramsPerCubicMillimeter.
         /// </summary>
-        public double KilogramsPerCubicMillimeter => As(MassConcentrationUnit.KilogramPerCubicMillimeter);
+        public T KilogramsPerCubicMillimeter => As(MassConcentrationUnit.KilogramPerCubicMillimeter);
 
         /// <summary>
-        ///     Get MassConcentration in KilogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in KilogramsPerLiter.
         /// </summary>
-        public double KilogramsPerLiter => As(MassConcentrationUnit.KilogramPerLiter);
+        public T KilogramsPerLiter => As(MassConcentrationUnit.KilogramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in KilopoundsPerCubicFoot.
+        ///     Get <see cref="MassConcentration{T}" /> in KilopoundsPerCubicFoot.
         /// </summary>
-        public double KilopoundsPerCubicFoot => As(MassConcentrationUnit.KilopoundPerCubicFoot);
+        public T KilopoundsPerCubicFoot => As(MassConcentrationUnit.KilopoundPerCubicFoot);
 
         /// <summary>
-        ///     Get MassConcentration in KilopoundsPerCubicInch.
+        ///     Get <see cref="MassConcentration{T}" /> in KilopoundsPerCubicInch.
         /// </summary>
-        public double KilopoundsPerCubicInch => As(MassConcentrationUnit.KilopoundPerCubicInch);
+        public T KilopoundsPerCubicInch => As(MassConcentrationUnit.KilopoundPerCubicInch);
 
         /// <summary>
-        ///     Get MassConcentration in MicrogramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> in MicrogramsPerCubicMeter.
         /// </summary>
-        public double MicrogramsPerCubicMeter => As(MassConcentrationUnit.MicrogramPerCubicMeter);
+        public T MicrogramsPerCubicMeter => As(MassConcentrationUnit.MicrogramPerCubicMeter);
 
         /// <summary>
-        ///     Get MassConcentration in MicrogramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> in MicrogramsPerDeciliter.
         /// </summary>
-        public double MicrogramsPerDeciliter => As(MassConcentrationUnit.MicrogramPerDeciliter);
+        public T MicrogramsPerDeciliter => As(MassConcentrationUnit.MicrogramPerDeciliter);
 
         /// <summary>
-        ///     Get MassConcentration in MicrogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in MicrogramsPerLiter.
         /// </summary>
-        public double MicrogramsPerLiter => As(MassConcentrationUnit.MicrogramPerLiter);
+        public T MicrogramsPerLiter => As(MassConcentrationUnit.MicrogramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in MicrogramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> in MicrogramsPerMicroliter.
         /// </summary>
-        public double MicrogramsPerMicroliter => As(MassConcentrationUnit.MicrogramPerMicroliter);
+        public T MicrogramsPerMicroliter => As(MassConcentrationUnit.MicrogramPerMicroliter);
 
         /// <summary>
-        ///     Get MassConcentration in MicrogramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> in MicrogramsPerMilliliter.
         /// </summary>
-        public double MicrogramsPerMilliliter => As(MassConcentrationUnit.MicrogramPerMilliliter);
+        public T MicrogramsPerMilliliter => As(MassConcentrationUnit.MicrogramPerMilliliter);
 
         /// <summary>
-        ///     Get MassConcentration in MilligramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> in MilligramsPerCubicMeter.
         /// </summary>
-        public double MilligramsPerCubicMeter => As(MassConcentrationUnit.MilligramPerCubicMeter);
+        public T MilligramsPerCubicMeter => As(MassConcentrationUnit.MilligramPerCubicMeter);
 
         /// <summary>
-        ///     Get MassConcentration in MilligramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> in MilligramsPerDeciliter.
         /// </summary>
-        public double MilligramsPerDeciliter => As(MassConcentrationUnit.MilligramPerDeciliter);
+        public T MilligramsPerDeciliter => As(MassConcentrationUnit.MilligramPerDeciliter);
 
         /// <summary>
-        ///     Get MassConcentration in MilligramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in MilligramsPerLiter.
         /// </summary>
-        public double MilligramsPerLiter => As(MassConcentrationUnit.MilligramPerLiter);
+        public T MilligramsPerLiter => As(MassConcentrationUnit.MilligramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in MilligramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> in MilligramsPerMicroliter.
         /// </summary>
-        public double MilligramsPerMicroliter => As(MassConcentrationUnit.MilligramPerMicroliter);
+        public T MilligramsPerMicroliter => As(MassConcentrationUnit.MilligramPerMicroliter);
 
         /// <summary>
-        ///     Get MassConcentration in MilligramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> in MilligramsPerMilliliter.
         /// </summary>
-        public double MilligramsPerMilliliter => As(MassConcentrationUnit.MilligramPerMilliliter);
+        public T MilligramsPerMilliliter => As(MassConcentrationUnit.MilligramPerMilliliter);
 
         /// <summary>
-        ///     Get MassConcentration in NanogramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> in NanogramsPerDeciliter.
         /// </summary>
-        public double NanogramsPerDeciliter => As(MassConcentrationUnit.NanogramPerDeciliter);
+        public T NanogramsPerDeciliter => As(MassConcentrationUnit.NanogramPerDeciliter);
 
         /// <summary>
-        ///     Get MassConcentration in NanogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in NanogramsPerLiter.
         /// </summary>
-        public double NanogramsPerLiter => As(MassConcentrationUnit.NanogramPerLiter);
+        public T NanogramsPerLiter => As(MassConcentrationUnit.NanogramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in NanogramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> in NanogramsPerMicroliter.
         /// </summary>
-        public double NanogramsPerMicroliter => As(MassConcentrationUnit.NanogramPerMicroliter);
+        public T NanogramsPerMicroliter => As(MassConcentrationUnit.NanogramPerMicroliter);
 
         /// <summary>
-        ///     Get MassConcentration in NanogramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> in NanogramsPerMilliliter.
         /// </summary>
-        public double NanogramsPerMilliliter => As(MassConcentrationUnit.NanogramPerMilliliter);
+        public T NanogramsPerMilliliter => As(MassConcentrationUnit.NanogramPerMilliliter);
 
         /// <summary>
-        ///     Get MassConcentration in PicogramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> in PicogramsPerDeciliter.
         /// </summary>
-        public double PicogramsPerDeciliter => As(MassConcentrationUnit.PicogramPerDeciliter);
+        public T PicogramsPerDeciliter => As(MassConcentrationUnit.PicogramPerDeciliter);
 
         /// <summary>
-        ///     Get MassConcentration in PicogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> in PicogramsPerLiter.
         /// </summary>
-        public double PicogramsPerLiter => As(MassConcentrationUnit.PicogramPerLiter);
+        public T PicogramsPerLiter => As(MassConcentrationUnit.PicogramPerLiter);
 
         /// <summary>
-        ///     Get MassConcentration in PicogramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> in PicogramsPerMicroliter.
         /// </summary>
-        public double PicogramsPerMicroliter => As(MassConcentrationUnit.PicogramPerMicroliter);
+        public T PicogramsPerMicroliter => As(MassConcentrationUnit.PicogramPerMicroliter);
 
         /// <summary>
-        ///     Get MassConcentration in PicogramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> in PicogramsPerMilliliter.
         /// </summary>
-        public double PicogramsPerMilliliter => As(MassConcentrationUnit.PicogramPerMilliliter);
+        public T PicogramsPerMilliliter => As(MassConcentrationUnit.PicogramPerMilliliter);
 
         /// <summary>
-        ///     Get MassConcentration in PoundsPerCubicFoot.
+        ///     Get <see cref="MassConcentration{T}" /> in PoundsPerCubicFoot.
         /// </summary>
-        public double PoundsPerCubicFoot => As(MassConcentrationUnit.PoundPerCubicFoot);
+        public T PoundsPerCubicFoot => As(MassConcentrationUnit.PoundPerCubicFoot);
 
         /// <summary>
-        ///     Get MassConcentration in PoundsPerCubicInch.
+        ///     Get <see cref="MassConcentration{T}" /> in PoundsPerCubicInch.
         /// </summary>
-        public double PoundsPerCubicInch => As(MassConcentrationUnit.PoundPerCubicInch);
+        public T PoundsPerCubicInch => As(MassConcentrationUnit.PoundPerCubicInch);
 
         /// <summary>
-        ///     Get MassConcentration in PoundsPerImperialGallon.
+        ///     Get <see cref="MassConcentration{T}" /> in PoundsPerImperialGallon.
         /// </summary>
-        public double PoundsPerImperialGallon => As(MassConcentrationUnit.PoundPerImperialGallon);
+        public T PoundsPerImperialGallon => As(MassConcentrationUnit.PoundPerImperialGallon);
 
         /// <summary>
-        ///     Get MassConcentration in PoundsPerUSGallon.
+        ///     Get <see cref="MassConcentration{T}" /> in PoundsPerUSGallon.
         /// </summary>
-        public double PoundsPerUSGallon => As(MassConcentrationUnit.PoundPerUSGallon);
+        public T PoundsPerUSGallon => As(MassConcentrationUnit.PoundPerUSGallon);
 
         /// <summary>
-        ///     Get MassConcentration in SlugsPerCubicFoot.
+        ///     Get <see cref="MassConcentration{T}" /> in SlugsPerCubicFoot.
         /// </summary>
-        public double SlugsPerCubicFoot => As(MassConcentrationUnit.SlugPerCubicFoot);
+        public T SlugsPerCubicFoot => As(MassConcentrationUnit.SlugPerCubicFoot);
 
         /// <summary>
-        ///     Get MassConcentration in TonnesPerCubicCentimeter.
+        ///     Get <see cref="MassConcentration{T}" /> in TonnesPerCubicCentimeter.
         /// </summary>
-        public double TonnesPerCubicCentimeter => As(MassConcentrationUnit.TonnePerCubicCentimeter);
+        public T TonnesPerCubicCentimeter => As(MassConcentrationUnit.TonnePerCubicCentimeter);
 
         /// <summary>
-        ///     Get MassConcentration in TonnesPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> in TonnesPerCubicMeter.
         /// </summary>
-        public double TonnesPerCubicMeter => As(MassConcentrationUnit.TonnePerCubicMeter);
+        public T TonnesPerCubicMeter => As(MassConcentrationUnit.TonnePerCubicMeter);
 
         /// <summary>
-        ///     Get MassConcentration in TonnesPerCubicMillimeter.
+        ///     Get <see cref="MassConcentration{T}" /> in TonnesPerCubicMillimeter.
         /// </summary>
-        public double TonnesPerCubicMillimeter => As(MassConcentrationUnit.TonnePerCubicMillimeter);
+        public T TonnesPerCubicMillimeter => As(MassConcentrationUnit.TonnePerCubicMillimeter);
 
         #endregion
 
@@ -480,438 +478,391 @@ public static string GetAbbreviation(MassConcentrationUnit unit, IFormatProvider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MassConcentration from CentigramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> from CentigramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerDeciliter(QuantityValue centigramsperdeciliter)
+        public static MassConcentration<T> FromCentigramsPerDeciliter(T centigramsperdeciliter)
         {
-            double value = (double) centigramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter);
+            return new MassConcentration<T>(centigramsperdeciliter, MassConcentrationUnit.CentigramPerDeciliter);
         }
         /// <summary>
-        ///     Get MassConcentration from CentigramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from CentigramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerLiter(QuantityValue centigramsperliter)
+        public static MassConcentration<T> FromCentigramsPerLiter(T centigramsperliter)
         {
-            double value = (double) centigramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter);
+            return new MassConcentration<T>(centigramsperliter, MassConcentrationUnit.CentigramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from CentigramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> from CentigramsPerMicroliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerMicroliter(QuantityValue centigramspermicroliter)
+        public static MassConcentration<T> FromCentigramsPerMicroliter(T centigramspermicroliter)
         {
-            double value = (double) centigramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter);
+            return new MassConcentration<T>(centigramspermicroliter, MassConcentrationUnit.CentigramPerMicroliter);
         }
         /// <summary>
-        ///     Get MassConcentration from CentigramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> from CentigramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerMilliliter(QuantityValue centigramspermilliliter)
+        public static MassConcentration<T> FromCentigramsPerMilliliter(T centigramspermilliliter)
         {
-            double value = (double) centigramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter);
+            return new MassConcentration<T>(centigramspermilliliter, MassConcentrationUnit.CentigramPerMilliliter);
         }
         /// <summary>
-        ///     Get MassConcentration from DecigramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> from DecigramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerDeciliter(QuantityValue decigramsperdeciliter)
+        public static MassConcentration<T> FromDecigramsPerDeciliter(T decigramsperdeciliter)
         {
-            double value = (double) decigramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter);
+            return new MassConcentration<T>(decigramsperdeciliter, MassConcentrationUnit.DecigramPerDeciliter);
         }
         /// <summary>
-        ///     Get MassConcentration from DecigramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from DecigramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerLiter(QuantityValue decigramsperliter)
+        public static MassConcentration<T> FromDecigramsPerLiter(T decigramsperliter)
         {
-            double value = (double) decigramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter);
+            return new MassConcentration<T>(decigramsperliter, MassConcentrationUnit.DecigramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from DecigramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> from DecigramsPerMicroliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerMicroliter(QuantityValue decigramspermicroliter)
+        public static MassConcentration<T> FromDecigramsPerMicroliter(T decigramspermicroliter)
         {
-            double value = (double) decigramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter);
+            return new MassConcentration<T>(decigramspermicroliter, MassConcentrationUnit.DecigramPerMicroliter);
         }
         /// <summary>
-        ///     Get MassConcentration from DecigramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> from DecigramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerMilliliter(QuantityValue decigramspermilliliter)
+        public static MassConcentration<T> FromDecigramsPerMilliliter(T decigramspermilliliter)
         {
-            double value = (double) decigramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter);
+            return new MassConcentration<T>(decigramspermilliliter, MassConcentrationUnit.DecigramPerMilliliter);
         }
         /// <summary>
-        ///     Get MassConcentration from GramsPerCubicCentimeter.
+        ///     Get <see cref="MassConcentration{T}" /> from GramsPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicCentimeter(QuantityValue gramspercubiccentimeter)
+        public static MassConcentration<T> FromGramsPerCubicCentimeter(T gramspercubiccentimeter)
         {
-            double value = (double) gramspercubiccentimeter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter);
+            return new MassConcentration<T>(gramspercubiccentimeter, MassConcentrationUnit.GramPerCubicCentimeter);
         }
         /// <summary>
-        ///     Get MassConcentration from GramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> from GramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicMeter(QuantityValue gramspercubicmeter)
+        public static MassConcentration<T> FromGramsPerCubicMeter(T gramspercubicmeter)
         {
-            double value = (double) gramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter);
+            return new MassConcentration<T>(gramspercubicmeter, MassConcentrationUnit.GramPerCubicMeter);
         }
         /// <summary>
-        ///     Get MassConcentration from GramsPerCubicMillimeter.
+        ///     Get <see cref="MassConcentration{T}" /> from GramsPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicMillimeter(QuantityValue gramspercubicmillimeter)
+        public static MassConcentration<T> FromGramsPerCubicMillimeter(T gramspercubicmillimeter)
         {
-            double value = (double) gramspercubicmillimeter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter);
+            return new MassConcentration<T>(gramspercubicmillimeter, MassConcentrationUnit.GramPerCubicMillimeter);
         }
         /// <summary>
-        ///     Get MassConcentration from GramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> from GramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerDeciliter(QuantityValue gramsperdeciliter)
+        public static MassConcentration<T> FromGramsPerDeciliter(T gramsperdeciliter)
         {
-            double value = (double) gramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter);
+            return new MassConcentration<T>(gramsperdeciliter, MassConcentrationUnit.GramPerDeciliter);
         }
         /// <summary>
-        ///     Get MassConcentration from GramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from GramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerLiter(QuantityValue gramsperliter)
+        public static MassConcentration<T> FromGramsPerLiter(T gramsperliter)
         {
-            double value = (double) gramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerLiter);
+            return new MassConcentration<T>(gramsperliter, MassConcentrationUnit.GramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from GramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> from GramsPerMicroliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerMicroliter(QuantityValue gramspermicroliter)
+        public static MassConcentration<T> FromGramsPerMicroliter(T gramspermicroliter)
         {
-            double value = (double) gramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter);
+            return new MassConcentration<T>(gramspermicroliter, MassConcentrationUnit.GramPerMicroliter);
         }
         /// <summary>
-        ///     Get MassConcentration from GramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> from GramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerMilliliter(QuantityValue gramspermilliliter)
+        public static MassConcentration<T> FromGramsPerMilliliter(T gramspermilliliter)
         {
-            double value = (double) gramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter);
+            return new MassConcentration<T>(gramspermilliliter, MassConcentrationUnit.GramPerMilliliter);
         }
         /// <summary>
-        ///     Get MassConcentration from KilogramsPerCubicCentimeter.
+        ///     Get <see cref="MassConcentration{T}" /> from KilogramsPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicCentimeter(QuantityValue kilogramspercubiccentimeter)
+        public static MassConcentration<T> FromKilogramsPerCubicCentimeter(T kilogramspercubiccentimeter)
         {
-            double value = (double) kilogramspercubiccentimeter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter);
+            return new MassConcentration<T>(kilogramspercubiccentimeter, MassConcentrationUnit.KilogramPerCubicCentimeter);
         }
         /// <summary>
-        ///     Get MassConcentration from KilogramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> from KilogramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicMeter(QuantityValue kilogramspercubicmeter)
+        public static MassConcentration<T> FromKilogramsPerCubicMeter(T kilogramspercubicmeter)
         {
-            double value = (double) kilogramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter);
+            return new MassConcentration<T>(kilogramspercubicmeter, MassConcentrationUnit.KilogramPerCubicMeter);
         }
         /// <summary>
-        ///     Get MassConcentration from KilogramsPerCubicMillimeter.
+        ///     Get <see cref="MassConcentration{T}" /> from KilogramsPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicMillimeter(QuantityValue kilogramspercubicmillimeter)
+        public static MassConcentration<T> FromKilogramsPerCubicMillimeter(T kilogramspercubicmillimeter)
         {
-            double value = (double) kilogramspercubicmillimeter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter);
+            return new MassConcentration<T>(kilogramspercubicmillimeter, MassConcentrationUnit.KilogramPerCubicMillimeter);
         }
         /// <summary>
-        ///     Get MassConcentration from KilogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from KilogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerLiter(QuantityValue kilogramsperliter)
+        public static MassConcentration<T> FromKilogramsPerLiter(T kilogramsperliter)
         {
-            double value = (double) kilogramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter);
+            return new MassConcentration<T>(kilogramsperliter, MassConcentrationUnit.KilogramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from KilopoundsPerCubicFoot.
+        ///     Get <see cref="MassConcentration{T}" /> from KilopoundsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilopoundsPerCubicFoot(QuantityValue kilopoundspercubicfoot)
+        public static MassConcentration<T> FromKilopoundsPerCubicFoot(T kilopoundspercubicfoot)
         {
-            double value = (double) kilopoundspercubicfoot;
-            return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot);
+            return new MassConcentration<T>(kilopoundspercubicfoot, MassConcentrationUnit.KilopoundPerCubicFoot);
         }
         /// <summary>
-        ///     Get MassConcentration from KilopoundsPerCubicInch.
+        ///     Get <see cref="MassConcentration{T}" /> from KilopoundsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilopoundsPerCubicInch(QuantityValue kilopoundspercubicinch)
+        public static MassConcentration<T> FromKilopoundsPerCubicInch(T kilopoundspercubicinch)
         {
-            double value = (double) kilopoundspercubicinch;
-            return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch);
+            return new MassConcentration<T>(kilopoundspercubicinch, MassConcentrationUnit.KilopoundPerCubicInch);
         }
         /// <summary>
-        ///     Get MassConcentration from MicrogramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> from MicrogramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerCubicMeter(QuantityValue microgramspercubicmeter)
+        public static MassConcentration<T> FromMicrogramsPerCubicMeter(T microgramspercubicmeter)
         {
-            double value = (double) microgramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter);
+            return new MassConcentration<T>(microgramspercubicmeter, MassConcentrationUnit.MicrogramPerCubicMeter);
         }
         /// <summary>
-        ///     Get MassConcentration from MicrogramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> from MicrogramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerDeciliter(QuantityValue microgramsperdeciliter)
+        public static MassConcentration<T> FromMicrogramsPerDeciliter(T microgramsperdeciliter)
         {
-            double value = (double) microgramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter);
+            return new MassConcentration<T>(microgramsperdeciliter, MassConcentrationUnit.MicrogramPerDeciliter);
         }
         /// <summary>
-        ///     Get MassConcentration from MicrogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from MicrogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerLiter(QuantityValue microgramsperliter)
+        public static MassConcentration<T> FromMicrogramsPerLiter(T microgramsperliter)
         {
-            double value = (double) microgramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter);
+            return new MassConcentration<T>(microgramsperliter, MassConcentrationUnit.MicrogramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from MicrogramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> from MicrogramsPerMicroliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerMicroliter(QuantityValue microgramspermicroliter)
+        public static MassConcentration<T> FromMicrogramsPerMicroliter(T microgramspermicroliter)
         {
-            double value = (double) microgramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter);
+            return new MassConcentration<T>(microgramspermicroliter, MassConcentrationUnit.MicrogramPerMicroliter);
         }
         /// <summary>
-        ///     Get MassConcentration from MicrogramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> from MicrogramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerMilliliter(QuantityValue microgramspermilliliter)
+        public static MassConcentration<T> FromMicrogramsPerMilliliter(T microgramspermilliliter)
         {
-            double value = (double) microgramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter);
+            return new MassConcentration<T>(microgramspermilliliter, MassConcentrationUnit.MicrogramPerMilliliter);
         }
         /// <summary>
-        ///     Get MassConcentration from MilligramsPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> from MilligramsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerCubicMeter(QuantityValue milligramspercubicmeter)
+        public static MassConcentration<T> FromMilligramsPerCubicMeter(T milligramspercubicmeter)
         {
-            double value = (double) milligramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter);
+            return new MassConcentration<T>(milligramspercubicmeter, MassConcentrationUnit.MilligramPerCubicMeter);
         }
         /// <summary>
-        ///     Get MassConcentration from MilligramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> from MilligramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerDeciliter(QuantityValue milligramsperdeciliter)
+        public static MassConcentration<T> FromMilligramsPerDeciliter(T milligramsperdeciliter)
         {
-            double value = (double) milligramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter);
+            return new MassConcentration<T>(milligramsperdeciliter, MassConcentrationUnit.MilligramPerDeciliter);
         }
         /// <summary>
-        ///     Get MassConcentration from MilligramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from MilligramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerLiter(QuantityValue milligramsperliter)
+        public static MassConcentration<T> FromMilligramsPerLiter(T milligramsperliter)
         {
-            double value = (double) milligramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter);
+            return new MassConcentration<T>(milligramsperliter, MassConcentrationUnit.MilligramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from MilligramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> from MilligramsPerMicroliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerMicroliter(QuantityValue milligramspermicroliter)
+        public static MassConcentration<T> FromMilligramsPerMicroliter(T milligramspermicroliter)
         {
-            double value = (double) milligramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter);
+            return new MassConcentration<T>(milligramspermicroliter, MassConcentrationUnit.MilligramPerMicroliter);
         }
         /// <summary>
-        ///     Get MassConcentration from MilligramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> from MilligramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerMilliliter(QuantityValue milligramspermilliliter)
+        public static MassConcentration<T> FromMilligramsPerMilliliter(T milligramspermilliliter)
         {
-            double value = (double) milligramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter);
+            return new MassConcentration<T>(milligramspermilliliter, MassConcentrationUnit.MilligramPerMilliliter);
         }
         /// <summary>
-        ///     Get MassConcentration from NanogramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> from NanogramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerDeciliter(QuantityValue nanogramsperdeciliter)
+        public static MassConcentration<T> FromNanogramsPerDeciliter(T nanogramsperdeciliter)
         {
-            double value = (double) nanogramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter);
+            return new MassConcentration<T>(nanogramsperdeciliter, MassConcentrationUnit.NanogramPerDeciliter);
         }
         /// <summary>
-        ///     Get MassConcentration from NanogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from NanogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerLiter(QuantityValue nanogramsperliter)
+        public static MassConcentration<T> FromNanogramsPerLiter(T nanogramsperliter)
         {
-            double value = (double) nanogramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter);
+            return new MassConcentration<T>(nanogramsperliter, MassConcentrationUnit.NanogramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from NanogramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> from NanogramsPerMicroliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerMicroliter(QuantityValue nanogramspermicroliter)
+        public static MassConcentration<T> FromNanogramsPerMicroliter(T nanogramspermicroliter)
         {
-            double value = (double) nanogramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter);
+            return new MassConcentration<T>(nanogramspermicroliter, MassConcentrationUnit.NanogramPerMicroliter);
         }
         /// <summary>
-        ///     Get MassConcentration from NanogramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> from NanogramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerMilliliter(QuantityValue nanogramspermilliliter)
+        public static MassConcentration<T> FromNanogramsPerMilliliter(T nanogramspermilliliter)
         {
-            double value = (double) nanogramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter);
+            return new MassConcentration<T>(nanogramspermilliliter, MassConcentrationUnit.NanogramPerMilliliter);
         }
         /// <summary>
-        ///     Get MassConcentration from PicogramsPerDeciliter.
+        ///     Get <see cref="MassConcentration{T}" /> from PicogramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerDeciliter(QuantityValue picogramsperdeciliter)
+        public static MassConcentration<T> FromPicogramsPerDeciliter(T picogramsperdeciliter)
         {
-            double value = (double) picogramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter);
+            return new MassConcentration<T>(picogramsperdeciliter, MassConcentrationUnit.PicogramPerDeciliter);
         }
         /// <summary>
-        ///     Get MassConcentration from PicogramsPerLiter.
+        ///     Get <see cref="MassConcentration{T}" /> from PicogramsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerLiter(QuantityValue picogramsperliter)
+        public static MassConcentration<T> FromPicogramsPerLiter(T picogramsperliter)
         {
-            double value = (double) picogramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter);
+            return new MassConcentration<T>(picogramsperliter, MassConcentrationUnit.PicogramPerLiter);
         }
         /// <summary>
-        ///     Get MassConcentration from PicogramsPerMicroliter.
+        ///     Get <see cref="MassConcentration{T}" /> from PicogramsPerMicroliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerMicroliter(QuantityValue picogramspermicroliter)
+        public static MassConcentration<T> FromPicogramsPerMicroliter(T picogramspermicroliter)
         {
-            double value = (double) picogramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter);
+            return new MassConcentration<T>(picogramspermicroliter, MassConcentrationUnit.PicogramPerMicroliter);
         }
         /// <summary>
-        ///     Get MassConcentration from PicogramsPerMilliliter.
+        ///     Get <see cref="MassConcentration{T}" /> from PicogramsPerMilliliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerMilliliter(QuantityValue picogramspermilliliter)
+        public static MassConcentration<T> FromPicogramsPerMilliliter(T picogramspermilliliter)
         {
-            double value = (double) picogramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter);
+            return new MassConcentration<T>(picogramspermilliliter, MassConcentrationUnit.PicogramPerMilliliter);
         }
         /// <summary>
-        ///     Get MassConcentration from PoundsPerCubicFoot.
+        ///     Get <see cref="MassConcentration{T}" /> from PoundsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerCubicFoot(QuantityValue poundspercubicfoot)
+        public static MassConcentration<T> FromPoundsPerCubicFoot(T poundspercubicfoot)
         {
-            double value = (double) poundspercubicfoot;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot);
+            return new MassConcentration<T>(poundspercubicfoot, MassConcentrationUnit.PoundPerCubicFoot);
         }
         /// <summary>
-        ///     Get MassConcentration from PoundsPerCubicInch.
+        ///     Get <see cref="MassConcentration{T}" /> from PoundsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerCubicInch(QuantityValue poundspercubicinch)
+        public static MassConcentration<T> FromPoundsPerCubicInch(T poundspercubicinch)
         {
-            double value = (double) poundspercubicinch;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch);
+            return new MassConcentration<T>(poundspercubicinch, MassConcentrationUnit.PoundPerCubicInch);
         }
         /// <summary>
-        ///     Get MassConcentration from PoundsPerImperialGallon.
+        ///     Get <see cref="MassConcentration{T}" /> from PoundsPerImperialGallon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerImperialGallon(QuantityValue poundsperimperialgallon)
+        public static MassConcentration<T> FromPoundsPerImperialGallon(T poundsperimperialgallon)
         {
-            double value = (double) poundsperimperialgallon;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon);
+            return new MassConcentration<T>(poundsperimperialgallon, MassConcentrationUnit.PoundPerImperialGallon);
         }
         /// <summary>
-        ///     Get MassConcentration from PoundsPerUSGallon.
+        ///     Get <see cref="MassConcentration{T}" /> from PoundsPerUSGallon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerUSGallon(QuantityValue poundsperusgallon)
+        public static MassConcentration<T> FromPoundsPerUSGallon(T poundsperusgallon)
         {
-            double value = (double) poundsperusgallon;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon);
+            return new MassConcentration<T>(poundsperusgallon, MassConcentrationUnit.PoundPerUSGallon);
         }
         /// <summary>
-        ///     Get MassConcentration from SlugsPerCubicFoot.
+        ///     Get <see cref="MassConcentration{T}" /> from SlugsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromSlugsPerCubicFoot(QuantityValue slugspercubicfoot)
+        public static MassConcentration<T> FromSlugsPerCubicFoot(T slugspercubicfoot)
         {
-            double value = (double) slugspercubicfoot;
-            return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot);
+            return new MassConcentration<T>(slugspercubicfoot, MassConcentrationUnit.SlugPerCubicFoot);
         }
         /// <summary>
-        ///     Get MassConcentration from TonnesPerCubicCentimeter.
+        ///     Get <see cref="MassConcentration{T}" /> from TonnesPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicCentimeter(QuantityValue tonnespercubiccentimeter)
+        public static MassConcentration<T> FromTonnesPerCubicCentimeter(T tonnespercubiccentimeter)
         {
-            double value = (double) tonnespercubiccentimeter;
-            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter);
+            return new MassConcentration<T>(tonnespercubiccentimeter, MassConcentrationUnit.TonnePerCubicCentimeter);
         }
         /// <summary>
-        ///     Get MassConcentration from TonnesPerCubicMeter.
+        ///     Get <see cref="MassConcentration{T}" /> from TonnesPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicMeter(QuantityValue tonnespercubicmeter)
+        public static MassConcentration<T> FromTonnesPerCubicMeter(T tonnespercubicmeter)
         {
-            double value = (double) tonnespercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter);
+            return new MassConcentration<T>(tonnespercubicmeter, MassConcentrationUnit.TonnePerCubicMeter);
         }
         /// <summary>
-        ///     Get MassConcentration from TonnesPerCubicMillimeter.
+        ///     Get <see cref="MassConcentration{T}" /> from TonnesPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicMillimeter(QuantityValue tonnespercubicmillimeter)
+        public static MassConcentration<T> FromTonnesPerCubicMillimeter(T tonnespercubicmillimeter)
         {
-            double value = (double) tonnespercubicmillimeter;
-            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter);
+            return new MassConcentration<T>(tonnespercubicmillimeter, MassConcentrationUnit.TonnePerCubicMillimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassConcentrationUnit" /> to <see cref="MassConcentration" />.
+        ///     Dynamically convert from value and unit enum <see cref="MassConcentrationUnit" /> to <see cref="MassConcentration{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassConcentration unit value.</returns>
-        public static MassConcentration From(QuantityValue value, MassConcentrationUnit fromUnit)
+        /// <returns><see cref="MassConcentration{T}" /> unit value.</returns>
+        public static MassConcentration<T> From(T value, MassConcentrationUnit fromUnit)
         {
-            return new MassConcentration((double)value, fromUnit);
+            return new MassConcentration<T>(value, fromUnit);
         }
 
         #endregion
@@ -940,7 +891,7 @@ public static MassConcentration From(QuantityValue value, MassConcentrationUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MassConcentration Parse(string str)
+        public static MassConcentration<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -968,9 +919,9 @@ public static MassConcentration Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MassConcentration Parse(string str, IFormatProvider? provider)
+        public static MassConcentration<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MassConcentration, MassConcentrationUnit>(
+            return QuantityParser.Default.Parse<T, MassConcentration<T>, MassConcentrationUnit>(
                 str,
                 provider,
                 From);
@@ -984,7 +935,7 @@ public static MassConcentration Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MassConcentration result)
+        public static bool TryParse(string? str, out MassConcentration<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -999,9 +950,9 @@ public static bool TryParse(string? str, out MassConcentration result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MassConcentration result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MassConcentration<T> result)
         {
-            return QuantityParser.Default.TryParse<MassConcentration, MassConcentrationUnit>(
+            return QuantityParser.Default.TryParse<T, MassConcentration<T>, MassConcentrationUnit>(
                 str,
                 provider,
                 From,
@@ -1063,45 +1014,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassC
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MassConcentration operator -(MassConcentration right)
+        public static MassConcentration<T> operator -(MassConcentration<T> right)
         {
-            return new MassConcentration(-right.Value, right.Unit);
+            return new MassConcentration<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MassConcentration"/> from adding two <see cref="MassConcentration"/>.</summary>
-        public static MassConcentration operator +(MassConcentration left, MassConcentration right)
+        /// <summary>Get <see cref="MassConcentration{T}"/> from adding two <see cref="MassConcentration{T}"/>.</summary>
+        public static MassConcentration<T> operator +(MassConcentration<T> left, MassConcentration<T> right)
         {
-            return new MassConcentration(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MassConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassConcentration"/> from subtracting two <see cref="MassConcentration"/>.</summary>
-        public static MassConcentration operator -(MassConcentration left, MassConcentration right)
+        /// <summary>Get <see cref="MassConcentration{T}"/> from subtracting two <see cref="MassConcentration{T}"/>.</summary>
+        public static MassConcentration<T> operator -(MassConcentration<T> left, MassConcentration<T> right)
         {
-            return new MassConcentration(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MassConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassConcentration"/> from multiplying value and <see cref="MassConcentration"/>.</summary>
-        public static MassConcentration operator *(double left, MassConcentration right)
+        /// <summary>Get <see cref="MassConcentration{T}"/> from multiplying value and <see cref="MassConcentration{T}"/>.</summary>
+        public static MassConcentration<T> operator *(T left, MassConcentration<T> right)
         {
-            return new MassConcentration(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MassConcentration<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MassConcentration"/> from multiplying value and <see cref="MassConcentration"/>.</summary>
-        public static MassConcentration operator *(MassConcentration left, double right)
+        /// <summary>Get <see cref="MassConcentration{T}"/> from multiplying value and <see cref="MassConcentration{T}"/>.</summary>
+        public static MassConcentration<T> operator *(MassConcentration<T> left, T right)
         {
-            return new MassConcentration(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MassConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassConcentration"/> from dividing <see cref="MassConcentration"/> by value.</summary>
-        public static MassConcentration operator /(MassConcentration left, double right)
+        /// <summary>Get <see cref="MassConcentration{T}"/> from dividing <see cref="MassConcentration{T}"/> by value.</summary>
+        public static MassConcentration<T> operator /(MassConcentration<T> left, T right)
         {
-            return new MassConcentration(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MassConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MassConcentration"/> by <see cref="MassConcentration"/>.</summary>
-        public static double operator /(MassConcentration left, MassConcentration right)
+        /// <summary>Get ratio value from dividing <see cref="MassConcentration{T}"/> by <see cref="MassConcentration{T}"/>.</summary>
+        public static T operator /(MassConcentration<T> left, MassConcentration<T> right)
         {
-            return left.KilogramsPerCubicMeter / right.KilogramsPerCubicMeter;
+            return CompiledLambdas.Divide(left.KilogramsPerCubicMeter, right.KilogramsPerCubicMeter);
         }
 
         #endregion
@@ -1109,39 +1065,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassC
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MassConcentration left, MassConcentration right)
+        public static bool operator <=(MassConcentration<T> left, MassConcentration<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MassConcentration left, MassConcentration right)
+        public static bool operator >=(MassConcentration<T> left, MassConcentration<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MassConcentration left, MassConcentration right)
+        public static bool operator <(MassConcentration<T> left, MassConcentration<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MassConcentration left, MassConcentration right)
+        public static bool operator >(MassConcentration<T> left, MassConcentration<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MassConcentration left, MassConcentration right)
+        /// <remarks>Consider using <see cref="Equals(MassConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MassConcentration<T> left, MassConcentration<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MassConcentration left, MassConcentration right)
+        /// <remarks>Consider using <see cref="Equals(MassConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MassConcentration<T> left, MassConcentration<T> right)
         {
             return !(left == right);
         }
@@ -1150,37 +1106,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassC
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MassConcentration objMassConcentration)) throw new ArgumentException("Expected type MassConcentration.", nameof(obj));
+            if(!(obj is MassConcentration<T> objMassConcentration)) throw new ArgumentException("Expected type MassConcentration.", nameof(obj));
 
             return CompareTo(objMassConcentration);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MassConcentration other)
+        public int CompareTo(MassConcentration<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MassConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MassConcentration objMassConcentration))
+            if(obj is null || !(obj is MassConcentration<T> objMassConcentration))
                 return false;
 
             return Equals(objMassConcentration);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MassConcentration other)
+        /// <remarks>Consider using <see cref="Equals(MassConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MassConcentration<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MassConcentration within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MassConcentration{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1218,21 +1174,19 @@ public bool Equals(MassConcentration other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MassConcentration other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MassConcentration<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MassConcentration.</returns>
+        /// <returns>A hash code for the current <see cref="MassConcentration{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1246,17 +1200,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassConcentrationUnit unit)
+        public T As(MassConcentrationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1276,17 +1230,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MassConcentrationUnit unitAsMassConcentrationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassConcentrationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMassConcentrationUnit);
+            var asValue = As(unitAsMassConcentrationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MassConcentrationUnit>.As(MassConcentrationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MassConcentration to another MassConcentration with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MassConcentration{T}" /> to another <see cref="MassConcentration{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MassConcentration with the specified unit.</returns>
-        public MassConcentration ToUnit(MassConcentrationUnit unit)
+        /// <returns>A <see cref="MassConcentration{T}" /> with the specified unit.</returns>
+        public MassConcentration<T> ToUnit(MassConcentrationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MassConcentration(convertedValue, unit);
+            return new MassConcentration<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1299,7 +1258,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MassConcentration ToUnit(UnitSystem unitSystem)
+        public MassConcentration<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1319,65 +1278,71 @@ public MassConcentration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassConcentrationUnit> IQuantity<MassConcentrationUnit>.ToUnit(MassConcentrationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MassConcentrationUnit, T> IQuantityT<MassConcentrationUnit, T>.ToUnit(MassConcentrationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MassConcentrationUnit> IQuantity<MassConcentrationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MassConcentrationUnit, T> IQuantityT<MassConcentrationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MassConcentrationUnit.CentigramPerDeciliter: return (_value/1e-1) * 1e-2d;
-                case MassConcentrationUnit.CentigramPerLiter: return (_value) * 1e-2d;
-                case MassConcentrationUnit.CentigramPerMicroliter: return (_value/1e-6) * 1e-2d;
-                case MassConcentrationUnit.CentigramPerMilliliter: return (_value/1e-3) * 1e-2d;
-                case MassConcentrationUnit.DecigramPerDeciliter: return (_value/1e-1) * 1e-1d;
-                case MassConcentrationUnit.DecigramPerLiter: return (_value) * 1e-1d;
-                case MassConcentrationUnit.DecigramPerMicroliter: return (_value/1e-6) * 1e-1d;
-                case MassConcentrationUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d;
-                case MassConcentrationUnit.GramPerCubicCentimeter: return _value/1e-3;
-                case MassConcentrationUnit.GramPerCubicMeter: return _value/1e3;
-                case MassConcentrationUnit.GramPerCubicMillimeter: return _value/1e-6;
-                case MassConcentrationUnit.GramPerDeciliter: return _value/1e-1;
-                case MassConcentrationUnit.GramPerLiter: return _value;
-                case MassConcentrationUnit.GramPerMicroliter: return _value/1e-6;
-                case MassConcentrationUnit.GramPerMilliliter: return _value/1e-3;
-                case MassConcentrationUnit.KilogramPerCubicCentimeter: return (_value/1e-3) * 1e3d;
-                case MassConcentrationUnit.KilogramPerCubicMeter: return (_value/1e3) * 1e3d;
-                case MassConcentrationUnit.KilogramPerCubicMillimeter: return (_value/1e-6) * 1e3d;
-                case MassConcentrationUnit.KilogramPerLiter: return (_value) * 1e3d;
-                case MassConcentrationUnit.KilopoundPerCubicFoot: return (_value/0.062427961) * 1e3d;
-                case MassConcentrationUnit.KilopoundPerCubicInch: return (_value/3.6127298147753e-5) * 1e3d;
-                case MassConcentrationUnit.MicrogramPerCubicMeter: return (_value/1e3) * 1e-6d;
-                case MassConcentrationUnit.MicrogramPerDeciliter: return (_value/1e-1) * 1e-6d;
-                case MassConcentrationUnit.MicrogramPerLiter: return (_value) * 1e-6d;
-                case MassConcentrationUnit.MicrogramPerMicroliter: return (_value/1e-6) * 1e-6d;
-                case MassConcentrationUnit.MicrogramPerMilliliter: return (_value/1e-3) * 1e-6d;
-                case MassConcentrationUnit.MilligramPerCubicMeter: return (_value/1e3) * 1e-3d;
-                case MassConcentrationUnit.MilligramPerDeciliter: return (_value/1e-1) * 1e-3d;
-                case MassConcentrationUnit.MilligramPerLiter: return (_value) * 1e-3d;
-                case MassConcentrationUnit.MilligramPerMicroliter: return (_value/1e-6) * 1e-3d;
-                case MassConcentrationUnit.MilligramPerMilliliter: return (_value/1e-3) * 1e-3d;
-                case MassConcentrationUnit.NanogramPerDeciliter: return (_value/1e-1) * 1e-9d;
-                case MassConcentrationUnit.NanogramPerLiter: return (_value) * 1e-9d;
-                case MassConcentrationUnit.NanogramPerMicroliter: return (_value/1e-6) * 1e-9d;
-                case MassConcentrationUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d;
-                case MassConcentrationUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d;
-                case MassConcentrationUnit.PicogramPerLiter: return (_value) * 1e-12d;
-                case MassConcentrationUnit.PicogramPerMicroliter: return (_value/1e-6) * 1e-12d;
-                case MassConcentrationUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d;
-                case MassConcentrationUnit.PoundPerCubicFoot: return _value/0.062427961;
-                case MassConcentrationUnit.PoundPerCubicInch: return _value/3.6127298147753e-5;
-                case MassConcentrationUnit.PoundPerImperialGallon: return _value*9.9776398e1;
-                case MassConcentrationUnit.PoundPerUSGallon: return _value*1.19826427e2;
-                case MassConcentrationUnit.SlugPerCubicFoot: return _value*515.378818;
-                case MassConcentrationUnit.TonnePerCubicCentimeter: return _value/1e-9;
-                case MassConcentrationUnit.TonnePerCubicMeter: return _value/0.001;
-                case MassConcentrationUnit.TonnePerCubicMillimeter: return _value/1e-12;
+                case MassConcentrationUnit.CentigramPerDeciliter: return (Value/1e-1) * 1e-2d;
+                case MassConcentrationUnit.CentigramPerLiter: return (Value) * 1e-2d;
+                case MassConcentrationUnit.CentigramPerMicroliter: return (Value/1e-6) * 1e-2d;
+                case MassConcentrationUnit.CentigramPerMilliliter: return (Value/1e-3) * 1e-2d;
+                case MassConcentrationUnit.DecigramPerDeciliter: return (Value/1e-1) * 1e-1d;
+                case MassConcentrationUnit.DecigramPerLiter: return (Value) * 1e-1d;
+                case MassConcentrationUnit.DecigramPerMicroliter: return (Value/1e-6) * 1e-1d;
+                case MassConcentrationUnit.DecigramPerMilliliter: return (Value/1e-3) * 1e-1d;
+                case MassConcentrationUnit.GramPerCubicCentimeter: return Value/1e-3;
+                case MassConcentrationUnit.GramPerCubicMeter: return Value/1e3;
+                case MassConcentrationUnit.GramPerCubicMillimeter: return Value/1e-6;
+                case MassConcentrationUnit.GramPerDeciliter: return Value/1e-1;
+                case MassConcentrationUnit.GramPerLiter: return Value;
+                case MassConcentrationUnit.GramPerMicroliter: return Value/1e-6;
+                case MassConcentrationUnit.GramPerMilliliter: return Value/1e-3;
+                case MassConcentrationUnit.KilogramPerCubicCentimeter: return (Value/1e-3) * 1e3d;
+                case MassConcentrationUnit.KilogramPerCubicMeter: return (Value/1e3) * 1e3d;
+                case MassConcentrationUnit.KilogramPerCubicMillimeter: return (Value/1e-6) * 1e3d;
+                case MassConcentrationUnit.KilogramPerLiter: return (Value) * 1e3d;
+                case MassConcentrationUnit.KilopoundPerCubicFoot: return (Value/0.062427961) * 1e3d;
+                case MassConcentrationUnit.KilopoundPerCubicInch: return (Value/3.6127298147753e-5) * 1e3d;
+                case MassConcentrationUnit.MicrogramPerCubicMeter: return (Value/1e3) * 1e-6d;
+                case MassConcentrationUnit.MicrogramPerDeciliter: return (Value/1e-1) * 1e-6d;
+                case MassConcentrationUnit.MicrogramPerLiter: return (Value) * 1e-6d;
+                case MassConcentrationUnit.MicrogramPerMicroliter: return (Value/1e-6) * 1e-6d;
+                case MassConcentrationUnit.MicrogramPerMilliliter: return (Value/1e-3) * 1e-6d;
+                case MassConcentrationUnit.MilligramPerCubicMeter: return (Value/1e3) * 1e-3d;
+                case MassConcentrationUnit.MilligramPerDeciliter: return (Value/1e-1) * 1e-3d;
+                case MassConcentrationUnit.MilligramPerLiter: return (Value) * 1e-3d;
+                case MassConcentrationUnit.MilligramPerMicroliter: return (Value/1e-6) * 1e-3d;
+                case MassConcentrationUnit.MilligramPerMilliliter: return (Value/1e-3) * 1e-3d;
+                case MassConcentrationUnit.NanogramPerDeciliter: return (Value/1e-1) * 1e-9d;
+                case MassConcentrationUnit.NanogramPerLiter: return (Value) * 1e-9d;
+                case MassConcentrationUnit.NanogramPerMicroliter: return (Value/1e-6) * 1e-9d;
+                case MassConcentrationUnit.NanogramPerMilliliter: return (Value/1e-3) * 1e-9d;
+                case MassConcentrationUnit.PicogramPerDeciliter: return (Value/1e-1) * 1e-12d;
+                case MassConcentrationUnit.PicogramPerLiter: return (Value) * 1e-12d;
+                case MassConcentrationUnit.PicogramPerMicroliter: return (Value/1e-6) * 1e-12d;
+                case MassConcentrationUnit.PicogramPerMilliliter: return (Value/1e-3) * 1e-12d;
+                case MassConcentrationUnit.PoundPerCubicFoot: return Value/0.062427961;
+                case MassConcentrationUnit.PoundPerCubicInch: return Value/3.6127298147753e-5;
+                case MassConcentrationUnit.PoundPerImperialGallon: return Value*9.9776398e1;
+                case MassConcentrationUnit.PoundPerUSGallon: return Value*1.19826427e2;
+                case MassConcentrationUnit.SlugPerCubicFoot: return Value*515.378818;
+                case MassConcentrationUnit.TonnePerCubicCentimeter: return Value/1e-9;
+                case MassConcentrationUnit.TonnePerCubicMeter: return Value/0.001;
+                case MassConcentrationUnit.TonnePerCubicMillimeter: return Value/1e-12;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1388,16 +1353,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MassConcentration ToBaseUnit()
+        internal MassConcentration<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MassConcentration(baseUnitValue, BaseUnit);
+            return new MassConcentration<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MassConcentrationUnit unit)
+        private T GetValueAs(MassConcentrationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1546,57 +1511,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassConcentration)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassConcentration<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassConcentration)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassConcentration<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassConcentration)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassConcentration<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1606,33 +1571,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MassConcentration))
+            if(conversionType == typeof(MassConcentration<T>))
                 return this;
             else if(conversionType == typeof(MassConcentrationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MassConcentration.QuantityType;
+                return MassConcentration<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MassConcentration.Info;
+                return MassConcentration<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MassConcentration.BaseDimensions;
+                return MassConcentration<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MassConcentration)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MassConcentration<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
index 3a0c7a7000..9205b8bfae 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Mass flow is the ratio of the mass change to the time during which the change occurred (value of mass changes per unit time).
     /// </summary>
-    public partial struct MassFlow : IQuantity<MassFlowUnit>, IEquatable<MassFlow>, IComparable, IComparable<MassFlow>, IConvertible, IFormattable
+    public partial struct MassFlow<T> : IQuantityT<MassFlowUnit, T>, IEquatable<MassFlow<T>>, IComparable, IComparable<MassFlow<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -95,12 +91,12 @@ static MassFlow()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MassFlow(double value, MassFlowUnit unit)
+        public MassFlow(T value, MassFlowUnit unit)
         {
             if(unit == MassFlowUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -112,14 +108,14 @@ public MassFlow(double value, MassFlowUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassFlow(double value, UnitSystem unitSystem)
+        public MassFlow(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -134,19 +130,19 @@ public MassFlow(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MassFlow, which is GramPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="MassFlow{T}" />, which is GramPerSecond. All conversions go via this value.
         /// </summary>
         public static MassFlowUnit BaseUnit { get; } = MassFlowUnit.GramPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of MassFlow
+        /// Represents the largest possible value of <see cref="MassFlow{T}" />
         /// </summary>
-        public static MassFlow MaxValue { get; } = new MassFlow(double.MaxValue, BaseUnit);
+        public static MassFlow<T> MaxValue { get; } = new MassFlow<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MassFlow
+        /// Represents the smallest possible value of <see cref="MassFlow{T}" />
         /// </summary>
-        public static MassFlow MinValue { get; } = new MassFlow(double.MinValue, BaseUnit);
+        public static MassFlow<T> MinValue { get; } = new MassFlow<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -155,14 +151,14 @@ public MassFlow(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MassFlow;
 
         /// <summary>
-        ///     All units of measurement for the MassFlow quantity.
+        ///     All units of measurement for the <see cref="MassFlow{T}" /> quantity.
         /// </summary>
         public static MassFlowUnit[] Units { get; } = Enum.GetValues(typeof(MassFlowUnit)).Cast<MassFlowUnit>().Except(new MassFlowUnit[]{ MassFlowUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit GramPerSecond.
         /// </summary>
-        public static MassFlow Zero { get; } = new MassFlow(0, BaseUnit);
+        public static MassFlow<T> Zero { get; } = new MassFlow<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -171,7 +167,9 @@ public MassFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -187,181 +185,181 @@ public MassFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MassFlow.QuantityType;
+        public QuantityType Type => MassFlow<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MassFlow.BaseDimensions;
+        public BaseDimensions Dimensions => MassFlow<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MassFlow in CentigramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in CentigramsPerDay.
         /// </summary>
-        public double CentigramsPerDay => As(MassFlowUnit.CentigramPerDay);
+        public T CentigramsPerDay => As(MassFlowUnit.CentigramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in CentigramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in CentigramsPerSecond.
         /// </summary>
-        public double CentigramsPerSecond => As(MassFlowUnit.CentigramPerSecond);
+        public T CentigramsPerSecond => As(MassFlowUnit.CentigramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in DecagramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in DecagramsPerDay.
         /// </summary>
-        public double DecagramsPerDay => As(MassFlowUnit.DecagramPerDay);
+        public T DecagramsPerDay => As(MassFlowUnit.DecagramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in DecagramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in DecagramsPerSecond.
         /// </summary>
-        public double DecagramsPerSecond => As(MassFlowUnit.DecagramPerSecond);
+        public T DecagramsPerSecond => As(MassFlowUnit.DecagramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in DecigramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in DecigramsPerDay.
         /// </summary>
-        public double DecigramsPerDay => As(MassFlowUnit.DecigramPerDay);
+        public T DecigramsPerDay => As(MassFlowUnit.DecigramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in DecigramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in DecigramsPerSecond.
         /// </summary>
-        public double DecigramsPerSecond => As(MassFlowUnit.DecigramPerSecond);
+        public T DecigramsPerSecond => As(MassFlowUnit.DecigramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in GramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in GramsPerDay.
         /// </summary>
-        public double GramsPerDay => As(MassFlowUnit.GramPerDay);
+        public T GramsPerDay => As(MassFlowUnit.GramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in GramsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> in GramsPerHour.
         /// </summary>
-        public double GramsPerHour => As(MassFlowUnit.GramPerHour);
+        public T GramsPerHour => As(MassFlowUnit.GramPerHour);
 
         /// <summary>
-        ///     Get MassFlow in GramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in GramsPerSecond.
         /// </summary>
-        public double GramsPerSecond => As(MassFlowUnit.GramPerSecond);
+        public T GramsPerSecond => As(MassFlowUnit.GramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in HectogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in HectogramsPerDay.
         /// </summary>
-        public double HectogramsPerDay => As(MassFlowUnit.HectogramPerDay);
+        public T HectogramsPerDay => As(MassFlowUnit.HectogramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in HectogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in HectogramsPerSecond.
         /// </summary>
-        public double HectogramsPerSecond => As(MassFlowUnit.HectogramPerSecond);
+        public T HectogramsPerSecond => As(MassFlowUnit.HectogramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in KilogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in KilogramsPerDay.
         /// </summary>
-        public double KilogramsPerDay => As(MassFlowUnit.KilogramPerDay);
+        public T KilogramsPerDay => As(MassFlowUnit.KilogramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in KilogramsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> in KilogramsPerHour.
         /// </summary>
-        public double KilogramsPerHour => As(MassFlowUnit.KilogramPerHour);
+        public T KilogramsPerHour => As(MassFlowUnit.KilogramPerHour);
 
         /// <summary>
-        ///     Get MassFlow in KilogramsPerMinute.
+        ///     Get <see cref="MassFlow{T}" /> in KilogramsPerMinute.
         /// </summary>
-        public double KilogramsPerMinute => As(MassFlowUnit.KilogramPerMinute);
+        public T KilogramsPerMinute => As(MassFlowUnit.KilogramPerMinute);
 
         /// <summary>
-        ///     Get MassFlow in KilogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in KilogramsPerSecond.
         /// </summary>
-        public double KilogramsPerSecond => As(MassFlowUnit.KilogramPerSecond);
+        public T KilogramsPerSecond => As(MassFlowUnit.KilogramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in MegagramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in MegagramsPerDay.
         /// </summary>
-        public double MegagramsPerDay => As(MassFlowUnit.MegagramPerDay);
+        public T MegagramsPerDay => As(MassFlowUnit.MegagramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in MegapoundsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in MegapoundsPerDay.
         /// </summary>
-        public double MegapoundsPerDay => As(MassFlowUnit.MegapoundPerDay);
+        public T MegapoundsPerDay => As(MassFlowUnit.MegapoundPerDay);
 
         /// <summary>
-        ///     Get MassFlow in MegapoundsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> in MegapoundsPerHour.
         /// </summary>
-        public double MegapoundsPerHour => As(MassFlowUnit.MegapoundPerHour);
+        public T MegapoundsPerHour => As(MassFlowUnit.MegapoundPerHour);
 
         /// <summary>
-        ///     Get MassFlow in MegapoundsPerMinute.
+        ///     Get <see cref="MassFlow{T}" /> in MegapoundsPerMinute.
         /// </summary>
-        public double MegapoundsPerMinute => As(MassFlowUnit.MegapoundPerMinute);
+        public T MegapoundsPerMinute => As(MassFlowUnit.MegapoundPerMinute);
 
         /// <summary>
-        ///     Get MassFlow in MegapoundsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in MegapoundsPerSecond.
         /// </summary>
-        public double MegapoundsPerSecond => As(MassFlowUnit.MegapoundPerSecond);
+        public T MegapoundsPerSecond => As(MassFlowUnit.MegapoundPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in MicrogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in MicrogramsPerDay.
         /// </summary>
-        public double MicrogramsPerDay => As(MassFlowUnit.MicrogramPerDay);
+        public T MicrogramsPerDay => As(MassFlowUnit.MicrogramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in MicrogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in MicrogramsPerSecond.
         /// </summary>
-        public double MicrogramsPerSecond => As(MassFlowUnit.MicrogramPerSecond);
+        public T MicrogramsPerSecond => As(MassFlowUnit.MicrogramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in MilligramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in MilligramsPerDay.
         /// </summary>
-        public double MilligramsPerDay => As(MassFlowUnit.MilligramPerDay);
+        public T MilligramsPerDay => As(MassFlowUnit.MilligramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in MilligramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in MilligramsPerSecond.
         /// </summary>
-        public double MilligramsPerSecond => As(MassFlowUnit.MilligramPerSecond);
+        public T MilligramsPerSecond => As(MassFlowUnit.MilligramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in NanogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in NanogramsPerDay.
         /// </summary>
-        public double NanogramsPerDay => As(MassFlowUnit.NanogramPerDay);
+        public T NanogramsPerDay => As(MassFlowUnit.NanogramPerDay);
 
         /// <summary>
-        ///     Get MassFlow in NanogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in NanogramsPerSecond.
         /// </summary>
-        public double NanogramsPerSecond => As(MassFlowUnit.NanogramPerSecond);
+        public T NanogramsPerSecond => As(MassFlowUnit.NanogramPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in PoundsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in PoundsPerDay.
         /// </summary>
-        public double PoundsPerDay => As(MassFlowUnit.PoundPerDay);
+        public T PoundsPerDay => As(MassFlowUnit.PoundPerDay);
 
         /// <summary>
-        ///     Get MassFlow in PoundsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> in PoundsPerHour.
         /// </summary>
-        public double PoundsPerHour => As(MassFlowUnit.PoundPerHour);
+        public T PoundsPerHour => As(MassFlowUnit.PoundPerHour);
 
         /// <summary>
-        ///     Get MassFlow in PoundsPerMinute.
+        ///     Get <see cref="MassFlow{T}" /> in PoundsPerMinute.
         /// </summary>
-        public double PoundsPerMinute => As(MassFlowUnit.PoundPerMinute);
+        public T PoundsPerMinute => As(MassFlowUnit.PoundPerMinute);
 
         /// <summary>
-        ///     Get MassFlow in PoundsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> in PoundsPerSecond.
         /// </summary>
-        public double PoundsPerSecond => As(MassFlowUnit.PoundPerSecond);
+        public T PoundsPerSecond => As(MassFlowUnit.PoundPerSecond);
 
         /// <summary>
-        ///     Get MassFlow in ShortTonsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> in ShortTonsPerHour.
         /// </summary>
-        public double ShortTonsPerHour => As(MassFlowUnit.ShortTonPerHour);
+        public T ShortTonsPerHour => As(MassFlowUnit.ShortTonPerHour);
 
         /// <summary>
-        ///     Get MassFlow in TonnesPerDay.
+        ///     Get <see cref="MassFlow{T}" /> in TonnesPerDay.
         /// </summary>
-        public double TonnesPerDay => As(MassFlowUnit.TonnePerDay);
+        public T TonnesPerDay => As(MassFlowUnit.TonnePerDay);
 
         /// <summary>
-        ///     Get MassFlow in TonnesPerHour.
+        ///     Get <see cref="MassFlow{T}" /> in TonnesPerHour.
         /// </summary>
-        public double TonnesPerHour => As(MassFlowUnit.TonnePerHour);
+        public T TonnesPerHour => As(MassFlowUnit.TonnePerHour);
 
         #endregion
 
@@ -393,312 +391,279 @@ public static string GetAbbreviation(MassFlowUnit unit, IFormatProvider? provide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MassFlow from CentigramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from CentigramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromCentigramsPerDay(QuantityValue centigramsperday)
+        public static MassFlow<T> FromCentigramsPerDay(T centigramsperday)
         {
-            double value = (double) centigramsperday;
-            return new MassFlow(value, MassFlowUnit.CentigramPerDay);
+            return new MassFlow<T>(centigramsperday, MassFlowUnit.CentigramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from CentigramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from CentigramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromCentigramsPerSecond(QuantityValue centigramspersecond)
+        public static MassFlow<T> FromCentigramsPerSecond(T centigramspersecond)
         {
-            double value = (double) centigramspersecond;
-            return new MassFlow(value, MassFlowUnit.CentigramPerSecond);
+            return new MassFlow<T>(centigramspersecond, MassFlowUnit.CentigramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from DecagramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from DecagramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecagramsPerDay(QuantityValue decagramsperday)
+        public static MassFlow<T> FromDecagramsPerDay(T decagramsperday)
         {
-            double value = (double) decagramsperday;
-            return new MassFlow(value, MassFlowUnit.DecagramPerDay);
+            return new MassFlow<T>(decagramsperday, MassFlowUnit.DecagramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from DecagramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from DecagramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecagramsPerSecond(QuantityValue decagramspersecond)
+        public static MassFlow<T> FromDecagramsPerSecond(T decagramspersecond)
         {
-            double value = (double) decagramspersecond;
-            return new MassFlow(value, MassFlowUnit.DecagramPerSecond);
+            return new MassFlow<T>(decagramspersecond, MassFlowUnit.DecagramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from DecigramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from DecigramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecigramsPerDay(QuantityValue decigramsperday)
+        public static MassFlow<T> FromDecigramsPerDay(T decigramsperday)
         {
-            double value = (double) decigramsperday;
-            return new MassFlow(value, MassFlowUnit.DecigramPerDay);
+            return new MassFlow<T>(decigramsperday, MassFlowUnit.DecigramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from DecigramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from DecigramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecigramsPerSecond(QuantityValue decigramspersecond)
+        public static MassFlow<T> FromDecigramsPerSecond(T decigramspersecond)
         {
-            double value = (double) decigramspersecond;
-            return new MassFlow(value, MassFlowUnit.DecigramPerSecond);
+            return new MassFlow<T>(decigramspersecond, MassFlowUnit.DecigramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from GramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from GramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerDay(QuantityValue gramsperday)
+        public static MassFlow<T> FromGramsPerDay(T gramsperday)
         {
-            double value = (double) gramsperday;
-            return new MassFlow(value, MassFlowUnit.GramPerDay);
+            return new MassFlow<T>(gramsperday, MassFlowUnit.GramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from GramsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> from GramsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerHour(QuantityValue gramsperhour)
+        public static MassFlow<T> FromGramsPerHour(T gramsperhour)
         {
-            double value = (double) gramsperhour;
-            return new MassFlow(value, MassFlowUnit.GramPerHour);
+            return new MassFlow<T>(gramsperhour, MassFlowUnit.GramPerHour);
         }
         /// <summary>
-        ///     Get MassFlow from GramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from GramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerSecond(QuantityValue gramspersecond)
+        public static MassFlow<T> FromGramsPerSecond(T gramspersecond)
         {
-            double value = (double) gramspersecond;
-            return new MassFlow(value, MassFlowUnit.GramPerSecond);
+            return new MassFlow<T>(gramspersecond, MassFlowUnit.GramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from HectogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from HectogramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromHectogramsPerDay(QuantityValue hectogramsperday)
+        public static MassFlow<T> FromHectogramsPerDay(T hectogramsperday)
         {
-            double value = (double) hectogramsperday;
-            return new MassFlow(value, MassFlowUnit.HectogramPerDay);
+            return new MassFlow<T>(hectogramsperday, MassFlowUnit.HectogramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from HectogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from HectogramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromHectogramsPerSecond(QuantityValue hectogramspersecond)
+        public static MassFlow<T> FromHectogramsPerSecond(T hectogramspersecond)
         {
-            double value = (double) hectogramspersecond;
-            return new MassFlow(value, MassFlowUnit.HectogramPerSecond);
+            return new MassFlow<T>(hectogramspersecond, MassFlowUnit.HectogramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from KilogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from KilogramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerDay(QuantityValue kilogramsperday)
+        public static MassFlow<T> FromKilogramsPerDay(T kilogramsperday)
         {
-            double value = (double) kilogramsperday;
-            return new MassFlow(value, MassFlowUnit.KilogramPerDay);
+            return new MassFlow<T>(kilogramsperday, MassFlowUnit.KilogramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from KilogramsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> from KilogramsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerHour(QuantityValue kilogramsperhour)
+        public static MassFlow<T> FromKilogramsPerHour(T kilogramsperhour)
         {
-            double value = (double) kilogramsperhour;
-            return new MassFlow(value, MassFlowUnit.KilogramPerHour);
+            return new MassFlow<T>(kilogramsperhour, MassFlowUnit.KilogramPerHour);
         }
         /// <summary>
-        ///     Get MassFlow from KilogramsPerMinute.
+        ///     Get <see cref="MassFlow{T}" /> from KilogramsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerMinute(QuantityValue kilogramsperminute)
+        public static MassFlow<T> FromKilogramsPerMinute(T kilogramsperminute)
         {
-            double value = (double) kilogramsperminute;
-            return new MassFlow(value, MassFlowUnit.KilogramPerMinute);
+            return new MassFlow<T>(kilogramsperminute, MassFlowUnit.KilogramPerMinute);
         }
         /// <summary>
-        ///     Get MassFlow from KilogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from KilogramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerSecond(QuantityValue kilogramspersecond)
+        public static MassFlow<T> FromKilogramsPerSecond(T kilogramspersecond)
         {
-            double value = (double) kilogramspersecond;
-            return new MassFlow(value, MassFlowUnit.KilogramPerSecond);
+            return new MassFlow<T>(kilogramspersecond, MassFlowUnit.KilogramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from MegagramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from MegagramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegagramsPerDay(QuantityValue megagramsperday)
+        public static MassFlow<T> FromMegagramsPerDay(T megagramsperday)
         {
-            double value = (double) megagramsperday;
-            return new MassFlow(value, MassFlowUnit.MegagramPerDay);
+            return new MassFlow<T>(megagramsperday, MassFlowUnit.MegagramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from MegapoundsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from MegapoundsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerDay(QuantityValue megapoundsperday)
+        public static MassFlow<T> FromMegapoundsPerDay(T megapoundsperday)
         {
-            double value = (double) megapoundsperday;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerDay);
+            return new MassFlow<T>(megapoundsperday, MassFlowUnit.MegapoundPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from MegapoundsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> from MegapoundsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerHour(QuantityValue megapoundsperhour)
+        public static MassFlow<T> FromMegapoundsPerHour(T megapoundsperhour)
         {
-            double value = (double) megapoundsperhour;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerHour);
+            return new MassFlow<T>(megapoundsperhour, MassFlowUnit.MegapoundPerHour);
         }
         /// <summary>
-        ///     Get MassFlow from MegapoundsPerMinute.
+        ///     Get <see cref="MassFlow{T}" /> from MegapoundsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerMinute(QuantityValue megapoundsperminute)
+        public static MassFlow<T> FromMegapoundsPerMinute(T megapoundsperminute)
         {
-            double value = (double) megapoundsperminute;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerMinute);
+            return new MassFlow<T>(megapoundsperminute, MassFlowUnit.MegapoundPerMinute);
         }
         /// <summary>
-        ///     Get MassFlow from MegapoundsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from MegapoundsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerSecond(QuantityValue megapoundspersecond)
+        public static MassFlow<T> FromMegapoundsPerSecond(T megapoundspersecond)
         {
-            double value = (double) megapoundspersecond;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerSecond);
+            return new MassFlow<T>(megapoundspersecond, MassFlowUnit.MegapoundPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from MicrogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from MicrogramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMicrogramsPerDay(QuantityValue microgramsperday)
+        public static MassFlow<T> FromMicrogramsPerDay(T microgramsperday)
         {
-            double value = (double) microgramsperday;
-            return new MassFlow(value, MassFlowUnit.MicrogramPerDay);
+            return new MassFlow<T>(microgramsperday, MassFlowUnit.MicrogramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from MicrogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from MicrogramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMicrogramsPerSecond(QuantityValue microgramspersecond)
+        public static MassFlow<T> FromMicrogramsPerSecond(T microgramspersecond)
         {
-            double value = (double) microgramspersecond;
-            return new MassFlow(value, MassFlowUnit.MicrogramPerSecond);
+            return new MassFlow<T>(microgramspersecond, MassFlowUnit.MicrogramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from MilligramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from MilligramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMilligramsPerDay(QuantityValue milligramsperday)
+        public static MassFlow<T> FromMilligramsPerDay(T milligramsperday)
         {
-            double value = (double) milligramsperday;
-            return new MassFlow(value, MassFlowUnit.MilligramPerDay);
+            return new MassFlow<T>(milligramsperday, MassFlowUnit.MilligramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from MilligramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from MilligramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMilligramsPerSecond(QuantityValue milligramspersecond)
+        public static MassFlow<T> FromMilligramsPerSecond(T milligramspersecond)
         {
-            double value = (double) milligramspersecond;
-            return new MassFlow(value, MassFlowUnit.MilligramPerSecond);
+            return new MassFlow<T>(milligramspersecond, MassFlowUnit.MilligramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from NanogramsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from NanogramsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromNanogramsPerDay(QuantityValue nanogramsperday)
+        public static MassFlow<T> FromNanogramsPerDay(T nanogramsperday)
         {
-            double value = (double) nanogramsperday;
-            return new MassFlow(value, MassFlowUnit.NanogramPerDay);
+            return new MassFlow<T>(nanogramsperday, MassFlowUnit.NanogramPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from NanogramsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from NanogramsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromNanogramsPerSecond(QuantityValue nanogramspersecond)
+        public static MassFlow<T> FromNanogramsPerSecond(T nanogramspersecond)
         {
-            double value = (double) nanogramspersecond;
-            return new MassFlow(value, MassFlowUnit.NanogramPerSecond);
+            return new MassFlow<T>(nanogramspersecond, MassFlowUnit.NanogramPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from PoundsPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from PoundsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerDay(QuantityValue poundsperday)
+        public static MassFlow<T> FromPoundsPerDay(T poundsperday)
         {
-            double value = (double) poundsperday;
-            return new MassFlow(value, MassFlowUnit.PoundPerDay);
+            return new MassFlow<T>(poundsperday, MassFlowUnit.PoundPerDay);
         }
         /// <summary>
-        ///     Get MassFlow from PoundsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> from PoundsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerHour(QuantityValue poundsperhour)
+        public static MassFlow<T> FromPoundsPerHour(T poundsperhour)
         {
-            double value = (double) poundsperhour;
-            return new MassFlow(value, MassFlowUnit.PoundPerHour);
+            return new MassFlow<T>(poundsperhour, MassFlowUnit.PoundPerHour);
         }
         /// <summary>
-        ///     Get MassFlow from PoundsPerMinute.
+        ///     Get <see cref="MassFlow{T}" /> from PoundsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerMinute(QuantityValue poundsperminute)
+        public static MassFlow<T> FromPoundsPerMinute(T poundsperminute)
         {
-            double value = (double) poundsperminute;
-            return new MassFlow(value, MassFlowUnit.PoundPerMinute);
+            return new MassFlow<T>(poundsperminute, MassFlowUnit.PoundPerMinute);
         }
         /// <summary>
-        ///     Get MassFlow from PoundsPerSecond.
+        ///     Get <see cref="MassFlow{T}" /> from PoundsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerSecond(QuantityValue poundspersecond)
+        public static MassFlow<T> FromPoundsPerSecond(T poundspersecond)
         {
-            double value = (double) poundspersecond;
-            return new MassFlow(value, MassFlowUnit.PoundPerSecond);
+            return new MassFlow<T>(poundspersecond, MassFlowUnit.PoundPerSecond);
         }
         /// <summary>
-        ///     Get MassFlow from ShortTonsPerHour.
+        ///     Get <see cref="MassFlow{T}" /> from ShortTonsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromShortTonsPerHour(QuantityValue shorttonsperhour)
+        public static MassFlow<T> FromShortTonsPerHour(T shorttonsperhour)
         {
-            double value = (double) shorttonsperhour;
-            return new MassFlow(value, MassFlowUnit.ShortTonPerHour);
+            return new MassFlow<T>(shorttonsperhour, MassFlowUnit.ShortTonPerHour);
         }
         /// <summary>
-        ///     Get MassFlow from TonnesPerDay.
+        ///     Get <see cref="MassFlow{T}" /> from TonnesPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromTonnesPerDay(QuantityValue tonnesperday)
+        public static MassFlow<T> FromTonnesPerDay(T tonnesperday)
         {
-            double value = (double) tonnesperday;
-            return new MassFlow(value, MassFlowUnit.TonnePerDay);
+            return new MassFlow<T>(tonnesperday, MassFlowUnit.TonnePerDay);
         }
         /// <summary>
-        ///     Get MassFlow from TonnesPerHour.
+        ///     Get <see cref="MassFlow{T}" /> from TonnesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromTonnesPerHour(QuantityValue tonnesperhour)
+        public static MassFlow<T> FromTonnesPerHour(T tonnesperhour)
         {
-            double value = (double) tonnesperhour;
-            return new MassFlow(value, MassFlowUnit.TonnePerHour);
+            return new MassFlow<T>(tonnesperhour, MassFlowUnit.TonnePerHour);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassFlowUnit" /> to <see cref="MassFlow" />.
+        ///     Dynamically convert from value and unit enum <see cref="MassFlowUnit" /> to <see cref="MassFlow{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassFlow unit value.</returns>
-        public static MassFlow From(QuantityValue value, MassFlowUnit fromUnit)
+        /// <returns><see cref="MassFlow{T}" /> unit value.</returns>
+        public static MassFlow<T> From(T value, MassFlowUnit fromUnit)
         {
-            return new MassFlow((double)value, fromUnit);
+            return new MassFlow<T>(value, fromUnit);
         }
 
         #endregion
@@ -727,7 +692,7 @@ public static MassFlow From(QuantityValue value, MassFlowUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MassFlow Parse(string str)
+        public static MassFlow<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -755,9 +720,9 @@ public static MassFlow Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MassFlow Parse(string str, IFormatProvider? provider)
+        public static MassFlow<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MassFlow, MassFlowUnit>(
+            return QuantityParser.Default.Parse<T, MassFlow<T>, MassFlowUnit>(
                 str,
                 provider,
                 From);
@@ -771,7 +736,7 @@ public static MassFlow Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MassFlow result)
+        public static bool TryParse(string? str, out MassFlow<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -786,9 +751,9 @@ public static bool TryParse(string? str, out MassFlow result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MassFlow result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MassFlow<T> result)
         {
-            return QuantityParser.Default.TryParse<MassFlow, MassFlowUnit>(
+            return QuantityParser.Default.TryParse<T, MassFlow<T>, MassFlowUnit>(
                 str,
                 provider,
                 From,
@@ -850,45 +815,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MassFlow operator -(MassFlow right)
+        public static MassFlow<T> operator -(MassFlow<T> right)
         {
-            return new MassFlow(-right.Value, right.Unit);
+            return new MassFlow<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from adding two <see cref="MassFlow"/>.</summary>
-        public static MassFlow operator +(MassFlow left, MassFlow right)
+        /// <summary>Get <see cref="MassFlow{T}"/> from adding two <see cref="MassFlow{T}"/>.</summary>
+        public static MassFlow<T> operator +(MassFlow<T> left, MassFlow<T> right)
         {
-            return new MassFlow(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MassFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from subtracting two <see cref="MassFlow"/>.</summary>
-        public static MassFlow operator -(MassFlow left, MassFlow right)
+        /// <summary>Get <see cref="MassFlow{T}"/> from subtracting two <see cref="MassFlow{T}"/>.</summary>
+        public static MassFlow<T> operator -(MassFlow<T> left, MassFlow<T> right)
         {
-            return new MassFlow(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MassFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from multiplying value and <see cref="MassFlow"/>.</summary>
-        public static MassFlow operator *(double left, MassFlow right)
+        /// <summary>Get <see cref="MassFlow{T}"/> from multiplying value and <see cref="MassFlow{T}"/>.</summary>
+        public static MassFlow<T> operator *(T left, MassFlow<T> right)
         {
-            return new MassFlow(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MassFlow<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from multiplying value and <see cref="MassFlow"/>.</summary>
-        public static MassFlow operator *(MassFlow left, double right)
+        /// <summary>Get <see cref="MassFlow{T}"/> from multiplying value and <see cref="MassFlow{T}"/>.</summary>
+        public static MassFlow<T> operator *(MassFlow<T> left, T right)
         {
-            return new MassFlow(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MassFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlow"/> from dividing <see cref="MassFlow"/> by value.</summary>
-        public static MassFlow operator /(MassFlow left, double right)
+        /// <summary>Get <see cref="MassFlow{T}"/> from dividing <see cref="MassFlow{T}"/> by value.</summary>
+        public static MassFlow<T> operator /(MassFlow<T> left, T right)
         {
-            return new MassFlow(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MassFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MassFlow"/> by <see cref="MassFlow"/>.</summary>
-        public static double operator /(MassFlow left, MassFlow right)
+        /// <summary>Get ratio value from dividing <see cref="MassFlow{T}"/> by <see cref="MassFlow{T}"/>.</summary>
+        public static T operator /(MassFlow<T> left, MassFlow<T> right)
         {
-            return left.GramsPerSecond / right.GramsPerSecond;
+            return CompiledLambdas.Divide(left.GramsPerSecond, right.GramsPerSecond);
         }
 
         #endregion
@@ -896,39 +866,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MassFlow left, MassFlow right)
+        public static bool operator <=(MassFlow<T> left, MassFlow<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MassFlow left, MassFlow right)
+        public static bool operator >=(MassFlow<T> left, MassFlow<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MassFlow left, MassFlow right)
+        public static bool operator <(MassFlow<T> left, MassFlow<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MassFlow left, MassFlow right)
+        public static bool operator >(MassFlow<T> left, MassFlow<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MassFlow left, MassFlow right)
+        /// <remarks>Consider using <see cref="Equals(MassFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MassFlow<T> left, MassFlow<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MassFlow left, MassFlow right)
+        /// <remarks>Consider using <see cref="Equals(MassFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MassFlow<T> left, MassFlow<T> right)
         {
             return !(left == right);
         }
@@ -937,37 +907,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MassFlow objMassFlow)) throw new ArgumentException("Expected type MassFlow.", nameof(obj));
+            if(!(obj is MassFlow<T> objMassFlow)) throw new ArgumentException("Expected type MassFlow.", nameof(obj));
 
             return CompareTo(objMassFlow);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MassFlow other)
+        public int CompareTo(MassFlow<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MassFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MassFlow objMassFlow))
+            if(obj is null || !(obj is MassFlow<T> objMassFlow))
                 return false;
 
             return Equals(objMassFlow);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MassFlow other)
+        /// <remarks>Consider using <see cref="Equals(MassFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MassFlow<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MassFlow within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MassFlow{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1005,21 +975,19 @@ public bool Equals(MassFlow other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MassFlow other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MassFlow<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MassFlow.</returns>
+        /// <returns>A hash code for the current <see cref="MassFlow{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1033,17 +1001,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassFlowUnit unit)
+        public T As(MassFlowUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1063,17 +1031,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MassFlowUnit unitAsMassFlowUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFlowUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMassFlowUnit);
+            var asValue = As(unitAsMassFlowUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MassFlowUnit>.As(MassFlowUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MassFlow to another MassFlow with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MassFlow{T}" /> to another <see cref="MassFlow{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MassFlow with the specified unit.</returns>
-        public MassFlow ToUnit(MassFlowUnit unit)
+        /// <returns>A <see cref="MassFlow{T}" /> with the specified unit.</returns>
+        public MassFlow<T> ToUnit(MassFlowUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MassFlow(convertedValue, unit);
+            return new MassFlow<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1086,7 +1059,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MassFlow ToUnit(UnitSystem unitSystem)
+        public MassFlow<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1106,51 +1079,57 @@ public MassFlow ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassFlowUnit> IQuantity<MassFlowUnit>.ToUnit(MassFlowUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MassFlowUnit, T> IQuantityT<MassFlowUnit, T>.ToUnit(MassFlowUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MassFlowUnit> IQuantity<MassFlowUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MassFlowUnit, T> IQuantityT<MassFlowUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MassFlowUnit.CentigramPerDay: return (_value/86400) * 1e-2d;
-                case MassFlowUnit.CentigramPerSecond: return (_value) * 1e-2d;
-                case MassFlowUnit.DecagramPerDay: return (_value/86400) * 1e1d;
-                case MassFlowUnit.DecagramPerSecond: return (_value) * 1e1d;
-                case MassFlowUnit.DecigramPerDay: return (_value/86400) * 1e-1d;
-                case MassFlowUnit.DecigramPerSecond: return (_value) * 1e-1d;
-                case MassFlowUnit.GramPerDay: return _value/86400;
-                case MassFlowUnit.GramPerHour: return _value/3600;
-                case MassFlowUnit.GramPerSecond: return _value;
-                case MassFlowUnit.HectogramPerDay: return (_value/86400) * 1e2d;
-                case MassFlowUnit.HectogramPerSecond: return (_value) * 1e2d;
-                case MassFlowUnit.KilogramPerDay: return (_value/86400) * 1e3d;
-                case MassFlowUnit.KilogramPerHour: return _value/3.6;
-                case MassFlowUnit.KilogramPerMinute: return _value/0.06;
-                case MassFlowUnit.KilogramPerSecond: return (_value) * 1e3d;
-                case MassFlowUnit.MegagramPerDay: return (_value/86400) * 1e6d;
-                case MassFlowUnit.MegapoundPerDay: return (_value/190.47936) * 1e6d;
-                case MassFlowUnit.MegapoundPerHour: return (_value/7.93664) * 1e6d;
-                case MassFlowUnit.MegapoundPerMinute: return (_value/0.132277) * 1e6d;
-                case MassFlowUnit.MegapoundPerSecond: return (_value * 453.59237) * 1e6d;
-                case MassFlowUnit.MicrogramPerDay: return (_value/86400) * 1e-6d;
-                case MassFlowUnit.MicrogramPerSecond: return (_value) * 1e-6d;
-                case MassFlowUnit.MilligramPerDay: return (_value/86400) * 1e-3d;
-                case MassFlowUnit.MilligramPerSecond: return (_value) * 1e-3d;
-                case MassFlowUnit.NanogramPerDay: return (_value/86400) * 1e-9d;
-                case MassFlowUnit.NanogramPerSecond: return (_value) * 1e-9d;
-                case MassFlowUnit.PoundPerDay: return _value/190.47936;
-                case MassFlowUnit.PoundPerHour: return _value/7.93664;
-                case MassFlowUnit.PoundPerMinute: return _value/0.132277;
-                case MassFlowUnit.PoundPerSecond: return _value * 453.59237;
-                case MassFlowUnit.ShortTonPerHour: return _value*251.9957611;
-                case MassFlowUnit.TonnePerDay: return _value/0.0864000;
-                case MassFlowUnit.TonnePerHour: return 1000*_value/3.6;
+                case MassFlowUnit.CentigramPerDay: return (Value/86400) * 1e-2d;
+                case MassFlowUnit.CentigramPerSecond: return (Value) * 1e-2d;
+                case MassFlowUnit.DecagramPerDay: return (Value/86400) * 1e1d;
+                case MassFlowUnit.DecagramPerSecond: return (Value) * 1e1d;
+                case MassFlowUnit.DecigramPerDay: return (Value/86400) * 1e-1d;
+                case MassFlowUnit.DecigramPerSecond: return (Value) * 1e-1d;
+                case MassFlowUnit.GramPerDay: return Value/86400;
+                case MassFlowUnit.GramPerHour: return Value/3600;
+                case MassFlowUnit.GramPerSecond: return Value;
+                case MassFlowUnit.HectogramPerDay: return (Value/86400) * 1e2d;
+                case MassFlowUnit.HectogramPerSecond: return (Value) * 1e2d;
+                case MassFlowUnit.KilogramPerDay: return (Value/86400) * 1e3d;
+                case MassFlowUnit.KilogramPerHour: return Value/3.6;
+                case MassFlowUnit.KilogramPerMinute: return Value/0.06;
+                case MassFlowUnit.KilogramPerSecond: return (Value) * 1e3d;
+                case MassFlowUnit.MegagramPerDay: return (Value/86400) * 1e6d;
+                case MassFlowUnit.MegapoundPerDay: return (Value/190.47936) * 1e6d;
+                case MassFlowUnit.MegapoundPerHour: return (Value/7.93664) * 1e6d;
+                case MassFlowUnit.MegapoundPerMinute: return (Value/0.132277) * 1e6d;
+                case MassFlowUnit.MegapoundPerSecond: return (Value * 453.59237) * 1e6d;
+                case MassFlowUnit.MicrogramPerDay: return (Value/86400) * 1e-6d;
+                case MassFlowUnit.MicrogramPerSecond: return (Value) * 1e-6d;
+                case MassFlowUnit.MilligramPerDay: return (Value/86400) * 1e-3d;
+                case MassFlowUnit.MilligramPerSecond: return (Value) * 1e-3d;
+                case MassFlowUnit.NanogramPerDay: return (Value/86400) * 1e-9d;
+                case MassFlowUnit.NanogramPerSecond: return (Value) * 1e-9d;
+                case MassFlowUnit.PoundPerDay: return Value/190.47936;
+                case MassFlowUnit.PoundPerHour: return Value/7.93664;
+                case MassFlowUnit.PoundPerMinute: return Value/0.132277;
+                case MassFlowUnit.PoundPerSecond: return Value * 453.59237;
+                case MassFlowUnit.ShortTonPerHour: return Value*251.9957611;
+                case MassFlowUnit.TonnePerDay: return Value/0.0864000;
+                case MassFlowUnit.TonnePerHour: return 1000*Value/3.6;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1161,16 +1140,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MassFlow ToBaseUnit()
+        internal MassFlow<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MassFlow(baseUnitValue, BaseUnit);
+            return new MassFlow<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MassFlowUnit unit)
+        private T GetValueAs(MassFlowUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1305,57 +1284,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFlow)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFlow<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFlow)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFlow<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFlow)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFlow<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1365,33 +1344,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MassFlow))
+            if(conversionType == typeof(MassFlow<T>))
                 return this;
             else if(conversionType == typeof(MassFlowUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MassFlow.QuantityType;
+                return MassFlow<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MassFlow.Info;
+                return MassFlow<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MassFlow.BaseDimensions;
+                return MassFlow<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MassFlow)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MassFlow<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
index 9bacd882cd..6da10643b6 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Mass flux is the mass flow rate per unit area.
     /// </summary>
-    public partial struct MassFlux : IQuantity<MassFluxUnit>, IEquatable<MassFlux>, IComparable, IComparable<MassFlux>, IConvertible, IFormattable
+    public partial struct MassFlux<T> : IQuantityT<MassFluxUnit, T>, IEquatable<MassFlux<T>>, IComparable, IComparable<MassFlux<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -74,12 +70,12 @@ static MassFlux()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MassFlux(double value, MassFluxUnit unit)
+        public MassFlux(T value, MassFluxUnit unit)
         {
             if(unit == MassFluxUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -91,14 +87,14 @@ public MassFlux(double value, MassFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassFlux(double value, UnitSystem unitSystem)
+        public MassFlux(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -113,19 +109,19 @@ public MassFlux(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MassFlux, which is KilogramPerSecondPerSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="MassFlux{T}" />, which is KilogramPerSecondPerSquareMeter. All conversions go via this value.
         /// </summary>
         public static MassFluxUnit BaseUnit { get; } = MassFluxUnit.KilogramPerSecondPerSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of MassFlux
+        /// Represents the largest possible value of <see cref="MassFlux{T}" />
         /// </summary>
-        public static MassFlux MaxValue { get; } = new MassFlux(double.MaxValue, BaseUnit);
+        public static MassFlux<T> MaxValue { get; } = new MassFlux<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MassFlux
+        /// Represents the smallest possible value of <see cref="MassFlux{T}" />
         /// </summary>
-        public static MassFlux MinValue { get; } = new MassFlux(double.MinValue, BaseUnit);
+        public static MassFlux<T> MinValue { get; } = new MassFlux<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -134,14 +130,14 @@ public MassFlux(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MassFlux;
 
         /// <summary>
-        ///     All units of measurement for the MassFlux quantity.
+        ///     All units of measurement for the <see cref="MassFlux{T}" /> quantity.
         /// </summary>
         public static MassFluxUnit[] Units { get; } = Enum.GetValues(typeof(MassFluxUnit)).Cast<MassFluxUnit>().Except(new MassFluxUnit[]{ MassFluxUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramPerSecondPerSquareMeter.
         /// </summary>
-        public static MassFlux Zero { get; } = new MassFlux(0, BaseUnit);
+        public static MassFlux<T> Zero { get; } = new MassFlux<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -150,7 +146,9 @@ public MassFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -166,76 +164,76 @@ public MassFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MassFlux.QuantityType;
+        public QuantityType Type => MassFlux<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MassFlux.BaseDimensions;
+        public BaseDimensions Dimensions => MassFlux<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MassFlux in GramsPerHourPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> in GramsPerHourPerSquareCentimeter.
         /// </summary>
-        public double GramsPerHourPerSquareCentimeter => As(MassFluxUnit.GramPerHourPerSquareCentimeter);
+        public T GramsPerHourPerSquareCentimeter => As(MassFluxUnit.GramPerHourPerSquareCentimeter);
 
         /// <summary>
-        ///     Get MassFlux in GramsPerHourPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> in GramsPerHourPerSquareMeter.
         /// </summary>
-        public double GramsPerHourPerSquareMeter => As(MassFluxUnit.GramPerHourPerSquareMeter);
+        public T GramsPerHourPerSquareMeter => As(MassFluxUnit.GramPerHourPerSquareMeter);
 
         /// <summary>
-        ///     Get MassFlux in GramsPerHourPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> in GramsPerHourPerSquareMillimeter.
         /// </summary>
-        public double GramsPerHourPerSquareMillimeter => As(MassFluxUnit.GramPerHourPerSquareMillimeter);
+        public T GramsPerHourPerSquareMillimeter => As(MassFluxUnit.GramPerHourPerSquareMillimeter);
 
         /// <summary>
-        ///     Get MassFlux in GramsPerSecondPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> in GramsPerSecondPerSquareCentimeter.
         /// </summary>
-        public double GramsPerSecondPerSquareCentimeter => As(MassFluxUnit.GramPerSecondPerSquareCentimeter);
+        public T GramsPerSecondPerSquareCentimeter => As(MassFluxUnit.GramPerSecondPerSquareCentimeter);
 
         /// <summary>
-        ///     Get MassFlux in GramsPerSecondPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> in GramsPerSecondPerSquareMeter.
         /// </summary>
-        public double GramsPerSecondPerSquareMeter => As(MassFluxUnit.GramPerSecondPerSquareMeter);
+        public T GramsPerSecondPerSquareMeter => As(MassFluxUnit.GramPerSecondPerSquareMeter);
 
         /// <summary>
-        ///     Get MassFlux in GramsPerSecondPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> in GramsPerSecondPerSquareMillimeter.
         /// </summary>
-        public double GramsPerSecondPerSquareMillimeter => As(MassFluxUnit.GramPerSecondPerSquareMillimeter);
+        public T GramsPerSecondPerSquareMillimeter => As(MassFluxUnit.GramPerSecondPerSquareMillimeter);
 
         /// <summary>
-        ///     Get MassFlux in KilogramsPerHourPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> in KilogramsPerHourPerSquareCentimeter.
         /// </summary>
-        public double KilogramsPerHourPerSquareCentimeter => As(MassFluxUnit.KilogramPerHourPerSquareCentimeter);
+        public T KilogramsPerHourPerSquareCentimeter => As(MassFluxUnit.KilogramPerHourPerSquareCentimeter);
 
         /// <summary>
-        ///     Get MassFlux in KilogramsPerHourPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> in KilogramsPerHourPerSquareMeter.
         /// </summary>
-        public double KilogramsPerHourPerSquareMeter => As(MassFluxUnit.KilogramPerHourPerSquareMeter);
+        public T KilogramsPerHourPerSquareMeter => As(MassFluxUnit.KilogramPerHourPerSquareMeter);
 
         /// <summary>
-        ///     Get MassFlux in KilogramsPerHourPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> in KilogramsPerHourPerSquareMillimeter.
         /// </summary>
-        public double KilogramsPerHourPerSquareMillimeter => As(MassFluxUnit.KilogramPerHourPerSquareMillimeter);
+        public T KilogramsPerHourPerSquareMillimeter => As(MassFluxUnit.KilogramPerHourPerSquareMillimeter);
 
         /// <summary>
-        ///     Get MassFlux in KilogramsPerSecondPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> in KilogramsPerSecondPerSquareCentimeter.
         /// </summary>
-        public double KilogramsPerSecondPerSquareCentimeter => As(MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
+        public T KilogramsPerSecondPerSquareCentimeter => As(MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
 
         /// <summary>
-        ///     Get MassFlux in KilogramsPerSecondPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> in KilogramsPerSecondPerSquareMeter.
         /// </summary>
-        public double KilogramsPerSecondPerSquareMeter => As(MassFluxUnit.KilogramPerSecondPerSquareMeter);
+        public T KilogramsPerSecondPerSquareMeter => As(MassFluxUnit.KilogramPerSecondPerSquareMeter);
 
         /// <summary>
-        ///     Get MassFlux in KilogramsPerSecondPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> in KilogramsPerSecondPerSquareMillimeter.
         /// </summary>
-        public double KilogramsPerSecondPerSquareMillimeter => As(MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
+        public T KilogramsPerSecondPerSquareMillimeter => As(MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
 
         #endregion
 
@@ -267,123 +265,111 @@ public static string GetAbbreviation(MassFluxUnit unit, IFormatProvider? provide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MassFlux from GramsPerHourPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> from GramsPerHourPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareCentimeter(QuantityValue gramsperhourpersquarecentimeter)
+        public static MassFlux<T> FromGramsPerHourPerSquareCentimeter(T gramsperhourpersquarecentimeter)
         {
-            double value = (double) gramsperhourpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter);
+            return new MassFlux<T>(gramsperhourpersquarecentimeter, MassFluxUnit.GramPerHourPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassFlux from GramsPerHourPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> from GramsPerHourPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareMeter(QuantityValue gramsperhourpersquaremeter)
+        public static MassFlux<T> FromGramsPerHourPerSquareMeter(T gramsperhourpersquaremeter)
         {
-            double value = (double) gramsperhourpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter);
+            return new MassFlux<T>(gramsperhourpersquaremeter, MassFluxUnit.GramPerHourPerSquareMeter);
         }
         /// <summary>
-        ///     Get MassFlux from GramsPerHourPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> from GramsPerHourPerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareMillimeter(QuantityValue gramsperhourpersquaremillimeter)
+        public static MassFlux<T> FromGramsPerHourPerSquareMillimeter(T gramsperhourpersquaremillimeter)
         {
-            double value = (double) gramsperhourpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter);
+            return new MassFlux<T>(gramsperhourpersquaremillimeter, MassFluxUnit.GramPerHourPerSquareMillimeter);
         }
         /// <summary>
-        ///     Get MassFlux from GramsPerSecondPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> from GramsPerSecondPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareCentimeter(QuantityValue gramspersecondpersquarecentimeter)
+        public static MassFlux<T> FromGramsPerSecondPerSquareCentimeter(T gramspersecondpersquarecentimeter)
         {
-            double value = (double) gramspersecondpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter);
+            return new MassFlux<T>(gramspersecondpersquarecentimeter, MassFluxUnit.GramPerSecondPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassFlux from GramsPerSecondPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> from GramsPerSecondPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareMeter(QuantityValue gramspersecondpersquaremeter)
+        public static MassFlux<T> FromGramsPerSecondPerSquareMeter(T gramspersecondpersquaremeter)
         {
-            double value = (double) gramspersecondpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter);
+            return new MassFlux<T>(gramspersecondpersquaremeter, MassFluxUnit.GramPerSecondPerSquareMeter);
         }
         /// <summary>
-        ///     Get MassFlux from GramsPerSecondPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> from GramsPerSecondPerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareMillimeter(QuantityValue gramspersecondpersquaremillimeter)
+        public static MassFlux<T> FromGramsPerSecondPerSquareMillimeter(T gramspersecondpersquaremillimeter)
         {
-            double value = (double) gramspersecondpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter);
+            return new MassFlux<T>(gramspersecondpersquaremillimeter, MassFluxUnit.GramPerSecondPerSquareMillimeter);
         }
         /// <summary>
-        ///     Get MassFlux from KilogramsPerHourPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> from KilogramsPerHourPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(QuantityValue kilogramsperhourpersquarecentimeter)
+        public static MassFlux<T> FromKilogramsPerHourPerSquareCentimeter(T kilogramsperhourpersquarecentimeter)
         {
-            double value = (double) kilogramsperhourpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
+            return new MassFlux<T>(kilogramsperhourpersquarecentimeter, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassFlux from KilogramsPerHourPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> from KilogramsPerHourPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareMeter(QuantityValue kilogramsperhourpersquaremeter)
+        public static MassFlux<T> FromKilogramsPerHourPerSquareMeter(T kilogramsperhourpersquaremeter)
         {
-            double value = (double) kilogramsperhourpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter);
+            return new MassFlux<T>(kilogramsperhourpersquaremeter, MassFluxUnit.KilogramPerHourPerSquareMeter);
         }
         /// <summary>
-        ///     Get MassFlux from KilogramsPerHourPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> from KilogramsPerHourPerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(QuantityValue kilogramsperhourpersquaremillimeter)
+        public static MassFlux<T> FromKilogramsPerHourPerSquareMillimeter(T kilogramsperhourpersquaremillimeter)
         {
-            double value = (double) kilogramsperhourpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
+            return new MassFlux<T>(kilogramsperhourpersquaremillimeter, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
         }
         /// <summary>
-        ///     Get MassFlux from KilogramsPerSecondPerSquareCentimeter.
+        ///     Get <see cref="MassFlux{T}" /> from KilogramsPerSecondPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(QuantityValue kilogramspersecondpersquarecentimeter)
+        public static MassFlux<T> FromKilogramsPerSecondPerSquareCentimeter(T kilogramspersecondpersquarecentimeter)
         {
-            double value = (double) kilogramspersecondpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
+            return new MassFlux<T>(kilogramspersecondpersquarecentimeter, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassFlux from KilogramsPerSecondPerSquareMeter.
+        ///     Get <see cref="MassFlux{T}" /> from KilogramsPerSecondPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareMeter(QuantityValue kilogramspersecondpersquaremeter)
+        public static MassFlux<T> FromKilogramsPerSecondPerSquareMeter(T kilogramspersecondpersquaremeter)
         {
-            double value = (double) kilogramspersecondpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter);
+            return new MassFlux<T>(kilogramspersecondpersquaremeter, MassFluxUnit.KilogramPerSecondPerSquareMeter);
         }
         /// <summary>
-        ///     Get MassFlux from KilogramsPerSecondPerSquareMillimeter.
+        ///     Get <see cref="MassFlux{T}" /> from KilogramsPerSecondPerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(QuantityValue kilogramspersecondpersquaremillimeter)
+        public static MassFlux<T> FromKilogramsPerSecondPerSquareMillimeter(T kilogramspersecondpersquaremillimeter)
         {
-            double value = (double) kilogramspersecondpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
+            return new MassFlux<T>(kilogramspersecondpersquaremillimeter, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassFluxUnit" /> to <see cref="MassFlux" />.
+        ///     Dynamically convert from value and unit enum <see cref="MassFluxUnit" /> to <see cref="MassFlux{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassFlux unit value.</returns>
-        public static MassFlux From(QuantityValue value, MassFluxUnit fromUnit)
+        /// <returns><see cref="MassFlux{T}" /> unit value.</returns>
+        public static MassFlux<T> From(T value, MassFluxUnit fromUnit)
         {
-            return new MassFlux((double)value, fromUnit);
+            return new MassFlux<T>(value, fromUnit);
         }
 
         #endregion
@@ -412,7 +398,7 @@ public static MassFlux From(QuantityValue value, MassFluxUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MassFlux Parse(string str)
+        public static MassFlux<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -440,9 +426,9 @@ public static MassFlux Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MassFlux Parse(string str, IFormatProvider? provider)
+        public static MassFlux<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MassFlux, MassFluxUnit>(
+            return QuantityParser.Default.Parse<T, MassFlux<T>, MassFluxUnit>(
                 str,
                 provider,
                 From);
@@ -456,7 +442,7 @@ public static MassFlux Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MassFlux result)
+        public static bool TryParse(string? str, out MassFlux<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -471,9 +457,9 @@ public static bool TryParse(string? str, out MassFlux result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MassFlux result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MassFlux<T> result)
         {
-            return QuantityParser.Default.TryParse<MassFlux, MassFluxUnit>(
+            return QuantityParser.Default.TryParse<T, MassFlux<T>, MassFluxUnit>(
                 str,
                 provider,
                 From,
@@ -535,45 +521,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MassFlux operator -(MassFlux right)
+        public static MassFlux<T> operator -(MassFlux<T> right)
         {
-            return new MassFlux(-right.Value, right.Unit);
+            return new MassFlux<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> from adding two <see cref="MassFlux"/>.</summary>
-        public static MassFlux operator +(MassFlux left, MassFlux right)
+        /// <summary>Get <see cref="MassFlux{T}"/> from adding two <see cref="MassFlux{T}"/>.</summary>
+        public static MassFlux<T> operator +(MassFlux<T> left, MassFlux<T> right)
         {
-            return new MassFlux(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MassFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> from subtracting two <see cref="MassFlux"/>.</summary>
-        public static MassFlux operator -(MassFlux left, MassFlux right)
+        /// <summary>Get <see cref="MassFlux{T}"/> from subtracting two <see cref="MassFlux{T}"/>.</summary>
+        public static MassFlux<T> operator -(MassFlux<T> left, MassFlux<T> right)
         {
-            return new MassFlux(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MassFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> from multiplying value and <see cref="MassFlux"/>.</summary>
-        public static MassFlux operator *(double left, MassFlux right)
+        /// <summary>Get <see cref="MassFlux{T}"/> from multiplying value and <see cref="MassFlux{T}"/>.</summary>
+        public static MassFlux<T> operator *(T left, MassFlux<T> right)
         {
-            return new MassFlux(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MassFlux<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> from multiplying value and <see cref="MassFlux"/>.</summary>
-        public static MassFlux operator *(MassFlux left, double right)
+        /// <summary>Get <see cref="MassFlux{T}"/> from multiplying value and <see cref="MassFlux{T}"/>.</summary>
+        public static MassFlux<T> operator *(MassFlux<T> left, T right)
         {
-            return new MassFlux(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MassFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFlux"/> from dividing <see cref="MassFlux"/> by value.</summary>
-        public static MassFlux operator /(MassFlux left, double right)
+        /// <summary>Get <see cref="MassFlux{T}"/> from dividing <see cref="MassFlux{T}"/> by value.</summary>
+        public static MassFlux<T> operator /(MassFlux<T> left, T right)
         {
-            return new MassFlux(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MassFlux<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MassFlux"/> by <see cref="MassFlux"/>.</summary>
-        public static double operator /(MassFlux left, MassFlux right)
+        /// <summary>Get ratio value from dividing <see cref="MassFlux{T}"/> by <see cref="MassFlux{T}"/>.</summary>
+        public static T operator /(MassFlux<T> left, MassFlux<T> right)
         {
-            return left.KilogramsPerSecondPerSquareMeter / right.KilogramsPerSecondPerSquareMeter;
+            return CompiledLambdas.Divide(left.KilogramsPerSecondPerSquareMeter, right.KilogramsPerSecondPerSquareMeter);
         }
 
         #endregion
@@ -581,39 +572,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MassFlux left, MassFlux right)
+        public static bool operator <=(MassFlux<T> left, MassFlux<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MassFlux left, MassFlux right)
+        public static bool operator >=(MassFlux<T> left, MassFlux<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MassFlux left, MassFlux right)
+        public static bool operator <(MassFlux<T> left, MassFlux<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MassFlux left, MassFlux right)
+        public static bool operator >(MassFlux<T> left, MassFlux<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MassFlux left, MassFlux right)
+        /// <remarks>Consider using <see cref="Equals(MassFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MassFlux<T> left, MassFlux<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MassFlux left, MassFlux right)
+        /// <remarks>Consider using <see cref="Equals(MassFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MassFlux<T> left, MassFlux<T> right)
         {
             return !(left == right);
         }
@@ -622,37 +613,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MassFlux objMassFlux)) throw new ArgumentException("Expected type MassFlux.", nameof(obj));
+            if(!(obj is MassFlux<T> objMassFlux)) throw new ArgumentException("Expected type MassFlux.", nameof(obj));
 
             return CompareTo(objMassFlux);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MassFlux other)
+        public int CompareTo(MassFlux<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MassFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MassFlux objMassFlux))
+            if(obj is null || !(obj is MassFlux<T> objMassFlux))
                 return false;
 
             return Equals(objMassFlux);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassFlux, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MassFlux other)
+        /// <remarks>Consider using <see cref="Equals(MassFlux{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MassFlux<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MassFlux within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MassFlux{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -690,21 +681,19 @@ public bool Equals(MassFlux other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MassFlux other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MassFlux<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MassFlux.</returns>
+        /// <returns>A hash code for the current <see cref="MassFlux{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -718,17 +707,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassFluxUnit unit)
+        public T As(MassFluxUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -748,17 +737,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MassFluxUnit unitAsMassFluxUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFluxUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMassFluxUnit);
+            var asValue = As(unitAsMassFluxUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MassFluxUnit>.As(MassFluxUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MassFlux to another MassFlux with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MassFlux{T}" /> to another <see cref="MassFlux{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MassFlux with the specified unit.</returns>
-        public MassFlux ToUnit(MassFluxUnit unit)
+        /// <returns>A <see cref="MassFlux{T}" /> with the specified unit.</returns>
+        public MassFlux<T> ToUnit(MassFluxUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MassFlux(convertedValue, unit);
+            return new MassFlux<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -771,7 +765,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MassFlux ToUnit(UnitSystem unitSystem)
+        public MassFlux<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -791,30 +785,36 @@ public MassFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassFluxUnit> IQuantity<MassFluxUnit>.ToUnit(MassFluxUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MassFluxUnit, T> IQuantityT<MassFluxUnit, T>.ToUnit(MassFluxUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MassFluxUnit> IQuantity<MassFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MassFluxUnit, T> IQuantityT<MassFluxUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MassFluxUnit.GramPerHourPerSquareCentimeter: return _value/3.6e2;
-                case MassFluxUnit.GramPerHourPerSquareMeter: return _value/3.6e6;
-                case MassFluxUnit.GramPerHourPerSquareMillimeter: return _value/3.6e0;
-                case MassFluxUnit.GramPerSecondPerSquareCentimeter: return _value/1e-1;
-                case MassFluxUnit.GramPerSecondPerSquareMeter: return _value/1e3;
-                case MassFluxUnit.GramPerSecondPerSquareMillimeter: return _value/1e-3;
-                case MassFluxUnit.KilogramPerHourPerSquareCentimeter: return (_value/3.6e2) * 1e3d;
-                case MassFluxUnit.KilogramPerHourPerSquareMeter: return (_value/3.6e6) * 1e3d;
-                case MassFluxUnit.KilogramPerHourPerSquareMillimeter: return (_value/3.6e0) * 1e3d;
-                case MassFluxUnit.KilogramPerSecondPerSquareCentimeter: return (_value/1e-1) * 1e3d;
-                case MassFluxUnit.KilogramPerSecondPerSquareMeter: return (_value/1e3) * 1e3d;
-                case MassFluxUnit.KilogramPerSecondPerSquareMillimeter: return (_value/1e-3) * 1e3d;
+                case MassFluxUnit.GramPerHourPerSquareCentimeter: return Value/3.6e2;
+                case MassFluxUnit.GramPerHourPerSquareMeter: return Value/3.6e6;
+                case MassFluxUnit.GramPerHourPerSquareMillimeter: return Value/3.6e0;
+                case MassFluxUnit.GramPerSecondPerSquareCentimeter: return Value/1e-1;
+                case MassFluxUnit.GramPerSecondPerSquareMeter: return Value/1e3;
+                case MassFluxUnit.GramPerSecondPerSquareMillimeter: return Value/1e-3;
+                case MassFluxUnit.KilogramPerHourPerSquareCentimeter: return (Value/3.6e2) * 1e3d;
+                case MassFluxUnit.KilogramPerHourPerSquareMeter: return (Value/3.6e6) * 1e3d;
+                case MassFluxUnit.KilogramPerHourPerSquareMillimeter: return (Value/3.6e0) * 1e3d;
+                case MassFluxUnit.KilogramPerSecondPerSquareCentimeter: return (Value/1e-1) * 1e3d;
+                case MassFluxUnit.KilogramPerSecondPerSquareMeter: return (Value/1e3) * 1e3d;
+                case MassFluxUnit.KilogramPerSecondPerSquareMillimeter: return (Value/1e-3) * 1e3d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -825,16 +825,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MassFlux ToBaseUnit()
+        internal MassFlux<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MassFlux(baseUnitValue, BaseUnit);
+            return new MassFlux<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MassFluxUnit unit)
+        private T GetValueAs(MassFluxUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -948,57 +948,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFlux)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFlux<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFlux)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFlux<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFlux)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFlux<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1008,33 +1008,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MassFlux))
+            if(conversionType == typeof(MassFlux<T>))
                 return this;
             else if(conversionType == typeof(MassFluxUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MassFlux.QuantityType;
+                return MassFlux<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MassFlux.Info;
+                return MassFlux<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MassFlux.BaseDimensions;
+                return MassFlux<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MassFlux)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MassFlux<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
index 7ff1a97651..6043a2ce57 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Mass_fraction_(chemistry)
     /// </remarks>
-    public partial struct MassFraction : IQuantity<MassFractionUnit>, IEquatable<MassFraction>, IComparable, IComparable<MassFraction>, IConvertible, IFormattable
+    public partial struct MassFraction<T> : IQuantityT<MassFractionUnit, T>, IEquatable<MassFraction<T>>, IComparable, IComparable<MassFraction<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -89,12 +85,12 @@ static MassFraction()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MassFraction(double value, MassFractionUnit unit)
+        public MassFraction(T value, MassFractionUnit unit)
         {
             if(unit == MassFractionUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -106,14 +102,14 @@ public MassFraction(double value, MassFractionUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassFraction(double value, UnitSystem unitSystem)
+        public MassFraction(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -128,19 +124,19 @@ public MassFraction(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MassFraction, which is DecimalFraction. All conversions go via this value.
+        ///     The base unit of <see cref="MassFraction{T}" />, which is DecimalFraction. All conversions go via this value.
         /// </summary>
         public static MassFractionUnit BaseUnit { get; } = MassFractionUnit.DecimalFraction;
 
         /// <summary>
-        /// Represents the largest possible value of MassFraction
+        /// Represents the largest possible value of <see cref="MassFraction{T}" />
         /// </summary>
-        public static MassFraction MaxValue { get; } = new MassFraction(double.MaxValue, BaseUnit);
+        public static MassFraction<T> MaxValue { get; } = new MassFraction<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MassFraction
+        /// Represents the smallest possible value of <see cref="MassFraction{T}" />
         /// </summary>
-        public static MassFraction MinValue { get; } = new MassFraction(double.MinValue, BaseUnit);
+        public static MassFraction<T> MinValue { get; } = new MassFraction<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -149,14 +145,14 @@ public MassFraction(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MassFraction;
 
         /// <summary>
-        ///     All units of measurement for the MassFraction quantity.
+        ///     All units of measurement for the <see cref="MassFraction{T}" /> quantity.
         /// </summary>
         public static MassFractionUnit[] Units { get; } = Enum.GetValues(typeof(MassFractionUnit)).Cast<MassFractionUnit>().Except(new MassFractionUnit[]{ MassFractionUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DecimalFraction.
         /// </summary>
-        public static MassFraction Zero { get; } = new MassFraction(0, BaseUnit);
+        public static MassFraction<T> Zero { get; } = new MassFraction<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -165,7 +161,9 @@ public MassFraction(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -181,136 +179,136 @@ public MassFraction(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MassFraction.QuantityType;
+        public QuantityType Type => MassFraction<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MassFraction.BaseDimensions;
+        public BaseDimensions Dimensions => MassFraction<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MassFraction in CentigramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in CentigramsPerGram.
         /// </summary>
-        public double CentigramsPerGram => As(MassFractionUnit.CentigramPerGram);
+        public T CentigramsPerGram => As(MassFractionUnit.CentigramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in CentigramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in CentigramsPerKilogram.
         /// </summary>
-        public double CentigramsPerKilogram => As(MassFractionUnit.CentigramPerKilogram);
+        public T CentigramsPerKilogram => As(MassFractionUnit.CentigramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in DecagramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in DecagramsPerGram.
         /// </summary>
-        public double DecagramsPerGram => As(MassFractionUnit.DecagramPerGram);
+        public T DecagramsPerGram => As(MassFractionUnit.DecagramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in DecagramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in DecagramsPerKilogram.
         /// </summary>
-        public double DecagramsPerKilogram => As(MassFractionUnit.DecagramPerKilogram);
+        public T DecagramsPerKilogram => As(MassFractionUnit.DecagramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in DecigramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in DecigramsPerGram.
         /// </summary>
-        public double DecigramsPerGram => As(MassFractionUnit.DecigramPerGram);
+        public T DecigramsPerGram => As(MassFractionUnit.DecigramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in DecigramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in DecigramsPerKilogram.
         /// </summary>
-        public double DecigramsPerKilogram => As(MassFractionUnit.DecigramPerKilogram);
+        public T DecigramsPerKilogram => As(MassFractionUnit.DecigramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in DecimalFractions.
+        ///     Get <see cref="MassFraction{T}" /> in DecimalFractions.
         /// </summary>
-        public double DecimalFractions => As(MassFractionUnit.DecimalFraction);
+        public T DecimalFractions => As(MassFractionUnit.DecimalFraction);
 
         /// <summary>
-        ///     Get MassFraction in GramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in GramsPerGram.
         /// </summary>
-        public double GramsPerGram => As(MassFractionUnit.GramPerGram);
+        public T GramsPerGram => As(MassFractionUnit.GramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in GramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in GramsPerKilogram.
         /// </summary>
-        public double GramsPerKilogram => As(MassFractionUnit.GramPerKilogram);
+        public T GramsPerKilogram => As(MassFractionUnit.GramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in HectogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in HectogramsPerGram.
         /// </summary>
-        public double HectogramsPerGram => As(MassFractionUnit.HectogramPerGram);
+        public T HectogramsPerGram => As(MassFractionUnit.HectogramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in HectogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in HectogramsPerKilogram.
         /// </summary>
-        public double HectogramsPerKilogram => As(MassFractionUnit.HectogramPerKilogram);
+        public T HectogramsPerKilogram => As(MassFractionUnit.HectogramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in KilogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in KilogramsPerGram.
         /// </summary>
-        public double KilogramsPerGram => As(MassFractionUnit.KilogramPerGram);
+        public T KilogramsPerGram => As(MassFractionUnit.KilogramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in KilogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in KilogramsPerKilogram.
         /// </summary>
-        public double KilogramsPerKilogram => As(MassFractionUnit.KilogramPerKilogram);
+        public T KilogramsPerKilogram => As(MassFractionUnit.KilogramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in MicrogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in MicrogramsPerGram.
         /// </summary>
-        public double MicrogramsPerGram => As(MassFractionUnit.MicrogramPerGram);
+        public T MicrogramsPerGram => As(MassFractionUnit.MicrogramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in MicrogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in MicrogramsPerKilogram.
         /// </summary>
-        public double MicrogramsPerKilogram => As(MassFractionUnit.MicrogramPerKilogram);
+        public T MicrogramsPerKilogram => As(MassFractionUnit.MicrogramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in MilligramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in MilligramsPerGram.
         /// </summary>
-        public double MilligramsPerGram => As(MassFractionUnit.MilligramPerGram);
+        public T MilligramsPerGram => As(MassFractionUnit.MilligramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in MilligramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in MilligramsPerKilogram.
         /// </summary>
-        public double MilligramsPerKilogram => As(MassFractionUnit.MilligramPerKilogram);
+        public T MilligramsPerKilogram => As(MassFractionUnit.MilligramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in NanogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> in NanogramsPerGram.
         /// </summary>
-        public double NanogramsPerGram => As(MassFractionUnit.NanogramPerGram);
+        public T NanogramsPerGram => As(MassFractionUnit.NanogramPerGram);
 
         /// <summary>
-        ///     Get MassFraction in NanogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> in NanogramsPerKilogram.
         /// </summary>
-        public double NanogramsPerKilogram => As(MassFractionUnit.NanogramPerKilogram);
+        public T NanogramsPerKilogram => As(MassFractionUnit.NanogramPerKilogram);
 
         /// <summary>
-        ///     Get MassFraction in PartsPerBillion.
+        ///     Get <see cref="MassFraction{T}" /> in PartsPerBillion.
         /// </summary>
-        public double PartsPerBillion => As(MassFractionUnit.PartPerBillion);
+        public T PartsPerBillion => As(MassFractionUnit.PartPerBillion);
 
         /// <summary>
-        ///     Get MassFraction in PartsPerMillion.
+        ///     Get <see cref="MassFraction{T}" /> in PartsPerMillion.
         /// </summary>
-        public double PartsPerMillion => As(MassFractionUnit.PartPerMillion);
+        public T PartsPerMillion => As(MassFractionUnit.PartPerMillion);
 
         /// <summary>
-        ///     Get MassFraction in PartsPerThousand.
+        ///     Get <see cref="MassFraction{T}" /> in PartsPerThousand.
         /// </summary>
-        public double PartsPerThousand => As(MassFractionUnit.PartPerThousand);
+        public T PartsPerThousand => As(MassFractionUnit.PartPerThousand);
 
         /// <summary>
-        ///     Get MassFraction in PartsPerTrillion.
+        ///     Get <see cref="MassFraction{T}" /> in PartsPerTrillion.
         /// </summary>
-        public double PartsPerTrillion => As(MassFractionUnit.PartPerTrillion);
+        public T PartsPerTrillion => As(MassFractionUnit.PartPerTrillion);
 
         /// <summary>
-        ///     Get MassFraction in Percent.
+        ///     Get <see cref="MassFraction{T}" /> in Percent.
         /// </summary>
-        public double Percent => As(MassFractionUnit.Percent);
+        public T Percent => As(MassFractionUnit.Percent);
 
         #endregion
 
@@ -342,231 +340,207 @@ public static string GetAbbreviation(MassFractionUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MassFraction from CentigramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from CentigramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromCentigramsPerGram(QuantityValue centigramspergram)
+        public static MassFraction<T> FromCentigramsPerGram(T centigramspergram)
         {
-            double value = (double) centigramspergram;
-            return new MassFraction(value, MassFractionUnit.CentigramPerGram);
+            return new MassFraction<T>(centigramspergram, MassFractionUnit.CentigramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from CentigramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from CentigramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromCentigramsPerKilogram(QuantityValue centigramsperkilogram)
+        public static MassFraction<T> FromCentigramsPerKilogram(T centigramsperkilogram)
         {
-            double value = (double) centigramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.CentigramPerKilogram);
+            return new MassFraction<T>(centigramsperkilogram, MassFractionUnit.CentigramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from DecagramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from DecagramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecagramsPerGram(QuantityValue decagramspergram)
+        public static MassFraction<T> FromDecagramsPerGram(T decagramspergram)
         {
-            double value = (double) decagramspergram;
-            return new MassFraction(value, MassFractionUnit.DecagramPerGram);
+            return new MassFraction<T>(decagramspergram, MassFractionUnit.DecagramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from DecagramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from DecagramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecagramsPerKilogram(QuantityValue decagramsperkilogram)
+        public static MassFraction<T> FromDecagramsPerKilogram(T decagramsperkilogram)
         {
-            double value = (double) decagramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.DecagramPerKilogram);
+            return new MassFraction<T>(decagramsperkilogram, MassFractionUnit.DecagramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from DecigramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from DecigramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecigramsPerGram(QuantityValue decigramspergram)
+        public static MassFraction<T> FromDecigramsPerGram(T decigramspergram)
         {
-            double value = (double) decigramspergram;
-            return new MassFraction(value, MassFractionUnit.DecigramPerGram);
+            return new MassFraction<T>(decigramspergram, MassFractionUnit.DecigramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from DecigramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from DecigramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecigramsPerKilogram(QuantityValue decigramsperkilogram)
+        public static MassFraction<T> FromDecigramsPerKilogram(T decigramsperkilogram)
         {
-            double value = (double) decigramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.DecigramPerKilogram);
+            return new MassFraction<T>(decigramsperkilogram, MassFractionUnit.DecigramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from DecimalFractions.
+        ///     Get <see cref="MassFraction{T}" /> from DecimalFractions.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecimalFractions(QuantityValue decimalfractions)
+        public static MassFraction<T> FromDecimalFractions(T decimalfractions)
         {
-            double value = (double) decimalfractions;
-            return new MassFraction(value, MassFractionUnit.DecimalFraction);
+            return new MassFraction<T>(decimalfractions, MassFractionUnit.DecimalFraction);
         }
         /// <summary>
-        ///     Get MassFraction from GramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from GramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromGramsPerGram(QuantityValue gramspergram)
+        public static MassFraction<T> FromGramsPerGram(T gramspergram)
         {
-            double value = (double) gramspergram;
-            return new MassFraction(value, MassFractionUnit.GramPerGram);
+            return new MassFraction<T>(gramspergram, MassFractionUnit.GramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from GramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from GramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromGramsPerKilogram(QuantityValue gramsperkilogram)
+        public static MassFraction<T> FromGramsPerKilogram(T gramsperkilogram)
         {
-            double value = (double) gramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.GramPerKilogram);
+            return new MassFraction<T>(gramsperkilogram, MassFractionUnit.GramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from HectogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from HectogramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromHectogramsPerGram(QuantityValue hectogramspergram)
+        public static MassFraction<T> FromHectogramsPerGram(T hectogramspergram)
         {
-            double value = (double) hectogramspergram;
-            return new MassFraction(value, MassFractionUnit.HectogramPerGram);
+            return new MassFraction<T>(hectogramspergram, MassFractionUnit.HectogramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from HectogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from HectogramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromHectogramsPerKilogram(QuantityValue hectogramsperkilogram)
+        public static MassFraction<T> FromHectogramsPerKilogram(T hectogramsperkilogram)
         {
-            double value = (double) hectogramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.HectogramPerKilogram);
+            return new MassFraction<T>(hectogramsperkilogram, MassFractionUnit.HectogramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from KilogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from KilogramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromKilogramsPerGram(QuantityValue kilogramspergram)
+        public static MassFraction<T> FromKilogramsPerGram(T kilogramspergram)
         {
-            double value = (double) kilogramspergram;
-            return new MassFraction(value, MassFractionUnit.KilogramPerGram);
+            return new MassFraction<T>(kilogramspergram, MassFractionUnit.KilogramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from KilogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from KilogramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromKilogramsPerKilogram(QuantityValue kilogramsperkilogram)
+        public static MassFraction<T> FromKilogramsPerKilogram(T kilogramsperkilogram)
         {
-            double value = (double) kilogramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.KilogramPerKilogram);
+            return new MassFraction<T>(kilogramsperkilogram, MassFractionUnit.KilogramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from MicrogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from MicrogramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMicrogramsPerGram(QuantityValue microgramspergram)
+        public static MassFraction<T> FromMicrogramsPerGram(T microgramspergram)
         {
-            double value = (double) microgramspergram;
-            return new MassFraction(value, MassFractionUnit.MicrogramPerGram);
+            return new MassFraction<T>(microgramspergram, MassFractionUnit.MicrogramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from MicrogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from MicrogramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMicrogramsPerKilogram(QuantityValue microgramsperkilogram)
+        public static MassFraction<T> FromMicrogramsPerKilogram(T microgramsperkilogram)
         {
-            double value = (double) microgramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram);
+            return new MassFraction<T>(microgramsperkilogram, MassFractionUnit.MicrogramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from MilligramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from MilligramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMilligramsPerGram(QuantityValue milligramspergram)
+        public static MassFraction<T> FromMilligramsPerGram(T milligramspergram)
         {
-            double value = (double) milligramspergram;
-            return new MassFraction(value, MassFractionUnit.MilligramPerGram);
+            return new MassFraction<T>(milligramspergram, MassFractionUnit.MilligramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from MilligramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from MilligramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMilligramsPerKilogram(QuantityValue milligramsperkilogram)
+        public static MassFraction<T> FromMilligramsPerKilogram(T milligramsperkilogram)
         {
-            double value = (double) milligramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.MilligramPerKilogram);
+            return new MassFraction<T>(milligramsperkilogram, MassFractionUnit.MilligramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from NanogramsPerGram.
+        ///     Get <see cref="MassFraction{T}" /> from NanogramsPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromNanogramsPerGram(QuantityValue nanogramspergram)
+        public static MassFraction<T> FromNanogramsPerGram(T nanogramspergram)
         {
-            double value = (double) nanogramspergram;
-            return new MassFraction(value, MassFractionUnit.NanogramPerGram);
+            return new MassFraction<T>(nanogramspergram, MassFractionUnit.NanogramPerGram);
         }
         /// <summary>
-        ///     Get MassFraction from NanogramsPerKilogram.
+        ///     Get <see cref="MassFraction{T}" /> from NanogramsPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromNanogramsPerKilogram(QuantityValue nanogramsperkilogram)
+        public static MassFraction<T> FromNanogramsPerKilogram(T nanogramsperkilogram)
         {
-            double value = (double) nanogramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.NanogramPerKilogram);
+            return new MassFraction<T>(nanogramsperkilogram, MassFractionUnit.NanogramPerKilogram);
         }
         /// <summary>
-        ///     Get MassFraction from PartsPerBillion.
+        ///     Get <see cref="MassFraction{T}" /> from PartsPerBillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerBillion(QuantityValue partsperbillion)
+        public static MassFraction<T> FromPartsPerBillion(T partsperbillion)
         {
-            double value = (double) partsperbillion;
-            return new MassFraction(value, MassFractionUnit.PartPerBillion);
+            return new MassFraction<T>(partsperbillion, MassFractionUnit.PartPerBillion);
         }
         /// <summary>
-        ///     Get MassFraction from PartsPerMillion.
+        ///     Get <see cref="MassFraction{T}" /> from PartsPerMillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerMillion(QuantityValue partspermillion)
+        public static MassFraction<T> FromPartsPerMillion(T partspermillion)
         {
-            double value = (double) partspermillion;
-            return new MassFraction(value, MassFractionUnit.PartPerMillion);
+            return new MassFraction<T>(partspermillion, MassFractionUnit.PartPerMillion);
         }
         /// <summary>
-        ///     Get MassFraction from PartsPerThousand.
+        ///     Get <see cref="MassFraction{T}" /> from PartsPerThousand.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerThousand(QuantityValue partsperthousand)
+        public static MassFraction<T> FromPartsPerThousand(T partsperthousand)
         {
-            double value = (double) partsperthousand;
-            return new MassFraction(value, MassFractionUnit.PartPerThousand);
+            return new MassFraction<T>(partsperthousand, MassFractionUnit.PartPerThousand);
         }
         /// <summary>
-        ///     Get MassFraction from PartsPerTrillion.
+        ///     Get <see cref="MassFraction{T}" /> from PartsPerTrillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerTrillion(QuantityValue partspertrillion)
+        public static MassFraction<T> FromPartsPerTrillion(T partspertrillion)
         {
-            double value = (double) partspertrillion;
-            return new MassFraction(value, MassFractionUnit.PartPerTrillion);
+            return new MassFraction<T>(partspertrillion, MassFractionUnit.PartPerTrillion);
         }
         /// <summary>
-        ///     Get MassFraction from Percent.
+        ///     Get <see cref="MassFraction{T}" /> from Percent.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPercent(QuantityValue percent)
+        public static MassFraction<T> FromPercent(T percent)
         {
-            double value = (double) percent;
-            return new MassFraction(value, MassFractionUnit.Percent);
+            return new MassFraction<T>(percent, MassFractionUnit.Percent);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassFractionUnit" /> to <see cref="MassFraction" />.
+        ///     Dynamically convert from value and unit enum <see cref="MassFractionUnit" /> to <see cref="MassFraction{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassFraction unit value.</returns>
-        public static MassFraction From(QuantityValue value, MassFractionUnit fromUnit)
+        /// <returns><see cref="MassFraction{T}" /> unit value.</returns>
+        public static MassFraction<T> From(T value, MassFractionUnit fromUnit)
         {
-            return new MassFraction((double)value, fromUnit);
+            return new MassFraction<T>(value, fromUnit);
         }
 
         #endregion
@@ -595,7 +569,7 @@ public static MassFraction From(QuantityValue value, MassFractionUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MassFraction Parse(string str)
+        public static MassFraction<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -623,9 +597,9 @@ public static MassFraction Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MassFraction Parse(string str, IFormatProvider? provider)
+        public static MassFraction<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MassFraction, MassFractionUnit>(
+            return QuantityParser.Default.Parse<T, MassFraction<T>, MassFractionUnit>(
                 str,
                 provider,
                 From);
@@ -639,7 +613,7 @@ public static MassFraction Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MassFraction result)
+        public static bool TryParse(string? str, out MassFraction<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -654,9 +628,9 @@ public static bool TryParse(string? str, out MassFraction result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MassFraction result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MassFraction<T> result)
         {
-            return QuantityParser.Default.TryParse<MassFraction, MassFractionUnit>(
+            return QuantityParser.Default.TryParse<T, MassFraction<T>, MassFractionUnit>(
                 str,
                 provider,
                 From,
@@ -718,45 +692,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MassFraction operator -(MassFraction right)
+        public static MassFraction<T> operator -(MassFraction<T> right)
         {
-            return new MassFraction(-right.Value, right.Unit);
+            return new MassFraction<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MassFraction"/> from adding two <see cref="MassFraction"/>.</summary>
-        public static MassFraction operator +(MassFraction left, MassFraction right)
+        /// <summary>Get <see cref="MassFraction{T}"/> from adding two <see cref="MassFraction{T}"/>.</summary>
+        public static MassFraction<T> operator +(MassFraction<T> left, MassFraction<T> right)
         {
-            return new MassFraction(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MassFraction<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFraction"/> from subtracting two <see cref="MassFraction"/>.</summary>
-        public static MassFraction operator -(MassFraction left, MassFraction right)
+        /// <summary>Get <see cref="MassFraction{T}"/> from subtracting two <see cref="MassFraction{T}"/>.</summary>
+        public static MassFraction<T> operator -(MassFraction<T> left, MassFraction<T> right)
         {
-            return new MassFraction(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MassFraction<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFraction"/> from multiplying value and <see cref="MassFraction"/>.</summary>
-        public static MassFraction operator *(double left, MassFraction right)
+        /// <summary>Get <see cref="MassFraction{T}"/> from multiplying value and <see cref="MassFraction{T}"/>.</summary>
+        public static MassFraction<T> operator *(T left, MassFraction<T> right)
         {
-            return new MassFraction(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MassFraction<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MassFraction"/> from multiplying value and <see cref="MassFraction"/>.</summary>
-        public static MassFraction operator *(MassFraction left, double right)
+        /// <summary>Get <see cref="MassFraction{T}"/> from multiplying value and <see cref="MassFraction{T}"/>.</summary>
+        public static MassFraction<T> operator *(MassFraction<T> left, T right)
         {
-            return new MassFraction(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MassFraction<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassFraction"/> from dividing <see cref="MassFraction"/> by value.</summary>
-        public static MassFraction operator /(MassFraction left, double right)
+        /// <summary>Get <see cref="MassFraction{T}"/> from dividing <see cref="MassFraction{T}"/> by value.</summary>
+        public static MassFraction<T> operator /(MassFraction<T> left, T right)
         {
-            return new MassFraction(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MassFraction<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MassFraction"/> by <see cref="MassFraction"/>.</summary>
-        public static double operator /(MassFraction left, MassFraction right)
+        /// <summary>Get ratio value from dividing <see cref="MassFraction{T}"/> by <see cref="MassFraction{T}"/>.</summary>
+        public static T operator /(MassFraction<T> left, MassFraction<T> right)
         {
-            return left.DecimalFractions / right.DecimalFractions;
+            return CompiledLambdas.Divide(left.DecimalFractions, right.DecimalFractions);
         }
 
         #endregion
@@ -764,39 +743,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MassFraction left, MassFraction right)
+        public static bool operator <=(MassFraction<T> left, MassFraction<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MassFraction left, MassFraction right)
+        public static bool operator >=(MassFraction<T> left, MassFraction<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MassFraction left, MassFraction right)
+        public static bool operator <(MassFraction<T> left, MassFraction<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MassFraction left, MassFraction right)
+        public static bool operator >(MassFraction<T> left, MassFraction<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassFraction, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MassFraction left, MassFraction right)
+        /// <remarks>Consider using <see cref="Equals(MassFraction{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MassFraction<T> left, MassFraction<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassFraction, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MassFraction left, MassFraction right)
+        /// <remarks>Consider using <see cref="Equals(MassFraction{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MassFraction<T> left, MassFraction<T> right)
         {
             return !(left == right);
         }
@@ -805,37 +784,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassF
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MassFraction objMassFraction)) throw new ArgumentException("Expected type MassFraction.", nameof(obj));
+            if(!(obj is MassFraction<T> objMassFraction)) throw new ArgumentException("Expected type MassFraction.", nameof(obj));
 
             return CompareTo(objMassFraction);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MassFraction other)
+        public int CompareTo(MassFraction<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassFraction, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MassFraction{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MassFraction objMassFraction))
+            if(obj is null || !(obj is MassFraction<T> objMassFraction))
                 return false;
 
             return Equals(objMassFraction);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassFraction, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MassFraction other)
+        /// <remarks>Consider using <see cref="Equals(MassFraction{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MassFraction<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MassFraction within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MassFraction{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -873,21 +852,19 @@ public bool Equals(MassFraction other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MassFraction other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MassFraction<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MassFraction.</returns>
+        /// <returns>A hash code for the current <see cref="MassFraction{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -901,17 +878,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassFractionUnit unit)
+        public T As(MassFractionUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -931,17 +908,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MassFractionUnit unitAsMassFractionUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFractionUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMassFractionUnit);
+            var asValue = As(unitAsMassFractionUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MassFractionUnit>.As(MassFractionUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MassFraction to another MassFraction with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MassFraction{T}" /> to another <see cref="MassFraction{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MassFraction with the specified unit.</returns>
-        public MassFraction ToUnit(MassFractionUnit unit)
+        /// <returns>A <see cref="MassFraction{T}" /> with the specified unit.</returns>
+        public MassFraction<T> ToUnit(MassFractionUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MassFraction(convertedValue, unit);
+            return new MassFraction<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -954,7 +936,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MassFraction ToUnit(UnitSystem unitSystem)
+        public MassFraction<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -974,42 +956,48 @@ public MassFraction ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassFractionUnit> IQuantity<MassFractionUnit>.ToUnit(MassFractionUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MassFractionUnit, T> IQuantityT<MassFractionUnit, T>.ToUnit(MassFractionUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MassFractionUnit> IQuantity<MassFractionUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MassFractionUnit, T> IQuantityT<MassFractionUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MassFractionUnit.CentigramPerGram: return (_value) * 1e-2d;
-                case MassFractionUnit.CentigramPerKilogram: return (_value/1e3) * 1e-2d;
-                case MassFractionUnit.DecagramPerGram: return (_value) * 1e1d;
-                case MassFractionUnit.DecagramPerKilogram: return (_value/1e3) * 1e1d;
-                case MassFractionUnit.DecigramPerGram: return (_value) * 1e-1d;
-                case MassFractionUnit.DecigramPerKilogram: return (_value/1e3) * 1e-1d;
-                case MassFractionUnit.DecimalFraction: return _value;
-                case MassFractionUnit.GramPerGram: return _value;
-                case MassFractionUnit.GramPerKilogram: return _value/1e3;
-                case MassFractionUnit.HectogramPerGram: return (_value) * 1e2d;
-                case MassFractionUnit.HectogramPerKilogram: return (_value/1e3) * 1e2d;
-                case MassFractionUnit.KilogramPerGram: return (_value) * 1e3d;
-                case MassFractionUnit.KilogramPerKilogram: return (_value/1e3) * 1e3d;
-                case MassFractionUnit.MicrogramPerGram: return (_value) * 1e-6d;
-                case MassFractionUnit.MicrogramPerKilogram: return (_value/1e3) * 1e-6d;
-                case MassFractionUnit.MilligramPerGram: return (_value) * 1e-3d;
-                case MassFractionUnit.MilligramPerKilogram: return (_value/1e3) * 1e-3d;
-                case MassFractionUnit.NanogramPerGram: return (_value) * 1e-9d;
-                case MassFractionUnit.NanogramPerKilogram: return (_value/1e3) * 1e-9d;
-                case MassFractionUnit.PartPerBillion: return _value/1e9;
-                case MassFractionUnit.PartPerMillion: return _value/1e6;
-                case MassFractionUnit.PartPerThousand: return _value/1e3;
-                case MassFractionUnit.PartPerTrillion: return _value/1e12;
-                case MassFractionUnit.Percent: return _value/1e2;
+                case MassFractionUnit.CentigramPerGram: return (Value) * 1e-2d;
+                case MassFractionUnit.CentigramPerKilogram: return (Value/1e3) * 1e-2d;
+                case MassFractionUnit.DecagramPerGram: return (Value) * 1e1d;
+                case MassFractionUnit.DecagramPerKilogram: return (Value/1e3) * 1e1d;
+                case MassFractionUnit.DecigramPerGram: return (Value) * 1e-1d;
+                case MassFractionUnit.DecigramPerKilogram: return (Value/1e3) * 1e-1d;
+                case MassFractionUnit.DecimalFraction: return Value;
+                case MassFractionUnit.GramPerGram: return Value;
+                case MassFractionUnit.GramPerKilogram: return Value/1e3;
+                case MassFractionUnit.HectogramPerGram: return (Value) * 1e2d;
+                case MassFractionUnit.HectogramPerKilogram: return (Value/1e3) * 1e2d;
+                case MassFractionUnit.KilogramPerGram: return (Value) * 1e3d;
+                case MassFractionUnit.KilogramPerKilogram: return (Value/1e3) * 1e3d;
+                case MassFractionUnit.MicrogramPerGram: return (Value) * 1e-6d;
+                case MassFractionUnit.MicrogramPerKilogram: return (Value/1e3) * 1e-6d;
+                case MassFractionUnit.MilligramPerGram: return (Value) * 1e-3d;
+                case MassFractionUnit.MilligramPerKilogram: return (Value/1e3) * 1e-3d;
+                case MassFractionUnit.NanogramPerGram: return (Value) * 1e-9d;
+                case MassFractionUnit.NanogramPerKilogram: return (Value/1e3) * 1e-9d;
+                case MassFractionUnit.PartPerBillion: return Value/1e9;
+                case MassFractionUnit.PartPerMillion: return Value/1e6;
+                case MassFractionUnit.PartPerThousand: return Value/1e3;
+                case MassFractionUnit.PartPerTrillion: return Value/1e12;
+                case MassFractionUnit.Percent: return Value/1e2;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1020,16 +1008,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MassFraction ToBaseUnit()
+        internal MassFraction<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MassFraction(baseUnitValue, BaseUnit);
+            return new MassFraction<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MassFractionUnit unit)
+        private T GetValueAs(MassFractionUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1155,57 +1143,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFraction)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFraction<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFraction)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFraction<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassFraction)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassFraction<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1215,33 +1203,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MassFraction))
+            if(conversionType == typeof(MassFraction<T>))
                 return this;
             else if(conversionType == typeof(MassFractionUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MassFraction.QuantityType;
+                return MassFraction<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MassFraction.Info;
+                return MassFraction<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MassFraction.BaseDimensions;
+                return MassFraction<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MassFraction)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MassFraction<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
index 39483d0c8d..d9dfe22358 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     A property of body reflects how its mass is distributed with regard to an axis.
     /// </summary>
-    public partial struct MassMomentOfInertia : IQuantity<MassMomentOfInertiaUnit>, IEquatable<MassMomentOfInertia>, IComparable, IComparable<MassMomentOfInertia>, IConvertible, IFormattable
+    public partial struct MassMomentOfInertia<T> : IQuantityT<MassMomentOfInertiaUnit, T>, IEquatable<MassMomentOfInertia<T>>, IComparable, IComparable<MassMomentOfInertia<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -90,12 +86,12 @@ static MassMomentOfInertia()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MassMomentOfInertia(double value, MassMomentOfInertiaUnit unit)
+        public MassMomentOfInertia(T value, MassMomentOfInertiaUnit unit)
         {
             if(unit == MassMomentOfInertiaUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -107,14 +103,14 @@ public MassMomentOfInertia(double value, MassMomentOfInertiaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassMomentOfInertia(double value, UnitSystem unitSystem)
+        public MassMomentOfInertia(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -129,19 +125,19 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MassMomentOfInertia, which is KilogramSquareMeter. All conversions go via this value.
+        ///     The base unit of <see cref="MassMomentOfInertia{T}" />, which is KilogramSquareMeter. All conversions go via this value.
         /// </summary>
         public static MassMomentOfInertiaUnit BaseUnit { get; } = MassMomentOfInertiaUnit.KilogramSquareMeter;
 
         /// <summary>
-        /// Represents the largest possible value of MassMomentOfInertia
+        /// Represents the largest possible value of <see cref="MassMomentOfInertia{T}" />
         /// </summary>
-        public static MassMomentOfInertia MaxValue { get; } = new MassMomentOfInertia(double.MaxValue, BaseUnit);
+        public static MassMomentOfInertia<T> MaxValue { get; } = new MassMomentOfInertia<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MassMomentOfInertia
+        /// Represents the smallest possible value of <see cref="MassMomentOfInertia{T}" />
         /// </summary>
-        public static MassMomentOfInertia MinValue { get; } = new MassMomentOfInertia(double.MinValue, BaseUnit);
+        public static MassMomentOfInertia<T> MinValue { get; } = new MassMomentOfInertia<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -150,14 +146,14 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MassMomentOfInertia;
 
         /// <summary>
-        ///     All units of measurement for the MassMomentOfInertia quantity.
+        ///     All units of measurement for the <see cref="MassMomentOfInertia{T}" /> quantity.
         /// </summary>
         public static MassMomentOfInertiaUnit[] Units { get; } = Enum.GetValues(typeof(MassMomentOfInertiaUnit)).Cast<MassMomentOfInertiaUnit>().Except(new MassMomentOfInertiaUnit[]{ MassMomentOfInertiaUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramSquareMeter.
         /// </summary>
-        public static MassMomentOfInertia Zero { get; } = new MassMomentOfInertia(0, BaseUnit);
+        public static MassMomentOfInertia<T> Zero { get; } = new MassMomentOfInertia<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -166,7 +162,9 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -182,156 +180,156 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MassMomentOfInertia.QuantityType;
+        public QuantityType Type => MassMomentOfInertia<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MassMomentOfInertia.BaseDimensions;
+        public BaseDimensions Dimensions => MassMomentOfInertia<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MassMomentOfInertia in GramSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in GramSquareCentimeters.
         /// </summary>
-        public double GramSquareCentimeters => As(MassMomentOfInertiaUnit.GramSquareCentimeter);
+        public T GramSquareCentimeters => As(MassMomentOfInertiaUnit.GramSquareCentimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in GramSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in GramSquareDecimeters.
         /// </summary>
-        public double GramSquareDecimeters => As(MassMomentOfInertiaUnit.GramSquareDecimeter);
+        public T GramSquareDecimeters => As(MassMomentOfInertiaUnit.GramSquareDecimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in GramSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in GramSquareMeters.
         /// </summary>
-        public double GramSquareMeters => As(MassMomentOfInertiaUnit.GramSquareMeter);
+        public T GramSquareMeters => As(MassMomentOfInertiaUnit.GramSquareMeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in GramSquareMillimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in GramSquareMillimeters.
         /// </summary>
-        public double GramSquareMillimeters => As(MassMomentOfInertiaUnit.GramSquareMillimeter);
+        public T GramSquareMillimeters => As(MassMomentOfInertiaUnit.GramSquareMillimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilogramSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilogramSquareCentimeters.
         /// </summary>
-        public double KilogramSquareCentimeters => As(MassMomentOfInertiaUnit.KilogramSquareCentimeter);
+        public T KilogramSquareCentimeters => As(MassMomentOfInertiaUnit.KilogramSquareCentimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilogramSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilogramSquareDecimeters.
         /// </summary>
-        public double KilogramSquareDecimeters => As(MassMomentOfInertiaUnit.KilogramSquareDecimeter);
+        public T KilogramSquareDecimeters => As(MassMomentOfInertiaUnit.KilogramSquareDecimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilogramSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilogramSquareMeters.
         /// </summary>
-        public double KilogramSquareMeters => As(MassMomentOfInertiaUnit.KilogramSquareMeter);
+        public T KilogramSquareMeters => As(MassMomentOfInertiaUnit.KilogramSquareMeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilogramSquareMillimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilogramSquareMillimeters.
         /// </summary>
-        public double KilogramSquareMillimeters => As(MassMomentOfInertiaUnit.KilogramSquareMillimeter);
+        public T KilogramSquareMillimeters => As(MassMomentOfInertiaUnit.KilogramSquareMillimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilotonneSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilotonneSquareCentimeters.
         /// </summary>
-        public double KilotonneSquareCentimeters => As(MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
+        public T KilotonneSquareCentimeters => As(MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilotonneSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilotonneSquareDecimeters.
         /// </summary>
-        public double KilotonneSquareDecimeters => As(MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
+        public T KilotonneSquareDecimeters => As(MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilotonneSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilotonneSquareMeters.
         /// </summary>
-        public double KilotonneSquareMeters => As(MassMomentOfInertiaUnit.KilotonneSquareMeter);
+        public T KilotonneSquareMeters => As(MassMomentOfInertiaUnit.KilotonneSquareMeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in KilotonneSquareMilimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in KilotonneSquareMilimeters.
         /// </summary>
-        public double KilotonneSquareMilimeters => As(MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
+        public T KilotonneSquareMilimeters => As(MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MegatonneSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MegatonneSquareCentimeters.
         /// </summary>
-        public double MegatonneSquareCentimeters => As(MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
+        public T MegatonneSquareCentimeters => As(MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MegatonneSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MegatonneSquareDecimeters.
         /// </summary>
-        public double MegatonneSquareDecimeters => As(MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
+        public T MegatonneSquareDecimeters => As(MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MegatonneSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MegatonneSquareMeters.
         /// </summary>
-        public double MegatonneSquareMeters => As(MassMomentOfInertiaUnit.MegatonneSquareMeter);
+        public T MegatonneSquareMeters => As(MassMomentOfInertiaUnit.MegatonneSquareMeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MegatonneSquareMilimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MegatonneSquareMilimeters.
         /// </summary>
-        public double MegatonneSquareMilimeters => As(MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
+        public T MegatonneSquareMilimeters => As(MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MilligramSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MilligramSquareCentimeters.
         /// </summary>
-        public double MilligramSquareCentimeters => As(MassMomentOfInertiaUnit.MilligramSquareCentimeter);
+        public T MilligramSquareCentimeters => As(MassMomentOfInertiaUnit.MilligramSquareCentimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MilligramSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MilligramSquareDecimeters.
         /// </summary>
-        public double MilligramSquareDecimeters => As(MassMomentOfInertiaUnit.MilligramSquareDecimeter);
+        public T MilligramSquareDecimeters => As(MassMomentOfInertiaUnit.MilligramSquareDecimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MilligramSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MilligramSquareMeters.
         /// </summary>
-        public double MilligramSquareMeters => As(MassMomentOfInertiaUnit.MilligramSquareMeter);
+        public T MilligramSquareMeters => As(MassMomentOfInertiaUnit.MilligramSquareMeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in MilligramSquareMillimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in MilligramSquareMillimeters.
         /// </summary>
-        public double MilligramSquareMillimeters => As(MassMomentOfInertiaUnit.MilligramSquareMillimeter);
+        public T MilligramSquareMillimeters => As(MassMomentOfInertiaUnit.MilligramSquareMillimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in PoundSquareFeet.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in PoundSquareFeet.
         /// </summary>
-        public double PoundSquareFeet => As(MassMomentOfInertiaUnit.PoundSquareFoot);
+        public T PoundSquareFeet => As(MassMomentOfInertiaUnit.PoundSquareFoot);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in PoundSquareInches.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in PoundSquareInches.
         /// </summary>
-        public double PoundSquareInches => As(MassMomentOfInertiaUnit.PoundSquareInch);
+        public T PoundSquareInches => As(MassMomentOfInertiaUnit.PoundSquareInch);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in SlugSquareFeet.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in SlugSquareFeet.
         /// </summary>
-        public double SlugSquareFeet => As(MassMomentOfInertiaUnit.SlugSquareFoot);
+        public T SlugSquareFeet => As(MassMomentOfInertiaUnit.SlugSquareFoot);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in SlugSquareInches.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in SlugSquareInches.
         /// </summary>
-        public double SlugSquareInches => As(MassMomentOfInertiaUnit.SlugSquareInch);
+        public T SlugSquareInches => As(MassMomentOfInertiaUnit.SlugSquareInch);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in TonneSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in TonneSquareCentimeters.
         /// </summary>
-        public double TonneSquareCentimeters => As(MassMomentOfInertiaUnit.TonneSquareCentimeter);
+        public T TonneSquareCentimeters => As(MassMomentOfInertiaUnit.TonneSquareCentimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in TonneSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in TonneSquareDecimeters.
         /// </summary>
-        public double TonneSquareDecimeters => As(MassMomentOfInertiaUnit.TonneSquareDecimeter);
+        public T TonneSquareDecimeters => As(MassMomentOfInertiaUnit.TonneSquareDecimeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in TonneSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in TonneSquareMeters.
         /// </summary>
-        public double TonneSquareMeters => As(MassMomentOfInertiaUnit.TonneSquareMeter);
+        public T TonneSquareMeters => As(MassMomentOfInertiaUnit.TonneSquareMeter);
 
         /// <summary>
-        ///     Get MassMomentOfInertia in TonneSquareMilimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> in TonneSquareMilimeters.
         /// </summary>
-        public double TonneSquareMilimeters => As(MassMomentOfInertiaUnit.TonneSquareMilimeter);
+        public T TonneSquareMilimeters => As(MassMomentOfInertiaUnit.TonneSquareMilimeter);
 
         #endregion
 
@@ -363,267 +361,239 @@ public static string GetAbbreviation(MassMomentOfInertiaUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MassMomentOfInertia from GramSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from GramSquareCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareCentimeters(QuantityValue gramsquarecentimeters)
+        public static MassMomentOfInertia<T> FromGramSquareCentimeters(T gramsquarecentimeters)
         {
-            double value = (double) gramsquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter);
+            return new MassMomentOfInertia<T>(gramsquarecentimeters, MassMomentOfInertiaUnit.GramSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from GramSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from GramSquareDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareDecimeters(QuantityValue gramsquaredecimeters)
+        public static MassMomentOfInertia<T> FromGramSquareDecimeters(T gramsquaredecimeters)
         {
-            double value = (double) gramsquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter);
+            return new MassMomentOfInertia<T>(gramsquaredecimeters, MassMomentOfInertiaUnit.GramSquareDecimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from GramSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from GramSquareMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareMeters(QuantityValue gramsquaremeters)
+        public static MassMomentOfInertia<T> FromGramSquareMeters(T gramsquaremeters)
         {
-            double value = (double) gramsquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter);
+            return new MassMomentOfInertia<T>(gramsquaremeters, MassMomentOfInertiaUnit.GramSquareMeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from GramSquareMillimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from GramSquareMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareMillimeters(QuantityValue gramsquaremillimeters)
+        public static MassMomentOfInertia<T> FromGramSquareMillimeters(T gramsquaremillimeters)
         {
-            double value = (double) gramsquaremillimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter);
+            return new MassMomentOfInertia<T>(gramsquaremillimeters, MassMomentOfInertiaUnit.GramSquareMillimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilogramSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilogramSquareCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareCentimeters(QuantityValue kilogramsquarecentimeters)
+        public static MassMomentOfInertia<T> FromKilogramSquareCentimeters(T kilogramsquarecentimeters)
         {
-            double value = (double) kilogramsquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
+            return new MassMomentOfInertia<T>(kilogramsquarecentimeters, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilogramSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilogramSquareDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareDecimeters(QuantityValue kilogramsquaredecimeters)
+        public static MassMomentOfInertia<T> FromKilogramSquareDecimeters(T kilogramsquaredecimeters)
         {
-            double value = (double) kilogramsquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
+            return new MassMomentOfInertia<T>(kilogramsquaredecimeters, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilogramSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilogramSquareMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareMeters(QuantityValue kilogramsquaremeters)
+        public static MassMomentOfInertia<T> FromKilogramSquareMeters(T kilogramsquaremeters)
         {
-            double value = (double) kilogramsquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter);
+            return new MassMomentOfInertia<T>(kilogramsquaremeters, MassMomentOfInertiaUnit.KilogramSquareMeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilogramSquareMillimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilogramSquareMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareMillimeters(QuantityValue kilogramsquaremillimeters)
+        public static MassMomentOfInertia<T> FromKilogramSquareMillimeters(T kilogramsquaremillimeters)
         {
-            double value = (double) kilogramsquaremillimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
+            return new MassMomentOfInertia<T>(kilogramsquaremillimeters, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilotonneSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilotonneSquareCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareCentimeters(QuantityValue kilotonnesquarecentimeters)
+        public static MassMomentOfInertia<T> FromKilotonneSquareCentimeters(T kilotonnesquarecentimeters)
         {
-            double value = (double) kilotonnesquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
+            return new MassMomentOfInertia<T>(kilotonnesquarecentimeters, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilotonneSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilotonneSquareDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareDecimeters(QuantityValue kilotonnesquaredecimeters)
+        public static MassMomentOfInertia<T> FromKilotonneSquareDecimeters(T kilotonnesquaredecimeters)
         {
-            double value = (double) kilotonnesquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
+            return new MassMomentOfInertia<T>(kilotonnesquaredecimeters, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilotonneSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilotonneSquareMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareMeters(QuantityValue kilotonnesquaremeters)
+        public static MassMomentOfInertia<T> FromKilotonneSquareMeters(T kilotonnesquaremeters)
         {
-            double value = (double) kilotonnesquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter);
+            return new MassMomentOfInertia<T>(kilotonnesquaremeters, MassMomentOfInertiaUnit.KilotonneSquareMeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from KilotonneSquareMilimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from KilotonneSquareMilimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareMilimeters(QuantityValue kilotonnesquaremilimeters)
+        public static MassMomentOfInertia<T> FromKilotonneSquareMilimeters(T kilotonnesquaremilimeters)
         {
-            double value = (double) kilotonnesquaremilimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
+            return new MassMomentOfInertia<T>(kilotonnesquaremilimeters, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MegatonneSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MegatonneSquareCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareCentimeters(QuantityValue megatonnesquarecentimeters)
+        public static MassMomentOfInertia<T> FromMegatonneSquareCentimeters(T megatonnesquarecentimeters)
         {
-            double value = (double) megatonnesquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
+            return new MassMomentOfInertia<T>(megatonnesquarecentimeters, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MegatonneSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MegatonneSquareDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareDecimeters(QuantityValue megatonnesquaredecimeters)
+        public static MassMomentOfInertia<T> FromMegatonneSquareDecimeters(T megatonnesquaredecimeters)
         {
-            double value = (double) megatonnesquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
+            return new MassMomentOfInertia<T>(megatonnesquaredecimeters, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MegatonneSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MegatonneSquareMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareMeters(QuantityValue megatonnesquaremeters)
+        public static MassMomentOfInertia<T> FromMegatonneSquareMeters(T megatonnesquaremeters)
         {
-            double value = (double) megatonnesquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter);
+            return new MassMomentOfInertia<T>(megatonnesquaremeters, MassMomentOfInertiaUnit.MegatonneSquareMeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MegatonneSquareMilimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MegatonneSquareMilimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareMilimeters(QuantityValue megatonnesquaremilimeters)
+        public static MassMomentOfInertia<T> FromMegatonneSquareMilimeters(T megatonnesquaremilimeters)
         {
-            double value = (double) megatonnesquaremilimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
+            return new MassMomentOfInertia<T>(megatonnesquaremilimeters, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MilligramSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MilligramSquareCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareCentimeters(QuantityValue milligramsquarecentimeters)
+        public static MassMomentOfInertia<T> FromMilligramSquareCentimeters(T milligramsquarecentimeters)
         {
-            double value = (double) milligramsquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
+            return new MassMomentOfInertia<T>(milligramsquarecentimeters, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MilligramSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MilligramSquareDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareDecimeters(QuantityValue milligramsquaredecimeters)
+        public static MassMomentOfInertia<T> FromMilligramSquareDecimeters(T milligramsquaredecimeters)
         {
-            double value = (double) milligramsquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
+            return new MassMomentOfInertia<T>(milligramsquaredecimeters, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MilligramSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MilligramSquareMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareMeters(QuantityValue milligramsquaremeters)
+        public static MassMomentOfInertia<T> FromMilligramSquareMeters(T milligramsquaremeters)
         {
-            double value = (double) milligramsquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter);
+            return new MassMomentOfInertia<T>(milligramsquaremeters, MassMomentOfInertiaUnit.MilligramSquareMeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from MilligramSquareMillimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from MilligramSquareMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareMillimeters(QuantityValue milligramsquaremillimeters)
+        public static MassMomentOfInertia<T> FromMilligramSquareMillimeters(T milligramsquaremillimeters)
         {
-            double value = (double) milligramsquaremillimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
+            return new MassMomentOfInertia<T>(milligramsquaremillimeters, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from PoundSquareFeet.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from PoundSquareFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromPoundSquareFeet(QuantityValue poundsquarefeet)
+        public static MassMomentOfInertia<T> FromPoundSquareFeet(T poundsquarefeet)
         {
-            double value = (double) poundsquarefeet;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot);
+            return new MassMomentOfInertia<T>(poundsquarefeet, MassMomentOfInertiaUnit.PoundSquareFoot);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from PoundSquareInches.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from PoundSquareInches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromPoundSquareInches(QuantityValue poundsquareinches)
+        public static MassMomentOfInertia<T> FromPoundSquareInches(T poundsquareinches)
         {
-            double value = (double) poundsquareinches;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch);
+            return new MassMomentOfInertia<T>(poundsquareinches, MassMomentOfInertiaUnit.PoundSquareInch);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from SlugSquareFeet.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from SlugSquareFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromSlugSquareFeet(QuantityValue slugsquarefeet)
+        public static MassMomentOfInertia<T> FromSlugSquareFeet(T slugsquarefeet)
         {
-            double value = (double) slugsquarefeet;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot);
+            return new MassMomentOfInertia<T>(slugsquarefeet, MassMomentOfInertiaUnit.SlugSquareFoot);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from SlugSquareInches.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from SlugSquareInches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromSlugSquareInches(QuantityValue slugsquareinches)
+        public static MassMomentOfInertia<T> FromSlugSquareInches(T slugsquareinches)
         {
-            double value = (double) slugsquareinches;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch);
+            return new MassMomentOfInertia<T>(slugsquareinches, MassMomentOfInertiaUnit.SlugSquareInch);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from TonneSquareCentimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from TonneSquareCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareCentimeters(QuantityValue tonnesquarecentimeters)
+        public static MassMomentOfInertia<T> FromTonneSquareCentimeters(T tonnesquarecentimeters)
         {
-            double value = (double) tonnesquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter);
+            return new MassMomentOfInertia<T>(tonnesquarecentimeters, MassMomentOfInertiaUnit.TonneSquareCentimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from TonneSquareDecimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from TonneSquareDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareDecimeters(QuantityValue tonnesquaredecimeters)
+        public static MassMomentOfInertia<T> FromTonneSquareDecimeters(T tonnesquaredecimeters)
         {
-            double value = (double) tonnesquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter);
+            return new MassMomentOfInertia<T>(tonnesquaredecimeters, MassMomentOfInertiaUnit.TonneSquareDecimeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from TonneSquareMeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from TonneSquareMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareMeters(QuantityValue tonnesquaremeters)
+        public static MassMomentOfInertia<T> FromTonneSquareMeters(T tonnesquaremeters)
         {
-            double value = (double) tonnesquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter);
+            return new MassMomentOfInertia<T>(tonnesquaremeters, MassMomentOfInertiaUnit.TonneSquareMeter);
         }
         /// <summary>
-        ///     Get MassMomentOfInertia from TonneSquareMilimeters.
+        ///     Get <see cref="MassMomentOfInertia{T}" /> from TonneSquareMilimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareMilimeters(QuantityValue tonnesquaremilimeters)
+        public static MassMomentOfInertia<T> FromTonneSquareMilimeters(T tonnesquaremilimeters)
         {
-            double value = (double) tonnesquaremilimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMilimeter);
+            return new MassMomentOfInertia<T>(tonnesquaremilimeters, MassMomentOfInertiaUnit.TonneSquareMilimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassMomentOfInertiaUnit" /> to <see cref="MassMomentOfInertia" />.
+        ///     Dynamically convert from value and unit enum <see cref="MassMomentOfInertiaUnit" /> to <see cref="MassMomentOfInertia{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassMomentOfInertia unit value.</returns>
-        public static MassMomentOfInertia From(QuantityValue value, MassMomentOfInertiaUnit fromUnit)
+        /// <returns><see cref="MassMomentOfInertia{T}" /> unit value.</returns>
+        public static MassMomentOfInertia<T> From(T value, MassMomentOfInertiaUnit fromUnit)
         {
-            return new MassMomentOfInertia((double)value, fromUnit);
+            return new MassMomentOfInertia<T>(value, fromUnit);
         }
 
         #endregion
@@ -652,7 +622,7 @@ public static MassMomentOfInertia From(QuantityValue value, MassMomentOfInertiaU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MassMomentOfInertia Parse(string str)
+        public static MassMomentOfInertia<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -680,9 +650,9 @@ public static MassMomentOfInertia Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MassMomentOfInertia Parse(string str, IFormatProvider? provider)
+        public static MassMomentOfInertia<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MassMomentOfInertia, MassMomentOfInertiaUnit>(
+            return QuantityParser.Default.Parse<T, MassMomentOfInertia<T>, MassMomentOfInertiaUnit>(
                 str,
                 provider,
                 From);
@@ -696,7 +666,7 @@ public static MassMomentOfInertia Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MassMomentOfInertia result)
+        public static bool TryParse(string? str, out MassMomentOfInertia<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -711,9 +681,9 @@ public static bool TryParse(string? str, out MassMomentOfInertia result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MassMomentOfInertia result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MassMomentOfInertia<T> result)
         {
-            return QuantityParser.Default.TryParse<MassMomentOfInertia, MassMomentOfInertiaUnit>(
+            return QuantityParser.Default.TryParse<T, MassMomentOfInertia<T>, MassMomentOfInertiaUnit>(
                 str,
                 provider,
                 From,
@@ -775,45 +745,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassM
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MassMomentOfInertia operator -(MassMomentOfInertia right)
+        public static MassMomentOfInertia<T> operator -(MassMomentOfInertia<T> right)
         {
-            return new MassMomentOfInertia(-right.Value, right.Unit);
+            return new MassMomentOfInertia<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MassMomentOfInertia"/> from adding two <see cref="MassMomentOfInertia"/>.</summary>
-        public static MassMomentOfInertia operator +(MassMomentOfInertia left, MassMomentOfInertia right)
+        /// <summary>Get <see cref="MassMomentOfInertia{T}"/> from adding two <see cref="MassMomentOfInertia{T}"/>.</summary>
+        public static MassMomentOfInertia<T> operator +(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
-            return new MassMomentOfInertia(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MassMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassMomentOfInertia"/> from subtracting two <see cref="MassMomentOfInertia"/>.</summary>
-        public static MassMomentOfInertia operator -(MassMomentOfInertia left, MassMomentOfInertia right)
+        /// <summary>Get <see cref="MassMomentOfInertia{T}"/> from subtracting two <see cref="MassMomentOfInertia{T}"/>.</summary>
+        public static MassMomentOfInertia<T> operator -(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
-            return new MassMomentOfInertia(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MassMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassMomentOfInertia"/> from multiplying value and <see cref="MassMomentOfInertia"/>.</summary>
-        public static MassMomentOfInertia operator *(double left, MassMomentOfInertia right)
+        /// <summary>Get <see cref="MassMomentOfInertia{T}"/> from multiplying value and <see cref="MassMomentOfInertia{T}"/>.</summary>
+        public static MassMomentOfInertia<T> operator *(T left, MassMomentOfInertia<T> right)
         {
-            return new MassMomentOfInertia(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MassMomentOfInertia<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MassMomentOfInertia"/> from multiplying value and <see cref="MassMomentOfInertia"/>.</summary>
-        public static MassMomentOfInertia operator *(MassMomentOfInertia left, double right)
+        /// <summary>Get <see cref="MassMomentOfInertia{T}"/> from multiplying value and <see cref="MassMomentOfInertia{T}"/>.</summary>
+        public static MassMomentOfInertia<T> operator *(MassMomentOfInertia<T> left, T right)
         {
-            return new MassMomentOfInertia(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MassMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MassMomentOfInertia"/> from dividing <see cref="MassMomentOfInertia"/> by value.</summary>
-        public static MassMomentOfInertia operator /(MassMomentOfInertia left, double right)
+        /// <summary>Get <see cref="MassMomentOfInertia{T}"/> from dividing <see cref="MassMomentOfInertia{T}"/> by value.</summary>
+        public static MassMomentOfInertia<T> operator /(MassMomentOfInertia<T> left, T right)
         {
-            return new MassMomentOfInertia(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MassMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MassMomentOfInertia"/> by <see cref="MassMomentOfInertia"/>.</summary>
-        public static double operator /(MassMomentOfInertia left, MassMomentOfInertia right)
+        /// <summary>Get ratio value from dividing <see cref="MassMomentOfInertia{T}"/> by <see cref="MassMomentOfInertia{T}"/>.</summary>
+        public static T operator /(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
-            return left.KilogramSquareMeters / right.KilogramSquareMeters;
+            return CompiledLambdas.Divide(left.KilogramSquareMeters, right.KilogramSquareMeters);
         }
 
         #endregion
@@ -821,39 +796,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassM
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MassMomentOfInertia left, MassMomentOfInertia right)
+        public static bool operator <=(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MassMomentOfInertia left, MassMomentOfInertia right)
+        public static bool operator >=(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MassMomentOfInertia left, MassMomentOfInertia right)
+        public static bool operator <(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MassMomentOfInertia left, MassMomentOfInertia right)
+        public static bool operator >(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MassMomentOfInertia left, MassMomentOfInertia right)
+        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MassMomentOfInertia left, MassMomentOfInertia right)
+        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MassMomentOfInertia<T> left, MassMomentOfInertia<T> right)
         {
             return !(left == right);
         }
@@ -862,37 +837,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out MassM
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MassMomentOfInertia objMassMomentOfInertia)) throw new ArgumentException("Expected type MassMomentOfInertia.", nameof(obj));
+            if(!(obj is MassMomentOfInertia<T> objMassMomentOfInertia)) throw new ArgumentException("Expected type MassMomentOfInertia.", nameof(obj));
 
             return CompareTo(objMassMomentOfInertia);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MassMomentOfInertia other)
+        public int CompareTo(MassMomentOfInertia<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MassMomentOfInertia objMassMomentOfInertia))
+            if(obj is null || !(obj is MassMomentOfInertia<T> objMassMomentOfInertia))
                 return false;
 
             return Equals(objMassMomentOfInertia);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MassMomentOfInertia other)
+        /// <remarks>Consider using <see cref="Equals(MassMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MassMomentOfInertia<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MassMomentOfInertia within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MassMomentOfInertia{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -930,21 +905,19 @@ public bool Equals(MassMomentOfInertia other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MassMomentOfInertia other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MassMomentOfInertia<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MassMomentOfInertia.</returns>
+        /// <returns>A hash code for the current <see cref="MassMomentOfInertia{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -958,17 +931,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassMomentOfInertiaUnit unit)
+        public T As(MassMomentOfInertiaUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -988,17 +961,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MassMomentOfInertiaUnit unitAsMassMomentOfInertiaUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassMomentOfInertiaUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMassMomentOfInertiaUnit);
+            var asValue = As(unitAsMassMomentOfInertiaUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MassMomentOfInertiaUnit>.As(MassMomentOfInertiaUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MassMomentOfInertia to another MassMomentOfInertia with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MassMomentOfInertia{T}" /> to another <see cref="MassMomentOfInertia{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MassMomentOfInertia with the specified unit.</returns>
-        public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit)
+        /// <returns>A <see cref="MassMomentOfInertia{T}" /> with the specified unit.</returns>
+        public MassMomentOfInertia<T> ToUnit(MassMomentOfInertiaUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MassMomentOfInertia(convertedValue, unit);
+            return new MassMomentOfInertia<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1011,7 +989,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MassMomentOfInertia ToUnit(UnitSystem unitSystem)
+        public MassMomentOfInertia<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1031,46 +1009,52 @@ public MassMomentOfInertia ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassMomentOfInertiaUnit> IQuantity<MassMomentOfInertiaUnit>.ToUnit(MassMomentOfInertiaUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MassMomentOfInertiaUnit, T> IQuantityT<MassMomentOfInertiaUnit, T>.ToUnit(MassMomentOfInertiaUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MassMomentOfInertiaUnit> IQuantity<MassMomentOfInertiaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MassMomentOfInertiaUnit, T> IQuantityT<MassMomentOfInertiaUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MassMomentOfInertiaUnit.GramSquareCentimeter: return _value/1e7;
-                case MassMomentOfInertiaUnit.GramSquareDecimeter: return _value/1e5;
-                case MassMomentOfInertiaUnit.GramSquareMeter: return _value/1e3;
-                case MassMomentOfInertiaUnit.GramSquareMillimeter: return _value/1e9;
-                case MassMomentOfInertiaUnit.KilogramSquareCentimeter: return (_value/1e7) * 1e3d;
-                case MassMomentOfInertiaUnit.KilogramSquareDecimeter: return (_value/1e5) * 1e3d;
-                case MassMomentOfInertiaUnit.KilogramSquareMeter: return (_value/1e3) * 1e3d;
-                case MassMomentOfInertiaUnit.KilogramSquareMillimeter: return (_value/1e9) * 1e3d;
-                case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: return (_value/1e1) * 1e3d;
-                case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: return (_value/1e-1) * 1e3d;
-                case MassMomentOfInertiaUnit.KilotonneSquareMeter: return (_value/1e-3) * 1e3d;
-                case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: return (_value/1e3) * 1e3d;
-                case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: return (_value/1e1) * 1e6d;
-                case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: return (_value/1e-1) * 1e6d;
-                case MassMomentOfInertiaUnit.MegatonneSquareMeter: return (_value/1e-3) * 1e6d;
-                case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: return (_value/1e3) * 1e6d;
-                case MassMomentOfInertiaUnit.MilligramSquareCentimeter: return (_value/1e7) * 1e-3d;
-                case MassMomentOfInertiaUnit.MilligramSquareDecimeter: return (_value/1e5) * 1e-3d;
-                case MassMomentOfInertiaUnit.MilligramSquareMeter: return (_value/1e3) * 1e-3d;
-                case MassMomentOfInertiaUnit.MilligramSquareMillimeter: return (_value/1e9) * 1e-3d;
-                case MassMomentOfInertiaUnit.PoundSquareFoot: return _value*4.21401101e-2;
-                case MassMomentOfInertiaUnit.PoundSquareInch: return _value*2.9263965e-4;
-                case MassMomentOfInertiaUnit.SlugSquareFoot: return _value*1.3558179619;
-                case MassMomentOfInertiaUnit.SlugSquareInch: return _value*9.41540242e-3;
-                case MassMomentOfInertiaUnit.TonneSquareCentimeter: return _value/1e1;
-                case MassMomentOfInertiaUnit.TonneSquareDecimeter: return _value/1e-1;
-                case MassMomentOfInertiaUnit.TonneSquareMeter: return _value/1e-3;
-                case MassMomentOfInertiaUnit.TonneSquareMilimeter: return _value/1e3;
+                case MassMomentOfInertiaUnit.GramSquareCentimeter: return Value/1e7;
+                case MassMomentOfInertiaUnit.GramSquareDecimeter: return Value/1e5;
+                case MassMomentOfInertiaUnit.GramSquareMeter: return Value/1e3;
+                case MassMomentOfInertiaUnit.GramSquareMillimeter: return Value/1e9;
+                case MassMomentOfInertiaUnit.KilogramSquareCentimeter: return (Value/1e7) * 1e3d;
+                case MassMomentOfInertiaUnit.KilogramSquareDecimeter: return (Value/1e5) * 1e3d;
+                case MassMomentOfInertiaUnit.KilogramSquareMeter: return (Value/1e3) * 1e3d;
+                case MassMomentOfInertiaUnit.KilogramSquareMillimeter: return (Value/1e9) * 1e3d;
+                case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: return (Value/1e1) * 1e3d;
+                case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: return (Value/1e-1) * 1e3d;
+                case MassMomentOfInertiaUnit.KilotonneSquareMeter: return (Value/1e-3) * 1e3d;
+                case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: return (Value/1e3) * 1e3d;
+                case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: return (Value/1e1) * 1e6d;
+                case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: return (Value/1e-1) * 1e6d;
+                case MassMomentOfInertiaUnit.MegatonneSquareMeter: return (Value/1e-3) * 1e6d;
+                case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: return (Value/1e3) * 1e6d;
+                case MassMomentOfInertiaUnit.MilligramSquareCentimeter: return (Value/1e7) * 1e-3d;
+                case MassMomentOfInertiaUnit.MilligramSquareDecimeter: return (Value/1e5) * 1e-3d;
+                case MassMomentOfInertiaUnit.MilligramSquareMeter: return (Value/1e3) * 1e-3d;
+                case MassMomentOfInertiaUnit.MilligramSquareMillimeter: return (Value/1e9) * 1e-3d;
+                case MassMomentOfInertiaUnit.PoundSquareFoot: return Value*4.21401101e-2;
+                case MassMomentOfInertiaUnit.PoundSquareInch: return Value*2.9263965e-4;
+                case MassMomentOfInertiaUnit.SlugSquareFoot: return Value*1.3558179619;
+                case MassMomentOfInertiaUnit.SlugSquareInch: return Value*9.41540242e-3;
+                case MassMomentOfInertiaUnit.TonneSquareCentimeter: return Value/1e1;
+                case MassMomentOfInertiaUnit.TonneSquareDecimeter: return Value/1e-1;
+                case MassMomentOfInertiaUnit.TonneSquareMeter: return Value/1e-3;
+                case MassMomentOfInertiaUnit.TonneSquareMilimeter: return Value/1e3;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1081,16 +1065,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MassMomentOfInertia ToBaseUnit()
+        internal MassMomentOfInertia<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MassMomentOfInertia(baseUnitValue, BaseUnit);
+            return new MassMomentOfInertia<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MassMomentOfInertiaUnit unit)
+        private T GetValueAs(MassMomentOfInertiaUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1220,57 +1204,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1280,33 +1264,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MassMomentOfInertia))
+            if(conversionType == typeof(MassMomentOfInertia<T>))
                 return this;
             else if(conversionType == typeof(MassMomentOfInertiaUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MassMomentOfInertia.QuantityType;
+                return MassMomentOfInertia<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MassMomentOfInertia.Info;
+                return MassMomentOfInertia<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MassMomentOfInertia.BaseDimensions;
+                return MassMomentOfInertia<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MassMomentOfInertia<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
index ec166846fc..12a4382fc3 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Molar energy is the amount of energy stored in 1 mole of a substance.
     /// </summary>
-    public partial struct MolarEnergy : IQuantity<MolarEnergyUnit>, IEquatable<MolarEnergy>, IComparable, IComparable<MolarEnergy>, IConvertible, IFormattable
+    public partial struct MolarEnergy<T> : IQuantityT<MolarEnergyUnit, T>, IEquatable<MolarEnergy<T>>, IComparable, IComparable<MolarEnergy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static MolarEnergy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MolarEnergy(double value, MolarEnergyUnit unit)
+        public MolarEnergy(T value, MolarEnergyUnit unit)
         {
             if(unit == MolarEnergyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public MolarEnergy(double value, MolarEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MolarEnergy(double value, UnitSystem unitSystem)
+        public MolarEnergy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public MolarEnergy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MolarEnergy, which is JoulePerMole. All conversions go via this value.
+        ///     The base unit of <see cref="MolarEnergy{T}" />, which is JoulePerMole. All conversions go via this value.
         /// </summary>
         public static MolarEnergyUnit BaseUnit { get; } = MolarEnergyUnit.JoulePerMole;
 
         /// <summary>
-        /// Represents the largest possible value of MolarEnergy
+        /// Represents the largest possible value of <see cref="MolarEnergy{T}" />
         /// </summary>
-        public static MolarEnergy MaxValue { get; } = new MolarEnergy(double.MaxValue, BaseUnit);
+        public static MolarEnergy<T> MaxValue { get; } = new MolarEnergy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MolarEnergy
+        /// Represents the smallest possible value of <see cref="MolarEnergy{T}" />
         /// </summary>
-        public static MolarEnergy MinValue { get; } = new MolarEnergy(double.MinValue, BaseUnit);
+        public static MolarEnergy<T> MinValue { get; } = new MolarEnergy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public MolarEnergy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MolarEnergy;
 
         /// <summary>
-        ///     All units of measurement for the MolarEnergy quantity.
+        ///     All units of measurement for the <see cref="MolarEnergy{T}" /> quantity.
         /// </summary>
         public static MolarEnergyUnit[] Units { get; } = Enum.GetValues(typeof(MolarEnergyUnit)).Cast<MolarEnergyUnit>().Except(new MolarEnergyUnit[]{ MolarEnergyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit JoulePerMole.
         /// </summary>
-        public static MolarEnergy Zero { get; } = new MolarEnergy(0, BaseUnit);
+        public static MolarEnergy<T> Zero { get; } = new MolarEnergy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public MolarEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public MolarEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MolarEnergy.QuantityType;
+        public QuantityType Type => MolarEnergy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MolarEnergy.BaseDimensions;
+        public BaseDimensions Dimensions => MolarEnergy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MolarEnergy in JoulesPerMole.
+        ///     Get <see cref="MolarEnergy{T}" /> in JoulesPerMole.
         /// </summary>
-        public double JoulesPerMole => As(MolarEnergyUnit.JoulePerMole);
+        public T JoulesPerMole => As(MolarEnergyUnit.JoulePerMole);
 
         /// <summary>
-        ///     Get MolarEnergy in KilojoulesPerMole.
+        ///     Get <see cref="MolarEnergy{T}" /> in KilojoulesPerMole.
         /// </summary>
-        public double KilojoulesPerMole => As(MolarEnergyUnit.KilojoulePerMole);
+        public T KilojoulesPerMole => As(MolarEnergyUnit.KilojoulePerMole);
 
         /// <summary>
-        ///     Get MolarEnergy in MegajoulesPerMole.
+        ///     Get <see cref="MolarEnergy{T}" /> in MegajoulesPerMole.
         /// </summary>
-        public double MegajoulesPerMole => As(MolarEnergyUnit.MegajoulePerMole);
+        public T MegajoulesPerMole => As(MolarEnergyUnit.MegajoulePerMole);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(MolarEnergyUnit unit, IFormatProvider? prov
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MolarEnergy from JoulesPerMole.
+        ///     Get <see cref="MolarEnergy{T}" /> from JoulesPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromJoulesPerMole(QuantityValue joulespermole)
+        public static MolarEnergy<T> FromJoulesPerMole(T joulespermole)
         {
-            double value = (double) joulespermole;
-            return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole);
+            return new MolarEnergy<T>(joulespermole, MolarEnergyUnit.JoulePerMole);
         }
         /// <summary>
-        ///     Get MolarEnergy from KilojoulesPerMole.
+        ///     Get <see cref="MolarEnergy{T}" /> from KilojoulesPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromKilojoulesPerMole(QuantityValue kilojoulespermole)
+        public static MolarEnergy<T> FromKilojoulesPerMole(T kilojoulespermole)
         {
-            double value = (double) kilojoulespermole;
-            return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole);
+            return new MolarEnergy<T>(kilojoulespermole, MolarEnergyUnit.KilojoulePerMole);
         }
         /// <summary>
-        ///     Get MolarEnergy from MegajoulesPerMole.
+        ///     Get <see cref="MolarEnergy{T}" /> from MegajoulesPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromMegajoulesPerMole(QuantityValue megajoulespermole)
+        public static MolarEnergy<T> FromMegajoulesPerMole(T megajoulespermole)
         {
-            double value = (double) megajoulespermole;
-            return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole);
+            return new MolarEnergy<T>(megajoulespermole, MolarEnergyUnit.MegajoulePerMole);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarEnergyUnit" /> to <see cref="MolarEnergy" />.
+        ///     Dynamically convert from value and unit enum <see cref="MolarEnergyUnit" /> to <see cref="MolarEnergy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MolarEnergy unit value.</returns>
-        public static MolarEnergy From(QuantityValue value, MolarEnergyUnit fromUnit)
+        /// <returns><see cref="MolarEnergy{T}" /> unit value.</returns>
+        public static MolarEnergy<T> From(T value, MolarEnergyUnit fromUnit)
         {
-            return new MolarEnergy((double)value, fromUnit);
+            return new MolarEnergy<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static MolarEnergy From(QuantityValue value, MolarEnergyUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MolarEnergy Parse(string str)
+        public static MolarEnergy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static MolarEnergy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MolarEnergy Parse(string str, IFormatProvider? provider)
+        public static MolarEnergy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MolarEnergy, MolarEnergyUnit>(
+            return QuantityParser.Default.Parse<T, MolarEnergy<T>, MolarEnergyUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static MolarEnergy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MolarEnergy result)
+        public static bool TryParse(string? str, out MolarEnergy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out MolarEnergy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MolarEnergy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MolarEnergy<T> result)
         {
-            return QuantityParser.Default.TryParse<MolarEnergy, MolarEnergyUnit>(
+            return QuantityParser.Default.TryParse<T, MolarEnergy<T>, MolarEnergyUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MolarEnergy operator -(MolarEnergy right)
+        public static MolarEnergy<T> operator -(MolarEnergy<T> right)
         {
-            return new MolarEnergy(-right.Value, right.Unit);
+            return new MolarEnergy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEnergy"/> from adding two <see cref="MolarEnergy"/>.</summary>
-        public static MolarEnergy operator +(MolarEnergy left, MolarEnergy right)
+        /// <summary>Get <see cref="MolarEnergy{T}"/> from adding two <see cref="MolarEnergy{T}"/>.</summary>
+        public static MolarEnergy<T> operator +(MolarEnergy<T> left, MolarEnergy<T> right)
         {
-            return new MolarEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MolarEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEnergy"/> from subtracting two <see cref="MolarEnergy"/>.</summary>
-        public static MolarEnergy operator -(MolarEnergy left, MolarEnergy right)
+        /// <summary>Get <see cref="MolarEnergy{T}"/> from subtracting two <see cref="MolarEnergy{T}"/>.</summary>
+        public static MolarEnergy<T> operator -(MolarEnergy<T> left, MolarEnergy<T> right)
         {
-            return new MolarEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MolarEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEnergy"/> from multiplying value and <see cref="MolarEnergy"/>.</summary>
-        public static MolarEnergy operator *(double left, MolarEnergy right)
+        /// <summary>Get <see cref="MolarEnergy{T}"/> from multiplying value and <see cref="MolarEnergy{T}"/>.</summary>
+        public static MolarEnergy<T> operator *(T left, MolarEnergy<T> right)
         {
-            return new MolarEnergy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MolarEnergy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEnergy"/> from multiplying value and <see cref="MolarEnergy"/>.</summary>
-        public static MolarEnergy operator *(MolarEnergy left, double right)
+        /// <summary>Get <see cref="MolarEnergy{T}"/> from multiplying value and <see cref="MolarEnergy{T}"/>.</summary>
+        public static MolarEnergy<T> operator *(MolarEnergy<T> left, T right)
         {
-            return new MolarEnergy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MolarEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEnergy"/> from dividing <see cref="MolarEnergy"/> by value.</summary>
-        public static MolarEnergy operator /(MolarEnergy left, double right)
+        /// <summary>Get <see cref="MolarEnergy{T}"/> from dividing <see cref="MolarEnergy{T}"/> by value.</summary>
+        public static MolarEnergy<T> operator /(MolarEnergy<T> left, T right)
         {
-            return new MolarEnergy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MolarEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MolarEnergy"/> by <see cref="MolarEnergy"/>.</summary>
-        public static double operator /(MolarEnergy left, MolarEnergy right)
+        /// <summary>Get ratio value from dividing <see cref="MolarEnergy{T}"/> by <see cref="MolarEnergy{T}"/>.</summary>
+        public static T operator /(MolarEnergy<T> left, MolarEnergy<T> right)
         {
-            return left.JoulesPerMole / right.JoulesPerMole;
+            return CompiledLambdas.Divide(left.JoulesPerMole, right.JoulesPerMole);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MolarEnergy left, MolarEnergy right)
+        public static bool operator <=(MolarEnergy<T> left, MolarEnergy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MolarEnergy left, MolarEnergy right)
+        public static bool operator >=(MolarEnergy<T> left, MolarEnergy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MolarEnergy left, MolarEnergy right)
+        public static bool operator <(MolarEnergy<T> left, MolarEnergy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MolarEnergy left, MolarEnergy right)
+        public static bool operator >(MolarEnergy<T> left, MolarEnergy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MolarEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MolarEnergy left, MolarEnergy right)
+        /// <remarks>Consider using <see cref="Equals(MolarEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MolarEnergy<T> left, MolarEnergy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MolarEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MolarEnergy left, MolarEnergy right)
+        /// <remarks>Consider using <see cref="Equals(MolarEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MolarEnergy<T> left, MolarEnergy<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MolarEnergy objMolarEnergy)) throw new ArgumentException("Expected type MolarEnergy.", nameof(obj));
+            if(!(obj is MolarEnergy<T> objMolarEnergy)) throw new ArgumentException("Expected type MolarEnergy.", nameof(obj));
 
             return CompareTo(objMolarEnergy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MolarEnergy other)
+        public int CompareTo(MolarEnergy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MolarEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MolarEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MolarEnergy objMolarEnergy))
+            if(obj is null || !(obj is MolarEnergy<T> objMolarEnergy))
                 return false;
 
             return Equals(objMolarEnergy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MolarEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MolarEnergy other)
+        /// <remarks>Consider using <see cref="Equals(MolarEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MolarEnergy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MolarEnergy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MolarEnergy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(MolarEnergy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MolarEnergy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MolarEnergy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MolarEnergy.</returns>
+        /// <returns>A hash code for the current <see cref="MolarEnergy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarEnergyUnit unit)
+        public T As(MolarEnergyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MolarEnergyUnit unitAsMolarEnergyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEnergyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMolarEnergyUnit);
+            var asValue = As(unitAsMolarEnergyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MolarEnergyUnit>.As(MolarEnergyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MolarEnergy to another MolarEnergy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MolarEnergy{T}" /> to another <see cref="MolarEnergy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MolarEnergy with the specified unit.</returns>
-        public MolarEnergy ToUnit(MolarEnergyUnit unit)
+        /// <returns>A <see cref="MolarEnergy{T}" /> with the specified unit.</returns>
+        public MolarEnergy<T> ToUnit(MolarEnergyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MolarEnergy(convertedValue, unit);
+            return new MolarEnergy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MolarEnergy ToUnit(UnitSystem unitSystem)
+        public MolarEnergy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public MolarEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarEnergyUnit> IQuantity<MolarEnergyUnit>.ToUnit(MolarEnergyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MolarEnergyUnit, T> IQuantityT<MolarEnergyUnit, T>.ToUnit(MolarEnergyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MolarEnergyUnit> IQuantity<MolarEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MolarEnergyUnit, T> IQuantityT<MolarEnergyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MolarEnergyUnit.JoulePerMole: return _value;
-                case MolarEnergyUnit.KilojoulePerMole: return (_value) * 1e3d;
-                case MolarEnergyUnit.MegajoulePerMole: return (_value) * 1e6d;
+                case MolarEnergyUnit.JoulePerMole: return Value;
+                case MolarEnergyUnit.KilojoulePerMole: return (Value) * 1e3d;
+                case MolarEnergyUnit.MegajoulePerMole: return (Value) * 1e6d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MolarEnergy ToBaseUnit()
+        internal MolarEnergy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MolarEnergy(baseUnitValue, BaseUnit);
+            return new MolarEnergy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MolarEnergyUnit unit)
+        private T GetValueAs(MolarEnergyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarEnergy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarEnergy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarEnergy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarEnergy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarEnergy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarEnergy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MolarEnergy))
+            if(conversionType == typeof(MolarEnergy<T>))
                 return this;
             else if(conversionType == typeof(MolarEnergyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MolarEnergy.QuantityType;
+                return MolarEnergy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MolarEnergy.Info;
+                return MolarEnergy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MolarEnergy.BaseDimensions;
+                return MolarEnergy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MolarEnergy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MolarEnergy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
index 3e9837ddcc..80ed27c9b2 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Molar entropy is amount of energy required to increase temperature of 1 mole substance by 1 Kelvin.
     /// </summary>
-    public partial struct MolarEntropy : IQuantity<MolarEntropyUnit>, IEquatable<MolarEntropy>, IComparable, IComparable<MolarEntropy>, IConvertible, IFormattable
+    public partial struct MolarEntropy<T> : IQuantityT<MolarEntropyUnit, T>, IEquatable<MolarEntropy<T>>, IComparable, IComparable<MolarEntropy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static MolarEntropy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MolarEntropy(double value, MolarEntropyUnit unit)
+        public MolarEntropy(T value, MolarEntropyUnit unit)
         {
             if(unit == MolarEntropyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public MolarEntropy(double value, MolarEntropyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MolarEntropy(double value, UnitSystem unitSystem)
+        public MolarEntropy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public MolarEntropy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MolarEntropy, which is JoulePerMoleKelvin. All conversions go via this value.
+        ///     The base unit of <see cref="MolarEntropy{T}" />, which is JoulePerMoleKelvin. All conversions go via this value.
         /// </summary>
         public static MolarEntropyUnit BaseUnit { get; } = MolarEntropyUnit.JoulePerMoleKelvin;
 
         /// <summary>
-        /// Represents the largest possible value of MolarEntropy
+        /// Represents the largest possible value of <see cref="MolarEntropy{T}" />
         /// </summary>
-        public static MolarEntropy MaxValue { get; } = new MolarEntropy(double.MaxValue, BaseUnit);
+        public static MolarEntropy<T> MaxValue { get; } = new MolarEntropy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MolarEntropy
+        /// Represents the smallest possible value of <see cref="MolarEntropy{T}" />
         /// </summary>
-        public static MolarEntropy MinValue { get; } = new MolarEntropy(double.MinValue, BaseUnit);
+        public static MolarEntropy<T> MinValue { get; } = new MolarEntropy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public MolarEntropy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MolarEntropy;
 
         /// <summary>
-        ///     All units of measurement for the MolarEntropy quantity.
+        ///     All units of measurement for the <see cref="MolarEntropy{T}" /> quantity.
         /// </summary>
         public static MolarEntropyUnit[] Units { get; } = Enum.GetValues(typeof(MolarEntropyUnit)).Cast<MolarEntropyUnit>().Except(new MolarEntropyUnit[]{ MolarEntropyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit JoulePerMoleKelvin.
         /// </summary>
-        public static MolarEntropy Zero { get; } = new MolarEntropy(0, BaseUnit);
+        public static MolarEntropy<T> Zero { get; } = new MolarEntropy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public MolarEntropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public MolarEntropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MolarEntropy.QuantityType;
+        public QuantityType Type => MolarEntropy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MolarEntropy.BaseDimensions;
+        public BaseDimensions Dimensions => MolarEntropy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MolarEntropy in JoulesPerMoleKelvin.
+        ///     Get <see cref="MolarEntropy{T}" /> in JoulesPerMoleKelvin.
         /// </summary>
-        public double JoulesPerMoleKelvin => As(MolarEntropyUnit.JoulePerMoleKelvin);
+        public T JoulesPerMoleKelvin => As(MolarEntropyUnit.JoulePerMoleKelvin);
 
         /// <summary>
-        ///     Get MolarEntropy in KilojoulesPerMoleKelvin.
+        ///     Get <see cref="MolarEntropy{T}" /> in KilojoulesPerMoleKelvin.
         /// </summary>
-        public double KilojoulesPerMoleKelvin => As(MolarEntropyUnit.KilojoulePerMoleKelvin);
+        public T KilojoulesPerMoleKelvin => As(MolarEntropyUnit.KilojoulePerMoleKelvin);
 
         /// <summary>
-        ///     Get MolarEntropy in MegajoulesPerMoleKelvin.
+        ///     Get <see cref="MolarEntropy{T}" /> in MegajoulesPerMoleKelvin.
         /// </summary>
-        public double MegajoulesPerMoleKelvin => As(MolarEntropyUnit.MegajoulePerMoleKelvin);
+        public T MegajoulesPerMoleKelvin => As(MolarEntropyUnit.MegajoulePerMoleKelvin);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(MolarEntropyUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MolarEntropy from JoulesPerMoleKelvin.
+        ///     Get <see cref="MolarEntropy{T}" /> from JoulesPerMoleKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromJoulesPerMoleKelvin(QuantityValue joulespermolekelvin)
+        public static MolarEntropy<T> FromJoulesPerMoleKelvin(T joulespermolekelvin)
         {
-            double value = (double) joulespermolekelvin;
-            return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin);
+            return new MolarEntropy<T>(joulespermolekelvin, MolarEntropyUnit.JoulePerMoleKelvin);
         }
         /// <summary>
-        ///     Get MolarEntropy from KilojoulesPerMoleKelvin.
+        ///     Get <see cref="MolarEntropy{T}" /> from KilojoulesPerMoleKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromKilojoulesPerMoleKelvin(QuantityValue kilojoulespermolekelvin)
+        public static MolarEntropy<T> FromKilojoulesPerMoleKelvin(T kilojoulespermolekelvin)
         {
-            double value = (double) kilojoulespermolekelvin;
-            return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin);
+            return new MolarEntropy<T>(kilojoulespermolekelvin, MolarEntropyUnit.KilojoulePerMoleKelvin);
         }
         /// <summary>
-        ///     Get MolarEntropy from MegajoulesPerMoleKelvin.
+        ///     Get <see cref="MolarEntropy{T}" /> from MegajoulesPerMoleKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromMegajoulesPerMoleKelvin(QuantityValue megajoulespermolekelvin)
+        public static MolarEntropy<T> FromMegajoulesPerMoleKelvin(T megajoulespermolekelvin)
         {
-            double value = (double) megajoulespermolekelvin;
-            return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin);
+            return new MolarEntropy<T>(megajoulespermolekelvin, MolarEntropyUnit.MegajoulePerMoleKelvin);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarEntropyUnit" /> to <see cref="MolarEntropy" />.
+        ///     Dynamically convert from value and unit enum <see cref="MolarEntropyUnit" /> to <see cref="MolarEntropy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MolarEntropy unit value.</returns>
-        public static MolarEntropy From(QuantityValue value, MolarEntropyUnit fromUnit)
+        /// <returns><see cref="MolarEntropy{T}" /> unit value.</returns>
+        public static MolarEntropy<T> From(T value, MolarEntropyUnit fromUnit)
         {
-            return new MolarEntropy((double)value, fromUnit);
+            return new MolarEntropy<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static MolarEntropy From(QuantityValue value, MolarEntropyUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MolarEntropy Parse(string str)
+        public static MolarEntropy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static MolarEntropy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MolarEntropy Parse(string str, IFormatProvider? provider)
+        public static MolarEntropy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MolarEntropy, MolarEntropyUnit>(
+            return QuantityParser.Default.Parse<T, MolarEntropy<T>, MolarEntropyUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static MolarEntropy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MolarEntropy result)
+        public static bool TryParse(string? str, out MolarEntropy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out MolarEntropy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MolarEntropy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MolarEntropy<T> result)
         {
-            return QuantityParser.Default.TryParse<MolarEntropy, MolarEntropyUnit>(
+            return QuantityParser.Default.TryParse<T, MolarEntropy<T>, MolarEntropyUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MolarEntropy operator -(MolarEntropy right)
+        public static MolarEntropy<T> operator -(MolarEntropy<T> right)
         {
-            return new MolarEntropy(-right.Value, right.Unit);
+            return new MolarEntropy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEntropy"/> from adding two <see cref="MolarEntropy"/>.</summary>
-        public static MolarEntropy operator +(MolarEntropy left, MolarEntropy right)
+        /// <summary>Get <see cref="MolarEntropy{T}"/> from adding two <see cref="MolarEntropy{T}"/>.</summary>
+        public static MolarEntropy<T> operator +(MolarEntropy<T> left, MolarEntropy<T> right)
         {
-            return new MolarEntropy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MolarEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEntropy"/> from subtracting two <see cref="MolarEntropy"/>.</summary>
-        public static MolarEntropy operator -(MolarEntropy left, MolarEntropy right)
+        /// <summary>Get <see cref="MolarEntropy{T}"/> from subtracting two <see cref="MolarEntropy{T}"/>.</summary>
+        public static MolarEntropy<T> operator -(MolarEntropy<T> left, MolarEntropy<T> right)
         {
-            return new MolarEntropy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MolarEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEntropy"/> from multiplying value and <see cref="MolarEntropy"/>.</summary>
-        public static MolarEntropy operator *(double left, MolarEntropy right)
+        /// <summary>Get <see cref="MolarEntropy{T}"/> from multiplying value and <see cref="MolarEntropy{T}"/>.</summary>
+        public static MolarEntropy<T> operator *(T left, MolarEntropy<T> right)
         {
-            return new MolarEntropy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MolarEntropy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEntropy"/> from multiplying value and <see cref="MolarEntropy"/>.</summary>
-        public static MolarEntropy operator *(MolarEntropy left, double right)
+        /// <summary>Get <see cref="MolarEntropy{T}"/> from multiplying value and <see cref="MolarEntropy{T}"/>.</summary>
+        public static MolarEntropy<T> operator *(MolarEntropy<T> left, T right)
         {
-            return new MolarEntropy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MolarEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarEntropy"/> from dividing <see cref="MolarEntropy"/> by value.</summary>
-        public static MolarEntropy operator /(MolarEntropy left, double right)
+        /// <summary>Get <see cref="MolarEntropy{T}"/> from dividing <see cref="MolarEntropy{T}"/> by value.</summary>
+        public static MolarEntropy<T> operator /(MolarEntropy<T> left, T right)
         {
-            return new MolarEntropy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MolarEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MolarEntropy"/> by <see cref="MolarEntropy"/>.</summary>
-        public static double operator /(MolarEntropy left, MolarEntropy right)
+        /// <summary>Get ratio value from dividing <see cref="MolarEntropy{T}"/> by <see cref="MolarEntropy{T}"/>.</summary>
+        public static T operator /(MolarEntropy<T> left, MolarEntropy<T> right)
         {
-            return left.JoulesPerMoleKelvin / right.JoulesPerMoleKelvin;
+            return CompiledLambdas.Divide(left.JoulesPerMoleKelvin, right.JoulesPerMoleKelvin);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MolarEntropy left, MolarEntropy right)
+        public static bool operator <=(MolarEntropy<T> left, MolarEntropy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MolarEntropy left, MolarEntropy right)
+        public static bool operator >=(MolarEntropy<T> left, MolarEntropy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MolarEntropy left, MolarEntropy right)
+        public static bool operator <(MolarEntropy<T> left, MolarEntropy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MolarEntropy left, MolarEntropy right)
+        public static bool operator >(MolarEntropy<T> left, MolarEntropy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MolarEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MolarEntropy left, MolarEntropy right)
+        /// <remarks>Consider using <see cref="Equals(MolarEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MolarEntropy<T> left, MolarEntropy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MolarEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MolarEntropy left, MolarEntropy right)
+        /// <remarks>Consider using <see cref="Equals(MolarEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MolarEntropy<T> left, MolarEntropy<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MolarEntropy objMolarEntropy)) throw new ArgumentException("Expected type MolarEntropy.", nameof(obj));
+            if(!(obj is MolarEntropy<T> objMolarEntropy)) throw new ArgumentException("Expected type MolarEntropy.", nameof(obj));
 
             return CompareTo(objMolarEntropy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MolarEntropy other)
+        public int CompareTo(MolarEntropy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MolarEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MolarEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MolarEntropy objMolarEntropy))
+            if(obj is null || !(obj is MolarEntropy<T> objMolarEntropy))
                 return false;
 
             return Equals(objMolarEntropy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MolarEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MolarEntropy other)
+        /// <remarks>Consider using <see cref="Equals(MolarEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MolarEntropy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MolarEntropy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MolarEntropy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(MolarEntropy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MolarEntropy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MolarEntropy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MolarEntropy.</returns>
+        /// <returns>A hash code for the current <see cref="MolarEntropy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarEntropyUnit unit)
+        public T As(MolarEntropyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MolarEntropyUnit unitAsMolarEntropyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEntropyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMolarEntropyUnit);
+            var asValue = As(unitAsMolarEntropyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MolarEntropyUnit>.As(MolarEntropyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MolarEntropy to another MolarEntropy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MolarEntropy{T}" /> to another <see cref="MolarEntropy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MolarEntropy with the specified unit.</returns>
-        public MolarEntropy ToUnit(MolarEntropyUnit unit)
+        /// <returns>A <see cref="MolarEntropy{T}" /> with the specified unit.</returns>
+        public MolarEntropy<T> ToUnit(MolarEntropyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MolarEntropy(convertedValue, unit);
+            return new MolarEntropy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MolarEntropy ToUnit(UnitSystem unitSystem)
+        public MolarEntropy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public MolarEntropy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarEntropyUnit> IQuantity<MolarEntropyUnit>.ToUnit(MolarEntropyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MolarEntropyUnit, T> IQuantityT<MolarEntropyUnit, T>.ToUnit(MolarEntropyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MolarEntropyUnit> IQuantity<MolarEntropyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MolarEntropyUnit, T> IQuantityT<MolarEntropyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MolarEntropyUnit.JoulePerMoleKelvin: return _value;
-                case MolarEntropyUnit.KilojoulePerMoleKelvin: return (_value) * 1e3d;
-                case MolarEntropyUnit.MegajoulePerMoleKelvin: return (_value) * 1e6d;
+                case MolarEntropyUnit.JoulePerMoleKelvin: return Value;
+                case MolarEntropyUnit.KilojoulePerMoleKelvin: return (Value) * 1e3d;
+                case MolarEntropyUnit.MegajoulePerMoleKelvin: return (Value) * 1e6d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MolarEntropy ToBaseUnit()
+        internal MolarEntropy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MolarEntropy(baseUnitValue, BaseUnit);
+            return new MolarEntropy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MolarEntropyUnit unit)
+        private T GetValueAs(MolarEntropyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarEntropy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarEntropy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarEntropy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarEntropy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarEntropy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarEntropy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MolarEntropy))
+            if(conversionType == typeof(MolarEntropy<T>))
                 return this;
             else if(conversionType == typeof(MolarEntropyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MolarEntropy.QuantityType;
+                return MolarEntropy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MolarEntropy.Info;
+                return MolarEntropy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MolarEntropy.BaseDimensions;
+                return MolarEntropy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MolarEntropy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MolarEntropy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
index 92fb698145..d07ce333df 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In chemistry, the molar mass M is a physical property defined as the mass of a given substance (chemical element or chemical compound) divided by the amount of substance.
     /// </summary>
-    public partial struct MolarMass : IQuantity<MolarMassUnit>, IEquatable<MolarMass>, IComparable, IComparable<MolarMass>, IConvertible, IFormattable
+    public partial struct MolarMass<T> : IQuantityT<MolarMassUnit, T>, IEquatable<MolarMass<T>>, IComparable, IComparable<MolarMass<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -74,12 +70,12 @@ static MolarMass()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public MolarMass(double value, MolarMassUnit unit)
+        public MolarMass(T value, MolarMassUnit unit)
         {
             if(unit == MolarMassUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -91,14 +87,14 @@ public MolarMass(double value, MolarMassUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MolarMass(double value, UnitSystem unitSystem)
+        public MolarMass(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -113,19 +109,19 @@ public MolarMass(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of MolarMass, which is KilogramPerMole. All conversions go via this value.
+        ///     The base unit of <see cref="MolarMass{T}" />, which is KilogramPerMole. All conversions go via this value.
         /// </summary>
         public static MolarMassUnit BaseUnit { get; } = MolarMassUnit.KilogramPerMole;
 
         /// <summary>
-        /// Represents the largest possible value of MolarMass
+        /// Represents the largest possible value of <see cref="MolarMass{T}" />
         /// </summary>
-        public static MolarMass MaxValue { get; } = new MolarMass(double.MaxValue, BaseUnit);
+        public static MolarMass<T> MaxValue { get; } = new MolarMass<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of MolarMass
+        /// Represents the smallest possible value of <see cref="MolarMass{T}" />
         /// </summary>
-        public static MolarMass MinValue { get; } = new MolarMass(double.MinValue, BaseUnit);
+        public static MolarMass<T> MinValue { get; } = new MolarMass<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -134,14 +130,14 @@ public MolarMass(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.MolarMass;
 
         /// <summary>
-        ///     All units of measurement for the MolarMass quantity.
+        ///     All units of measurement for the <see cref="MolarMass{T}" /> quantity.
         /// </summary>
         public static MolarMassUnit[] Units { get; } = Enum.GetValues(typeof(MolarMassUnit)).Cast<MolarMassUnit>().Except(new MolarMassUnit[]{ MolarMassUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit KilogramPerMole.
         /// </summary>
-        public static MolarMass Zero { get; } = new MolarMass(0, BaseUnit);
+        public static MolarMass<T> Zero { get; } = new MolarMass<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -150,7 +146,9 @@ public MolarMass(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -166,76 +164,76 @@ public MolarMass(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => MolarMass.QuantityType;
+        public QuantityType Type => MolarMass<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => MolarMass.BaseDimensions;
+        public BaseDimensions Dimensions => MolarMass<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get MolarMass in CentigramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in CentigramsPerMole.
         /// </summary>
-        public double CentigramsPerMole => As(MolarMassUnit.CentigramPerMole);
+        public T CentigramsPerMole => As(MolarMassUnit.CentigramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in DecagramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in DecagramsPerMole.
         /// </summary>
-        public double DecagramsPerMole => As(MolarMassUnit.DecagramPerMole);
+        public T DecagramsPerMole => As(MolarMassUnit.DecagramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in DecigramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in DecigramsPerMole.
         /// </summary>
-        public double DecigramsPerMole => As(MolarMassUnit.DecigramPerMole);
+        public T DecigramsPerMole => As(MolarMassUnit.DecigramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in GramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in GramsPerMole.
         /// </summary>
-        public double GramsPerMole => As(MolarMassUnit.GramPerMole);
+        public T GramsPerMole => As(MolarMassUnit.GramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in HectogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in HectogramsPerMole.
         /// </summary>
-        public double HectogramsPerMole => As(MolarMassUnit.HectogramPerMole);
+        public T HectogramsPerMole => As(MolarMassUnit.HectogramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in KilogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in KilogramsPerMole.
         /// </summary>
-        public double KilogramsPerMole => As(MolarMassUnit.KilogramPerMole);
+        public T KilogramsPerMole => As(MolarMassUnit.KilogramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in KilopoundsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in KilopoundsPerMole.
         /// </summary>
-        public double KilopoundsPerMole => As(MolarMassUnit.KilopoundPerMole);
+        public T KilopoundsPerMole => As(MolarMassUnit.KilopoundPerMole);
 
         /// <summary>
-        ///     Get MolarMass in MegapoundsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in MegapoundsPerMole.
         /// </summary>
-        public double MegapoundsPerMole => As(MolarMassUnit.MegapoundPerMole);
+        public T MegapoundsPerMole => As(MolarMassUnit.MegapoundPerMole);
 
         /// <summary>
-        ///     Get MolarMass in MicrogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in MicrogramsPerMole.
         /// </summary>
-        public double MicrogramsPerMole => As(MolarMassUnit.MicrogramPerMole);
+        public T MicrogramsPerMole => As(MolarMassUnit.MicrogramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in MilligramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in MilligramsPerMole.
         /// </summary>
-        public double MilligramsPerMole => As(MolarMassUnit.MilligramPerMole);
+        public T MilligramsPerMole => As(MolarMassUnit.MilligramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in NanogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in NanogramsPerMole.
         /// </summary>
-        public double NanogramsPerMole => As(MolarMassUnit.NanogramPerMole);
+        public T NanogramsPerMole => As(MolarMassUnit.NanogramPerMole);
 
         /// <summary>
-        ///     Get MolarMass in PoundsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> in PoundsPerMole.
         /// </summary>
-        public double PoundsPerMole => As(MolarMassUnit.PoundPerMole);
+        public T PoundsPerMole => As(MolarMassUnit.PoundPerMole);
 
         #endregion
 
@@ -267,123 +265,111 @@ public static string GetAbbreviation(MolarMassUnit unit, IFormatProvider? provid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get MolarMass from CentigramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from CentigramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromCentigramsPerMole(QuantityValue centigramspermole)
+        public static MolarMass<T> FromCentigramsPerMole(T centigramspermole)
         {
-            double value = (double) centigramspermole;
-            return new MolarMass(value, MolarMassUnit.CentigramPerMole);
+            return new MolarMass<T>(centigramspermole, MolarMassUnit.CentigramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from DecagramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from DecagramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromDecagramsPerMole(QuantityValue decagramspermole)
+        public static MolarMass<T> FromDecagramsPerMole(T decagramspermole)
         {
-            double value = (double) decagramspermole;
-            return new MolarMass(value, MolarMassUnit.DecagramPerMole);
+            return new MolarMass<T>(decagramspermole, MolarMassUnit.DecagramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from DecigramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from DecigramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromDecigramsPerMole(QuantityValue decigramspermole)
+        public static MolarMass<T> FromDecigramsPerMole(T decigramspermole)
         {
-            double value = (double) decigramspermole;
-            return new MolarMass(value, MolarMassUnit.DecigramPerMole);
+            return new MolarMass<T>(decigramspermole, MolarMassUnit.DecigramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from GramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from GramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromGramsPerMole(QuantityValue gramspermole)
+        public static MolarMass<T> FromGramsPerMole(T gramspermole)
         {
-            double value = (double) gramspermole;
-            return new MolarMass(value, MolarMassUnit.GramPerMole);
+            return new MolarMass<T>(gramspermole, MolarMassUnit.GramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from HectogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from HectogramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromHectogramsPerMole(QuantityValue hectogramspermole)
+        public static MolarMass<T> FromHectogramsPerMole(T hectogramspermole)
         {
-            double value = (double) hectogramspermole;
-            return new MolarMass(value, MolarMassUnit.HectogramPerMole);
+            return new MolarMass<T>(hectogramspermole, MolarMassUnit.HectogramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from KilogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from KilogramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilogramsPerMole(QuantityValue kilogramspermole)
+        public static MolarMass<T> FromKilogramsPerMole(T kilogramspermole)
         {
-            double value = (double) kilogramspermole;
-            return new MolarMass(value, MolarMassUnit.KilogramPerMole);
+            return new MolarMass<T>(kilogramspermole, MolarMassUnit.KilogramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from KilopoundsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from KilopoundsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilopoundsPerMole(QuantityValue kilopoundspermole)
+        public static MolarMass<T> FromKilopoundsPerMole(T kilopoundspermole)
         {
-            double value = (double) kilopoundspermole;
-            return new MolarMass(value, MolarMassUnit.KilopoundPerMole);
+            return new MolarMass<T>(kilopoundspermole, MolarMassUnit.KilopoundPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from MegapoundsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from MegapoundsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMegapoundsPerMole(QuantityValue megapoundspermole)
+        public static MolarMass<T> FromMegapoundsPerMole(T megapoundspermole)
         {
-            double value = (double) megapoundspermole;
-            return new MolarMass(value, MolarMassUnit.MegapoundPerMole);
+            return new MolarMass<T>(megapoundspermole, MolarMassUnit.MegapoundPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from MicrogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from MicrogramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMicrogramsPerMole(QuantityValue microgramspermole)
+        public static MolarMass<T> FromMicrogramsPerMole(T microgramspermole)
         {
-            double value = (double) microgramspermole;
-            return new MolarMass(value, MolarMassUnit.MicrogramPerMole);
+            return new MolarMass<T>(microgramspermole, MolarMassUnit.MicrogramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from MilligramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from MilligramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMilligramsPerMole(QuantityValue milligramspermole)
+        public static MolarMass<T> FromMilligramsPerMole(T milligramspermole)
         {
-            double value = (double) milligramspermole;
-            return new MolarMass(value, MolarMassUnit.MilligramPerMole);
+            return new MolarMass<T>(milligramspermole, MolarMassUnit.MilligramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from NanogramsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from NanogramsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromNanogramsPerMole(QuantityValue nanogramspermole)
+        public static MolarMass<T> FromNanogramsPerMole(T nanogramspermole)
         {
-            double value = (double) nanogramspermole;
-            return new MolarMass(value, MolarMassUnit.NanogramPerMole);
+            return new MolarMass<T>(nanogramspermole, MolarMassUnit.NanogramPerMole);
         }
         /// <summary>
-        ///     Get MolarMass from PoundsPerMole.
+        ///     Get <see cref="MolarMass{T}" /> from PoundsPerMole.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromPoundsPerMole(QuantityValue poundspermole)
+        public static MolarMass<T> FromPoundsPerMole(T poundspermole)
         {
-            double value = (double) poundspermole;
-            return new MolarMass(value, MolarMassUnit.PoundPerMole);
+            return new MolarMass<T>(poundspermole, MolarMassUnit.PoundPerMole);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarMassUnit" /> to <see cref="MolarMass" />.
+        ///     Dynamically convert from value and unit enum <see cref="MolarMassUnit" /> to <see cref="MolarMass{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MolarMass unit value.</returns>
-        public static MolarMass From(QuantityValue value, MolarMassUnit fromUnit)
+        /// <returns><see cref="MolarMass{T}" /> unit value.</returns>
+        public static MolarMass<T> From(T value, MolarMassUnit fromUnit)
         {
-            return new MolarMass((double)value, fromUnit);
+            return new MolarMass<T>(value, fromUnit);
         }
 
         #endregion
@@ -412,7 +398,7 @@ public static MolarMass From(QuantityValue value, MolarMassUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static MolarMass Parse(string str)
+        public static MolarMass<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -440,9 +426,9 @@ public static MolarMass Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static MolarMass Parse(string str, IFormatProvider? provider)
+        public static MolarMass<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<MolarMass, MolarMassUnit>(
+            return QuantityParser.Default.Parse<T, MolarMass<T>, MolarMassUnit>(
                 str,
                 provider,
                 From);
@@ -456,7 +442,7 @@ public static MolarMass Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out MolarMass result)
+        public static bool TryParse(string? str, out MolarMass<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -471,9 +457,9 @@ public static bool TryParse(string? str, out MolarMass result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out MolarMass result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out MolarMass<T> result)
         {
-            return QuantityParser.Default.TryParse<MolarMass, MolarMassUnit>(
+            return QuantityParser.Default.TryParse<T, MolarMass<T>, MolarMassUnit>(
                 str,
                 provider,
                 From,
@@ -535,45 +521,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static MolarMass operator -(MolarMass right)
+        public static MolarMass<T> operator -(MolarMass<T> right)
         {
-            return new MolarMass(-right.Value, right.Unit);
+            return new MolarMass<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="MolarMass"/> from adding two <see cref="MolarMass"/>.</summary>
-        public static MolarMass operator +(MolarMass left, MolarMass right)
+        /// <summary>Get <see cref="MolarMass{T}"/> from adding two <see cref="MolarMass{T}"/>.</summary>
+        public static MolarMass<T> operator +(MolarMass<T> left, MolarMass<T> right)
         {
-            return new MolarMass(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new MolarMass<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarMass"/> from subtracting two <see cref="MolarMass"/>.</summary>
-        public static MolarMass operator -(MolarMass left, MolarMass right)
+        /// <summary>Get <see cref="MolarMass{T}"/> from subtracting two <see cref="MolarMass{T}"/>.</summary>
+        public static MolarMass<T> operator -(MolarMass<T> left, MolarMass<T> right)
         {
-            return new MolarMass(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new MolarMass<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarMass"/> from multiplying value and <see cref="MolarMass"/>.</summary>
-        public static MolarMass operator *(double left, MolarMass right)
+        /// <summary>Get <see cref="MolarMass{T}"/> from multiplying value and <see cref="MolarMass{T}"/>.</summary>
+        public static MolarMass<T> operator *(T left, MolarMass<T> right)
         {
-            return new MolarMass(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new MolarMass<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="MolarMass"/> from multiplying value and <see cref="MolarMass"/>.</summary>
-        public static MolarMass operator *(MolarMass left, double right)
+        /// <summary>Get <see cref="MolarMass{T}"/> from multiplying value and <see cref="MolarMass{T}"/>.</summary>
+        public static MolarMass<T> operator *(MolarMass<T> left, T right)
         {
-            return new MolarMass(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new MolarMass<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="MolarMass"/> from dividing <see cref="MolarMass"/> by value.</summary>
-        public static MolarMass operator /(MolarMass left, double right)
+        /// <summary>Get <see cref="MolarMass{T}"/> from dividing <see cref="MolarMass{T}"/> by value.</summary>
+        public static MolarMass<T> operator /(MolarMass<T> left, T right)
         {
-            return new MolarMass(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new MolarMass<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="MolarMass"/> by <see cref="MolarMass"/>.</summary>
-        public static double operator /(MolarMass left, MolarMass right)
+        /// <summary>Get ratio value from dividing <see cref="MolarMass{T}"/> by <see cref="MolarMass{T}"/>.</summary>
+        public static T operator /(MolarMass<T> left, MolarMass<T> right)
         {
-            return left.KilogramsPerMole / right.KilogramsPerMole;
+            return CompiledLambdas.Divide(left.KilogramsPerMole, right.KilogramsPerMole);
         }
 
         #endregion
@@ -581,39 +572,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(MolarMass left, MolarMass right)
+        public static bool operator <=(MolarMass<T> left, MolarMass<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(MolarMass left, MolarMass right)
+        public static bool operator >=(MolarMass<T> left, MolarMass<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(MolarMass left, MolarMass right)
+        public static bool operator <(MolarMass<T> left, MolarMass<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(MolarMass left, MolarMass right)
+        public static bool operator >(MolarMass<T> left, MolarMass<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MolarMass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(MolarMass left, MolarMass right)
+        /// <remarks>Consider using <see cref="Equals(MolarMass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(MolarMass<T> left, MolarMass<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(MolarMass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(MolarMass left, MolarMass right)
+        /// <remarks>Consider using <see cref="Equals(MolarMass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(MolarMass<T> left, MolarMass<T> right)
         {
             return !(left == right);
         }
@@ -622,37 +613,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is MolarMass objMolarMass)) throw new ArgumentException("Expected type MolarMass.", nameof(obj));
+            if(!(obj is MolarMass<T> objMolarMass)) throw new ArgumentException("Expected type MolarMass.", nameof(obj));
 
             return CompareTo(objMolarMass);
         }
 
         /// <inheritdoc />
-        public int CompareTo(MolarMass other)
+        public int CompareTo(MolarMass<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MolarMass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(MolarMass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is MolarMass objMolarMass))
+            if(obj is null || !(obj is MolarMass<T> objMolarMass))
                 return false;
 
             return Equals(objMolarMass);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(MolarMass, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(MolarMass other)
+        /// <remarks>Consider using <see cref="Equals(MolarMass{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(MolarMass<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another MolarMass within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="MolarMass{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -690,21 +681,19 @@ public bool Equals(MolarMass other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(MolarMass other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(MolarMass<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current MolarMass.</returns>
+        /// <returns>A hash code for the current <see cref="MolarMass{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -718,17 +707,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarMassUnit unit)
+        public T As(MolarMassUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -748,17 +737,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MolarMassUnit unitAsMolarMassUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarMassUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMolarMassUnit);
+            var asValue = As(unitAsMolarMassUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MolarMassUnit>.As(MolarMassUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this MolarMass to another MolarMass with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="MolarMass{T}" /> to another <see cref="MolarMass{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A MolarMass with the specified unit.</returns>
-        public MolarMass ToUnit(MolarMassUnit unit)
+        /// <returns>A <see cref="MolarMass{T}" /> with the specified unit.</returns>
+        public MolarMass<T> ToUnit(MolarMassUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new MolarMass(convertedValue, unit);
+            return new MolarMass<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -771,7 +765,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public MolarMass ToUnit(UnitSystem unitSystem)
+        public MolarMass<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -791,30 +785,36 @@ public MolarMass ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarMassUnit> IQuantity<MolarMassUnit>.ToUnit(MolarMassUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MolarMassUnit, T> IQuantityT<MolarMassUnit, T>.ToUnit(MolarMassUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MolarMassUnit> IQuantity<MolarMassUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MolarMassUnit, T> IQuantityT<MolarMassUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MolarMassUnit.CentigramPerMole: return (_value/1e3) * 1e-2d;
-                case MolarMassUnit.DecagramPerMole: return (_value/1e3) * 1e1d;
-                case MolarMassUnit.DecigramPerMole: return (_value/1e3) * 1e-1d;
-                case MolarMassUnit.GramPerMole: return _value/1e3;
-                case MolarMassUnit.HectogramPerMole: return (_value/1e3) * 1e2d;
-                case MolarMassUnit.KilogramPerMole: return (_value/1e3) * 1e3d;
-                case MolarMassUnit.KilopoundPerMole: return (_value*0.45359237) * 1e3d;
-                case MolarMassUnit.MegapoundPerMole: return (_value*0.45359237) * 1e6d;
-                case MolarMassUnit.MicrogramPerMole: return (_value/1e3) * 1e-6d;
-                case MolarMassUnit.MilligramPerMole: return (_value/1e3) * 1e-3d;
-                case MolarMassUnit.NanogramPerMole: return (_value/1e3) * 1e-9d;
-                case MolarMassUnit.PoundPerMole: return _value*0.45359237;
+                case MolarMassUnit.CentigramPerMole: return (Value/1e3) * 1e-2d;
+                case MolarMassUnit.DecagramPerMole: return (Value/1e3) * 1e1d;
+                case MolarMassUnit.DecigramPerMole: return (Value/1e3) * 1e-1d;
+                case MolarMassUnit.GramPerMole: return Value/1e3;
+                case MolarMassUnit.HectogramPerMole: return (Value/1e3) * 1e2d;
+                case MolarMassUnit.KilogramPerMole: return (Value/1e3) * 1e3d;
+                case MolarMassUnit.KilopoundPerMole: return (Value*0.45359237) * 1e3d;
+                case MolarMassUnit.MegapoundPerMole: return (Value*0.45359237) * 1e6d;
+                case MolarMassUnit.MicrogramPerMole: return (Value/1e3) * 1e-6d;
+                case MolarMassUnit.MilligramPerMole: return (Value/1e3) * 1e-3d;
+                case MolarMassUnit.NanogramPerMole: return (Value/1e3) * 1e-9d;
+                case MolarMassUnit.PoundPerMole: return Value*0.45359237;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -825,16 +825,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal MolarMass ToBaseUnit()
+        internal MolarMass<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new MolarMass(baseUnitValue, BaseUnit);
+            return new MolarMass<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MolarMassUnit unit)
+        private T GetValueAs(MolarMassUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -948,57 +948,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarMass)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarMass<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarMass)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarMass<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(MolarMass)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(MolarMass<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1008,33 +1008,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(MolarMass))
+            if(conversionType == typeof(MolarMass<T>))
                 return this;
             else if(conversionType == typeof(MolarMassUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return MolarMass.QuantityType;
+                return MolarMass<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return MolarMass.Info;
+                return MolarMass<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return MolarMass.BaseDimensions;
+                return MolarMass<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(MolarMass)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(MolarMass<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
index eae1098573..5549be8f04 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Molar_concentration
     /// </remarks>
-    public partial struct Molarity : IQuantity<MolarityUnit>, IEquatable<Molarity>, IComparable, IComparable<Molarity>, IConvertible, IFormattable
+    public partial struct Molarity<T> : IQuantityT<MolarityUnit, T>, IEquatable<Molarity<T>>, IComparable, IComparable<Molarity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -73,12 +69,12 @@ static Molarity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Molarity(double value, MolarityUnit unit)
+        public Molarity(T value, MolarityUnit unit)
         {
             if(unit == MolarityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -90,14 +86,14 @@ public Molarity(double value, MolarityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Molarity(double value, UnitSystem unitSystem)
+        public Molarity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -112,19 +108,19 @@ public Molarity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Molarity, which is MolesPerCubicMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Molarity{T}" />, which is MolesPerCubicMeter. All conversions go via this value.
         /// </summary>
         public static MolarityUnit BaseUnit { get; } = MolarityUnit.MolesPerCubicMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Molarity
+        /// Represents the largest possible value of <see cref="Molarity{T}" />
         /// </summary>
-        public static Molarity MaxValue { get; } = new Molarity(double.MaxValue, BaseUnit);
+        public static Molarity<T> MaxValue { get; } = new Molarity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Molarity
+        /// Represents the smallest possible value of <see cref="Molarity{T}" />
         /// </summary>
-        public static Molarity MinValue { get; } = new Molarity(double.MinValue, BaseUnit);
+        public static Molarity<T> MinValue { get; } = new Molarity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -133,14 +129,14 @@ public Molarity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Molarity;
 
         /// <summary>
-        ///     All units of measurement for the Molarity quantity.
+        ///     All units of measurement for the <see cref="Molarity{T}" /> quantity.
         /// </summary>
         public static MolarityUnit[] Units { get; } = Enum.GetValues(typeof(MolarityUnit)).Cast<MolarityUnit>().Except(new MolarityUnit[]{ MolarityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit MolesPerCubicMeter.
         /// </summary>
-        public static Molarity Zero { get; } = new Molarity(0, BaseUnit);
+        public static Molarity<T> Zero { get; } = new Molarity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -149,7 +145,9 @@ public Molarity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -165,56 +163,56 @@ public Molarity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Molarity.QuantityType;
+        public QuantityType Type => Molarity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Molarity.BaseDimensions;
+        public BaseDimensions Dimensions => Molarity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Molarity in CentimolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> in CentimolesPerLiter.
         /// </summary>
-        public double CentimolesPerLiter => As(MolarityUnit.CentimolesPerLiter);
+        public T CentimolesPerLiter => As(MolarityUnit.CentimolesPerLiter);
 
         /// <summary>
-        ///     Get Molarity in DecimolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> in DecimolesPerLiter.
         /// </summary>
-        public double DecimolesPerLiter => As(MolarityUnit.DecimolesPerLiter);
+        public T DecimolesPerLiter => As(MolarityUnit.DecimolesPerLiter);
 
         /// <summary>
-        ///     Get Molarity in MicromolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> in MicromolesPerLiter.
         /// </summary>
-        public double MicromolesPerLiter => As(MolarityUnit.MicromolesPerLiter);
+        public T MicromolesPerLiter => As(MolarityUnit.MicromolesPerLiter);
 
         /// <summary>
-        ///     Get Molarity in MillimolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> in MillimolesPerLiter.
         /// </summary>
-        public double MillimolesPerLiter => As(MolarityUnit.MillimolesPerLiter);
+        public T MillimolesPerLiter => As(MolarityUnit.MillimolesPerLiter);
 
         /// <summary>
-        ///     Get Molarity in MolesPerCubicMeter.
+        ///     Get <see cref="Molarity{T}" /> in MolesPerCubicMeter.
         /// </summary>
-        public double MolesPerCubicMeter => As(MolarityUnit.MolesPerCubicMeter);
+        public T MolesPerCubicMeter => As(MolarityUnit.MolesPerCubicMeter);
 
         /// <summary>
-        ///     Get Molarity in MolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> in MolesPerLiter.
         /// </summary>
-        public double MolesPerLiter => As(MolarityUnit.MolesPerLiter);
+        public T MolesPerLiter => As(MolarityUnit.MolesPerLiter);
 
         /// <summary>
-        ///     Get Molarity in NanomolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> in NanomolesPerLiter.
         /// </summary>
-        public double NanomolesPerLiter => As(MolarityUnit.NanomolesPerLiter);
+        public T NanomolesPerLiter => As(MolarityUnit.NanomolesPerLiter);
 
         /// <summary>
-        ///     Get Molarity in PicomolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> in PicomolesPerLiter.
         /// </summary>
-        public double PicomolesPerLiter => As(MolarityUnit.PicomolesPerLiter);
+        public T PicomolesPerLiter => As(MolarityUnit.PicomolesPerLiter);
 
         #endregion
 
@@ -246,87 +244,79 @@ public static string GetAbbreviation(MolarityUnit unit, IFormatProvider? provide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Molarity from CentimolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> from CentimolesPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromCentimolesPerLiter(QuantityValue centimolesperliter)
+        public static Molarity<T> FromCentimolesPerLiter(T centimolesperliter)
         {
-            double value = (double) centimolesperliter;
-            return new Molarity(value, MolarityUnit.CentimolesPerLiter);
+            return new Molarity<T>(centimolesperliter, MolarityUnit.CentimolesPerLiter);
         }
         /// <summary>
-        ///     Get Molarity from DecimolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> from DecimolesPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromDecimolesPerLiter(QuantityValue decimolesperliter)
+        public static Molarity<T> FromDecimolesPerLiter(T decimolesperliter)
         {
-            double value = (double) decimolesperliter;
-            return new Molarity(value, MolarityUnit.DecimolesPerLiter);
+            return new Molarity<T>(decimolesperliter, MolarityUnit.DecimolesPerLiter);
         }
         /// <summary>
-        ///     Get Molarity from MicromolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> from MicromolesPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMicromolesPerLiter(QuantityValue micromolesperliter)
+        public static Molarity<T> FromMicromolesPerLiter(T micromolesperliter)
         {
-            double value = (double) micromolesperliter;
-            return new Molarity(value, MolarityUnit.MicromolesPerLiter);
+            return new Molarity<T>(micromolesperliter, MolarityUnit.MicromolesPerLiter);
         }
         /// <summary>
-        ///     Get Molarity from MillimolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> from MillimolesPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMillimolesPerLiter(QuantityValue millimolesperliter)
+        public static Molarity<T> FromMillimolesPerLiter(T millimolesperliter)
         {
-            double value = (double) millimolesperliter;
-            return new Molarity(value, MolarityUnit.MillimolesPerLiter);
+            return new Molarity<T>(millimolesperliter, MolarityUnit.MillimolesPerLiter);
         }
         /// <summary>
-        ///     Get Molarity from MolesPerCubicMeter.
+        ///     Get <see cref="Molarity{T}" /> from MolesPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMolesPerCubicMeter(QuantityValue molespercubicmeter)
+        public static Molarity<T> FromMolesPerCubicMeter(T molespercubicmeter)
         {
-            double value = (double) molespercubicmeter;
-            return new Molarity(value, MolarityUnit.MolesPerCubicMeter);
+            return new Molarity<T>(molespercubicmeter, MolarityUnit.MolesPerCubicMeter);
         }
         /// <summary>
-        ///     Get Molarity from MolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> from MolesPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMolesPerLiter(QuantityValue molesperliter)
+        public static Molarity<T> FromMolesPerLiter(T molesperliter)
         {
-            double value = (double) molesperliter;
-            return new Molarity(value, MolarityUnit.MolesPerLiter);
+            return new Molarity<T>(molesperliter, MolarityUnit.MolesPerLiter);
         }
         /// <summary>
-        ///     Get Molarity from NanomolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> from NanomolesPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromNanomolesPerLiter(QuantityValue nanomolesperliter)
+        public static Molarity<T> FromNanomolesPerLiter(T nanomolesperliter)
         {
-            double value = (double) nanomolesperliter;
-            return new Molarity(value, MolarityUnit.NanomolesPerLiter);
+            return new Molarity<T>(nanomolesperliter, MolarityUnit.NanomolesPerLiter);
         }
         /// <summary>
-        ///     Get Molarity from PicomolesPerLiter.
+        ///     Get <see cref="Molarity{T}" /> from PicomolesPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromPicomolesPerLiter(QuantityValue picomolesperliter)
+        public static Molarity<T> FromPicomolesPerLiter(T picomolesperliter)
         {
-            double value = (double) picomolesperliter;
-            return new Molarity(value, MolarityUnit.PicomolesPerLiter);
+            return new Molarity<T>(picomolesperliter, MolarityUnit.PicomolesPerLiter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarityUnit" /> to <see cref="Molarity" />.
+        ///     Dynamically convert from value and unit enum <see cref="MolarityUnit" /> to <see cref="Molarity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Molarity unit value.</returns>
-        public static Molarity From(QuantityValue value, MolarityUnit fromUnit)
+        /// <returns><see cref="Molarity{T}" /> unit value.</returns>
+        public static Molarity<T> From(T value, MolarityUnit fromUnit)
         {
-            return new Molarity((double)value, fromUnit);
+            return new Molarity<T>(value, fromUnit);
         }
 
         #endregion
@@ -355,7 +345,7 @@ public static Molarity From(QuantityValue value, MolarityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Molarity Parse(string str)
+        public static Molarity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -383,9 +373,9 @@ public static Molarity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Molarity Parse(string str, IFormatProvider? provider)
+        public static Molarity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Molarity, MolarityUnit>(
+            return QuantityParser.Default.Parse<T, Molarity<T>, MolarityUnit>(
                 str,
                 provider,
                 From);
@@ -399,7 +389,7 @@ public static Molarity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Molarity result)
+        public static bool TryParse(string? str, out Molarity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -414,9 +404,9 @@ public static bool TryParse(string? str, out Molarity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Molarity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Molarity<T> result)
         {
-            return QuantityParser.Default.TryParse<Molarity, MolarityUnit>(
+            return QuantityParser.Default.TryParse<T, Molarity<T>, MolarityUnit>(
                 str,
                 provider,
                 From,
@@ -478,45 +468,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Molarity operator -(Molarity right)
+        public static Molarity<T> operator -(Molarity<T> right)
         {
-            return new Molarity(-right.Value, right.Unit);
+            return new Molarity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Molarity"/> from adding two <see cref="Molarity"/>.</summary>
-        public static Molarity operator +(Molarity left, Molarity right)
+        /// <summary>Get <see cref="Molarity{T}"/> from adding two <see cref="Molarity{T}"/>.</summary>
+        public static Molarity<T> operator +(Molarity<T> left, Molarity<T> right)
         {
-            return new Molarity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Molarity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Molarity"/> from subtracting two <see cref="Molarity"/>.</summary>
-        public static Molarity operator -(Molarity left, Molarity right)
+        /// <summary>Get <see cref="Molarity{T}"/> from subtracting two <see cref="Molarity{T}"/>.</summary>
+        public static Molarity<T> operator -(Molarity<T> left, Molarity<T> right)
         {
-            return new Molarity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Molarity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Molarity"/> from multiplying value and <see cref="Molarity"/>.</summary>
-        public static Molarity operator *(double left, Molarity right)
+        /// <summary>Get <see cref="Molarity{T}"/> from multiplying value and <see cref="Molarity{T}"/>.</summary>
+        public static Molarity<T> operator *(T left, Molarity<T> right)
         {
-            return new Molarity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Molarity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Molarity"/> from multiplying value and <see cref="Molarity"/>.</summary>
-        public static Molarity operator *(Molarity left, double right)
+        /// <summary>Get <see cref="Molarity{T}"/> from multiplying value and <see cref="Molarity{T}"/>.</summary>
+        public static Molarity<T> operator *(Molarity<T> left, T right)
         {
-            return new Molarity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Molarity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Molarity"/> from dividing <see cref="Molarity"/> by value.</summary>
-        public static Molarity operator /(Molarity left, double right)
+        /// <summary>Get <see cref="Molarity{T}"/> from dividing <see cref="Molarity{T}"/> by value.</summary>
+        public static Molarity<T> operator /(Molarity<T> left, T right)
         {
-            return new Molarity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Molarity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Molarity"/> by <see cref="Molarity"/>.</summary>
-        public static double operator /(Molarity left, Molarity right)
+        /// <summary>Get ratio value from dividing <see cref="Molarity{T}"/> by <see cref="Molarity{T}"/>.</summary>
+        public static T operator /(Molarity<T> left, Molarity<T> right)
         {
-            return left.MolesPerCubicMeter / right.MolesPerCubicMeter;
+            return CompiledLambdas.Divide(left.MolesPerCubicMeter, right.MolesPerCubicMeter);
         }
 
         #endregion
@@ -524,39 +519,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Molarity left, Molarity right)
+        public static bool operator <=(Molarity<T> left, Molarity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Molarity left, Molarity right)
+        public static bool operator >=(Molarity<T> left, Molarity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Molarity left, Molarity right)
+        public static bool operator <(Molarity<T> left, Molarity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Molarity left, Molarity right)
+        public static bool operator >(Molarity<T> left, Molarity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Molarity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Molarity left, Molarity right)
+        /// <remarks>Consider using <see cref="Equals(Molarity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Molarity<T> left, Molarity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Molarity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Molarity left, Molarity right)
+        /// <remarks>Consider using <see cref="Equals(Molarity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Molarity<T> left, Molarity<T> right)
         {
             return !(left == right);
         }
@@ -565,37 +560,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Molar
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Molarity objMolarity)) throw new ArgumentException("Expected type Molarity.", nameof(obj));
+            if(!(obj is Molarity<T> objMolarity)) throw new ArgumentException("Expected type Molarity.", nameof(obj));
 
             return CompareTo(objMolarity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Molarity other)
+        public int CompareTo(Molarity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Molarity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Molarity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Molarity objMolarity))
+            if(obj is null || !(obj is Molarity<T> objMolarity))
                 return false;
 
             return Equals(objMolarity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Molarity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Molarity other)
+        /// <remarks>Consider using <see cref="Equals(Molarity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Molarity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Molarity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Molarity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -633,21 +628,19 @@ public bool Equals(Molarity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Molarity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Molarity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Molarity.</returns>
+        /// <returns>A hash code for the current <see cref="Molarity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -661,17 +654,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarityUnit unit)
+        public T As(MolarityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -691,17 +684,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is MolarityUnit unitAsMolarityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsMolarityUnit);
+            var asValue = As(unitAsMolarityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<MolarityUnit>.As(MolarityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Molarity to another Molarity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Molarity{T}" /> to another <see cref="Molarity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Molarity with the specified unit.</returns>
-        public Molarity ToUnit(MolarityUnit unit)
+        /// <returns>A <see cref="Molarity{T}" /> with the specified unit.</returns>
+        public Molarity<T> ToUnit(MolarityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Molarity(convertedValue, unit);
+            return new Molarity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -714,7 +712,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Molarity ToUnit(UnitSystem unitSystem)
+        public Molarity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -734,26 +732,32 @@ public Molarity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarityUnit> IQuantity<MolarityUnit>.ToUnit(MolarityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<MolarityUnit, T> IQuantityT<MolarityUnit, T>.ToUnit(MolarityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<MolarityUnit> IQuantity<MolarityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<MolarityUnit, T> IQuantityT<MolarityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case MolarityUnit.CentimolesPerLiter: return (_value/1e-3) * 1e-2d;
-                case MolarityUnit.DecimolesPerLiter: return (_value/1e-3) * 1e-1d;
-                case MolarityUnit.MicromolesPerLiter: return (_value/1e-3) * 1e-6d;
-                case MolarityUnit.MillimolesPerLiter: return (_value/1e-3) * 1e-3d;
-                case MolarityUnit.MolesPerCubicMeter: return _value;
-                case MolarityUnit.MolesPerLiter: return _value/1e-3;
-                case MolarityUnit.NanomolesPerLiter: return (_value/1e-3) * 1e-9d;
-                case MolarityUnit.PicomolesPerLiter: return (_value/1e-3) * 1e-12d;
+                case MolarityUnit.CentimolesPerLiter: return (Value/1e-3) * 1e-2d;
+                case MolarityUnit.DecimolesPerLiter: return (Value/1e-3) * 1e-1d;
+                case MolarityUnit.MicromolesPerLiter: return (Value/1e-3) * 1e-6d;
+                case MolarityUnit.MillimolesPerLiter: return (Value/1e-3) * 1e-3d;
+                case MolarityUnit.MolesPerCubicMeter: return Value;
+                case MolarityUnit.MolesPerLiter: return Value/1e-3;
+                case MolarityUnit.NanomolesPerLiter: return (Value/1e-3) * 1e-9d;
+                case MolarityUnit.PicomolesPerLiter: return (Value/1e-3) * 1e-12d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -764,16 +768,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Molarity ToBaseUnit()
+        internal Molarity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Molarity(baseUnitValue, BaseUnit);
+            return new Molarity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(MolarityUnit unit)
+        private T GetValueAs(MolarityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -883,57 +887,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Molarity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Molarity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Molarity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Molarity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Molarity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Molarity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -943,33 +947,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Molarity))
+            if(conversionType == typeof(Molarity<T>))
                 return this;
             else if(conversionType == typeof(MolarityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Molarity.QuantityType;
+                return Molarity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Molarity.Info;
+                return Molarity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Molarity.BaseDimensions;
+                return Molarity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Molarity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Molarity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
index b08c1634b4..1d04e35bf4 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Permeability_(electromagnetism)
     /// </remarks>
-    public partial struct Permeability : IQuantity<PermeabilityUnit>, IEquatable<Permeability>, IComparable, IComparable<Permeability>, IConvertible, IFormattable
+    public partial struct Permeability<T> : IQuantityT<PermeabilityUnit, T>, IEquatable<Permeability<T>>, IComparable, IComparable<Permeability<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static Permeability()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Permeability(double value, PermeabilityUnit unit)
+        public Permeability(T value, PermeabilityUnit unit)
         {
             if(unit == PermeabilityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public Permeability(double value, PermeabilityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Permeability(double value, UnitSystem unitSystem)
+        public Permeability(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public Permeability(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Permeability, which is HenryPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Permeability{T}" />, which is HenryPerMeter. All conversions go via this value.
         /// </summary>
         public static PermeabilityUnit BaseUnit { get; } = PermeabilityUnit.HenryPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Permeability
+        /// Represents the largest possible value of <see cref="Permeability{T}" />
         /// </summary>
-        public static Permeability MaxValue { get; } = new Permeability(double.MaxValue, BaseUnit);
+        public static Permeability<T> MaxValue { get; } = new Permeability<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Permeability
+        /// Represents the smallest possible value of <see cref="Permeability{T}" />
         /// </summary>
-        public static Permeability MinValue { get; } = new Permeability(double.MinValue, BaseUnit);
+        public static Permeability<T> MinValue { get; } = new Permeability<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public Permeability(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Permeability;
 
         /// <summary>
-        ///     All units of measurement for the Permeability quantity.
+        ///     All units of measurement for the <see cref="Permeability{T}" /> quantity.
         /// </summary>
         public static PermeabilityUnit[] Units { get; } = Enum.GetValues(typeof(PermeabilityUnit)).Cast<PermeabilityUnit>().Except(new PermeabilityUnit[]{ PermeabilityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit HenryPerMeter.
         /// </summary>
-        public static Permeability Zero { get; } = new Permeability(0, BaseUnit);
+        public static Permeability<T> Zero { get; } = new Permeability<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public Permeability(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public Permeability(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Permeability.QuantityType;
+        public QuantityType Type => Permeability<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Permeability.BaseDimensions;
+        public BaseDimensions Dimensions => Permeability<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Permeability in HenriesPerMeter.
+        ///     Get <see cref="Permeability{T}" /> in HenriesPerMeter.
         /// </summary>
-        public double HenriesPerMeter => As(PermeabilityUnit.HenryPerMeter);
+        public T HenriesPerMeter => As(PermeabilityUnit.HenryPerMeter);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(PermeabilityUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Permeability from HenriesPerMeter.
+        ///     Get <see cref="Permeability{T}" /> from HenriesPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Permeability FromHenriesPerMeter(QuantityValue henriespermeter)
+        public static Permeability<T> FromHenriesPerMeter(T henriespermeter)
         {
-            double value = (double) henriespermeter;
-            return new Permeability(value, PermeabilityUnit.HenryPerMeter);
+            return new Permeability<T>(henriespermeter, PermeabilityUnit.HenryPerMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PermeabilityUnit" /> to <see cref="Permeability" />.
+        ///     Dynamically convert from value and unit enum <see cref="PermeabilityUnit" /> to <see cref="Permeability{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Permeability unit value.</returns>
-        public static Permeability From(QuantityValue value, PermeabilityUnit fromUnit)
+        /// <returns><see cref="Permeability{T}" /> unit value.</returns>
+        public static Permeability<T> From(T value, PermeabilityUnit fromUnit)
         {
-            return new Permeability((double)value, fromUnit);
+            return new Permeability<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static Permeability From(QuantityValue value, PermeabilityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Permeability Parse(string str)
+        public static Permeability<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static Permeability Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Permeability Parse(string str, IFormatProvider? provider)
+        public static Permeability<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Permeability, PermeabilityUnit>(
+            return QuantityParser.Default.Parse<T, Permeability<T>, PermeabilityUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static Permeability Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Permeability result)
+        public static bool TryParse(string? str, out Permeability<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out Permeability result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Permeability result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Permeability<T> result)
         {
-            return QuantityParser.Default.TryParse<Permeability, PermeabilityUnit>(
+            return QuantityParser.Default.TryParse<T, Permeability<T>, PermeabilityUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Perme
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Permeability operator -(Permeability right)
+        public static Permeability<T> operator -(Permeability<T> right)
         {
-            return new Permeability(-right.Value, right.Unit);
+            return new Permeability<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Permeability"/> from adding two <see cref="Permeability"/>.</summary>
-        public static Permeability operator +(Permeability left, Permeability right)
+        /// <summary>Get <see cref="Permeability{T}"/> from adding two <see cref="Permeability{T}"/>.</summary>
+        public static Permeability<T> operator +(Permeability<T> left, Permeability<T> right)
         {
-            return new Permeability(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Permeability<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Permeability"/> from subtracting two <see cref="Permeability"/>.</summary>
-        public static Permeability operator -(Permeability left, Permeability right)
+        /// <summary>Get <see cref="Permeability{T}"/> from subtracting two <see cref="Permeability{T}"/>.</summary>
+        public static Permeability<T> operator -(Permeability<T> left, Permeability<T> right)
         {
-            return new Permeability(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Permeability<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Permeability"/> from multiplying value and <see cref="Permeability"/>.</summary>
-        public static Permeability operator *(double left, Permeability right)
+        /// <summary>Get <see cref="Permeability{T}"/> from multiplying value and <see cref="Permeability{T}"/>.</summary>
+        public static Permeability<T> operator *(T left, Permeability<T> right)
         {
-            return new Permeability(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Permeability<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Permeability"/> from multiplying value and <see cref="Permeability"/>.</summary>
-        public static Permeability operator *(Permeability left, double right)
+        /// <summary>Get <see cref="Permeability{T}"/> from multiplying value and <see cref="Permeability{T}"/>.</summary>
+        public static Permeability<T> operator *(Permeability<T> left, T right)
         {
-            return new Permeability(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Permeability<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Permeability"/> from dividing <see cref="Permeability"/> by value.</summary>
-        public static Permeability operator /(Permeability left, double right)
+        /// <summary>Get <see cref="Permeability{T}"/> from dividing <see cref="Permeability{T}"/> by value.</summary>
+        public static Permeability<T> operator /(Permeability<T> left, T right)
         {
-            return new Permeability(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Permeability<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Permeability"/> by <see cref="Permeability"/>.</summary>
-        public static double operator /(Permeability left, Permeability right)
+        /// <summary>Get ratio value from dividing <see cref="Permeability{T}"/> by <see cref="Permeability{T}"/>.</summary>
+        public static T operator /(Permeability<T> left, Permeability<T> right)
         {
-            return left.HenriesPerMeter / right.HenriesPerMeter;
+            return CompiledLambdas.Divide(left.HenriesPerMeter, right.HenriesPerMeter);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Perme
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Permeability left, Permeability right)
+        public static bool operator <=(Permeability<T> left, Permeability<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Permeability left, Permeability right)
+        public static bool operator >=(Permeability<T> left, Permeability<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Permeability left, Permeability right)
+        public static bool operator <(Permeability<T> left, Permeability<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Permeability left, Permeability right)
+        public static bool operator >(Permeability<T> left, Permeability<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Permeability, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Permeability left, Permeability right)
+        /// <remarks>Consider using <see cref="Equals(Permeability{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Permeability<T> left, Permeability<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Permeability, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Permeability left, Permeability right)
+        /// <remarks>Consider using <see cref="Equals(Permeability{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Permeability<T> left, Permeability<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Perme
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Permeability objPermeability)) throw new ArgumentException("Expected type Permeability.", nameof(obj));
+            if(!(obj is Permeability<T> objPermeability)) throw new ArgumentException("Expected type Permeability.", nameof(obj));
 
             return CompareTo(objPermeability);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Permeability other)
+        public int CompareTo(Permeability<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Permeability, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Permeability{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Permeability objPermeability))
+            if(obj is null || !(obj is Permeability<T> objPermeability))
                 return false;
 
             return Equals(objPermeability);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Permeability, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Permeability other)
+        /// <remarks>Consider using <see cref="Equals(Permeability{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Permeability<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Permeability within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Permeability{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(Permeability other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Permeability other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Permeability<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Permeability.</returns>
+        /// <returns>A hash code for the current <see cref="Permeability{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(PermeabilityUnit unit)
+        public T As(PermeabilityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is PermeabilityUnit unitAsPermeabilityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermeabilityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsPermeabilityUnit);
+            var asValue = As(unitAsPermeabilityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<PermeabilityUnit>.As(PermeabilityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Permeability to another Permeability with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Permeability{T}" /> to another <see cref="Permeability{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Permeability with the specified unit.</returns>
-        public Permeability ToUnit(PermeabilityUnit unit)
+        /// <returns>A <see cref="Permeability{T}" /> with the specified unit.</returns>
+        public Permeability<T> ToUnit(PermeabilityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Permeability(convertedValue, unit);
+            return new Permeability<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Permeability ToUnit(UnitSystem unitSystem)
+        public Permeability<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public Permeability ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PermeabilityUnit> IQuantity<PermeabilityUnit>.ToUnit(PermeabilityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<PermeabilityUnit, T> IQuantityT<PermeabilityUnit, T>.ToUnit(PermeabilityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<PermeabilityUnit> IQuantity<PermeabilityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<PermeabilityUnit, T> IQuantityT<PermeabilityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case PermeabilityUnit.HenryPerMeter: return _value;
+                case PermeabilityUnit.HenryPerMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Permeability ToBaseUnit()
+        internal Permeability<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Permeability(baseUnitValue, BaseUnit);
+            return new Permeability<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(PermeabilityUnit unit)
+        private T GetValueAs(PermeabilityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Permeability)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Permeability<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Permeability)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Permeability<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Permeability)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Permeability<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Permeability))
+            if(conversionType == typeof(Permeability<T>))
                 return this;
             else if(conversionType == typeof(PermeabilityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Permeability.QuantityType;
+                return Permeability<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Permeability.Info;
+                return Permeability<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Permeability.BaseDimensions;
+                return Permeability<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Permeability)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Permeability<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
index a9d0f53581..37d6f161db 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Permittivity
     /// </remarks>
-    public partial struct Permittivity : IQuantity<PermittivityUnit>, IEquatable<Permittivity>, IComparable, IComparable<Permittivity>, IConvertible, IFormattable
+    public partial struct Permittivity<T> : IQuantityT<PermittivityUnit, T>, IEquatable<Permittivity<T>>, IComparable, IComparable<Permittivity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static Permittivity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Permittivity(double value, PermittivityUnit unit)
+        public Permittivity(T value, PermittivityUnit unit)
         {
             if(unit == PermittivityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public Permittivity(double value, PermittivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Permittivity(double value, UnitSystem unitSystem)
+        public Permittivity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public Permittivity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Permittivity, which is FaradPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Permittivity{T}" />, which is FaradPerMeter. All conversions go via this value.
         /// </summary>
         public static PermittivityUnit BaseUnit { get; } = PermittivityUnit.FaradPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Permittivity
+        /// Represents the largest possible value of <see cref="Permittivity{T}" />
         /// </summary>
-        public static Permittivity MaxValue { get; } = new Permittivity(double.MaxValue, BaseUnit);
+        public static Permittivity<T> MaxValue { get; } = new Permittivity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Permittivity
+        /// Represents the smallest possible value of <see cref="Permittivity{T}" />
         /// </summary>
-        public static Permittivity MinValue { get; } = new Permittivity(double.MinValue, BaseUnit);
+        public static Permittivity<T> MinValue { get; } = new Permittivity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public Permittivity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Permittivity;
 
         /// <summary>
-        ///     All units of measurement for the Permittivity quantity.
+        ///     All units of measurement for the <see cref="Permittivity{T}" /> quantity.
         /// </summary>
         public static PermittivityUnit[] Units { get; } = Enum.GetValues(typeof(PermittivityUnit)).Cast<PermittivityUnit>().Except(new PermittivityUnit[]{ PermittivityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit FaradPerMeter.
         /// </summary>
-        public static Permittivity Zero { get; } = new Permittivity(0, BaseUnit);
+        public static Permittivity<T> Zero { get; } = new Permittivity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public Permittivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public Permittivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Permittivity.QuantityType;
+        public QuantityType Type => Permittivity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Permittivity.BaseDimensions;
+        public BaseDimensions Dimensions => Permittivity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Permittivity in FaradsPerMeter.
+        ///     Get <see cref="Permittivity{T}" /> in FaradsPerMeter.
         /// </summary>
-        public double FaradsPerMeter => As(PermittivityUnit.FaradPerMeter);
+        public T FaradsPerMeter => As(PermittivityUnit.FaradPerMeter);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(PermittivityUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Permittivity from FaradsPerMeter.
+        ///     Get <see cref="Permittivity{T}" /> from FaradsPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Permittivity FromFaradsPerMeter(QuantityValue faradspermeter)
+        public static Permittivity<T> FromFaradsPerMeter(T faradspermeter)
         {
-            double value = (double) faradspermeter;
-            return new Permittivity(value, PermittivityUnit.FaradPerMeter);
+            return new Permittivity<T>(faradspermeter, PermittivityUnit.FaradPerMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PermittivityUnit" /> to <see cref="Permittivity" />.
+        ///     Dynamically convert from value and unit enum <see cref="PermittivityUnit" /> to <see cref="Permittivity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Permittivity unit value.</returns>
-        public static Permittivity From(QuantityValue value, PermittivityUnit fromUnit)
+        /// <returns><see cref="Permittivity{T}" /> unit value.</returns>
+        public static Permittivity<T> From(T value, PermittivityUnit fromUnit)
         {
-            return new Permittivity((double)value, fromUnit);
+            return new Permittivity<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static Permittivity From(QuantityValue value, PermittivityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Permittivity Parse(string str)
+        public static Permittivity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static Permittivity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Permittivity Parse(string str, IFormatProvider? provider)
+        public static Permittivity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Permittivity, PermittivityUnit>(
+            return QuantityParser.Default.Parse<T, Permittivity<T>, PermittivityUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static Permittivity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Permittivity result)
+        public static bool TryParse(string? str, out Permittivity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out Permittivity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Permittivity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Permittivity<T> result)
         {
-            return QuantityParser.Default.TryParse<Permittivity, PermittivityUnit>(
+            return QuantityParser.Default.TryParse<T, Permittivity<T>, PermittivityUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Permi
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Permittivity operator -(Permittivity right)
+        public static Permittivity<T> operator -(Permittivity<T> right)
         {
-            return new Permittivity(-right.Value, right.Unit);
+            return new Permittivity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Permittivity"/> from adding two <see cref="Permittivity"/>.</summary>
-        public static Permittivity operator +(Permittivity left, Permittivity right)
+        /// <summary>Get <see cref="Permittivity{T}"/> from adding two <see cref="Permittivity{T}"/>.</summary>
+        public static Permittivity<T> operator +(Permittivity<T> left, Permittivity<T> right)
         {
-            return new Permittivity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Permittivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Permittivity"/> from subtracting two <see cref="Permittivity"/>.</summary>
-        public static Permittivity operator -(Permittivity left, Permittivity right)
+        /// <summary>Get <see cref="Permittivity{T}"/> from subtracting two <see cref="Permittivity{T}"/>.</summary>
+        public static Permittivity<T> operator -(Permittivity<T> left, Permittivity<T> right)
         {
-            return new Permittivity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Permittivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Permittivity"/> from multiplying value and <see cref="Permittivity"/>.</summary>
-        public static Permittivity operator *(double left, Permittivity right)
+        /// <summary>Get <see cref="Permittivity{T}"/> from multiplying value and <see cref="Permittivity{T}"/>.</summary>
+        public static Permittivity<T> operator *(T left, Permittivity<T> right)
         {
-            return new Permittivity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Permittivity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Permittivity"/> from multiplying value and <see cref="Permittivity"/>.</summary>
-        public static Permittivity operator *(Permittivity left, double right)
+        /// <summary>Get <see cref="Permittivity{T}"/> from multiplying value and <see cref="Permittivity{T}"/>.</summary>
+        public static Permittivity<T> operator *(Permittivity<T> left, T right)
         {
-            return new Permittivity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Permittivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Permittivity"/> from dividing <see cref="Permittivity"/> by value.</summary>
-        public static Permittivity operator /(Permittivity left, double right)
+        /// <summary>Get <see cref="Permittivity{T}"/> from dividing <see cref="Permittivity{T}"/> by value.</summary>
+        public static Permittivity<T> operator /(Permittivity<T> left, T right)
         {
-            return new Permittivity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Permittivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Permittivity"/> by <see cref="Permittivity"/>.</summary>
-        public static double operator /(Permittivity left, Permittivity right)
+        /// <summary>Get ratio value from dividing <see cref="Permittivity{T}"/> by <see cref="Permittivity{T}"/>.</summary>
+        public static T operator /(Permittivity<T> left, Permittivity<T> right)
         {
-            return left.FaradsPerMeter / right.FaradsPerMeter;
+            return CompiledLambdas.Divide(left.FaradsPerMeter, right.FaradsPerMeter);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Permi
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Permittivity left, Permittivity right)
+        public static bool operator <=(Permittivity<T> left, Permittivity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Permittivity left, Permittivity right)
+        public static bool operator >=(Permittivity<T> left, Permittivity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Permittivity left, Permittivity right)
+        public static bool operator <(Permittivity<T> left, Permittivity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Permittivity left, Permittivity right)
+        public static bool operator >(Permittivity<T> left, Permittivity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Permittivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Permittivity left, Permittivity right)
+        /// <remarks>Consider using <see cref="Equals(Permittivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Permittivity<T> left, Permittivity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Permittivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Permittivity left, Permittivity right)
+        /// <remarks>Consider using <see cref="Equals(Permittivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Permittivity<T> left, Permittivity<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Permi
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Permittivity objPermittivity)) throw new ArgumentException("Expected type Permittivity.", nameof(obj));
+            if(!(obj is Permittivity<T> objPermittivity)) throw new ArgumentException("Expected type Permittivity.", nameof(obj));
 
             return CompareTo(objPermittivity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Permittivity other)
+        public int CompareTo(Permittivity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Permittivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Permittivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Permittivity objPermittivity))
+            if(obj is null || !(obj is Permittivity<T> objPermittivity))
                 return false;
 
             return Equals(objPermittivity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Permittivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Permittivity other)
+        /// <remarks>Consider using <see cref="Equals(Permittivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Permittivity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Permittivity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Permittivity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(Permittivity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Permittivity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Permittivity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Permittivity.</returns>
+        /// <returns>A hash code for the current <see cref="Permittivity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(PermittivityUnit unit)
+        public T As(PermittivityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is PermittivityUnit unitAsPermittivityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermittivityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsPermittivityUnit);
+            var asValue = As(unitAsPermittivityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<PermittivityUnit>.As(PermittivityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Permittivity to another Permittivity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Permittivity{T}" /> to another <see cref="Permittivity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Permittivity with the specified unit.</returns>
-        public Permittivity ToUnit(PermittivityUnit unit)
+        /// <returns>A <see cref="Permittivity{T}" /> with the specified unit.</returns>
+        public Permittivity<T> ToUnit(PermittivityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Permittivity(convertedValue, unit);
+            return new Permittivity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Permittivity ToUnit(UnitSystem unitSystem)
+        public Permittivity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public Permittivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PermittivityUnit> IQuantity<PermittivityUnit>.ToUnit(PermittivityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<PermittivityUnit, T> IQuantityT<PermittivityUnit, T>.ToUnit(PermittivityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<PermittivityUnit> IQuantity<PermittivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<PermittivityUnit, T> IQuantityT<PermittivityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case PermittivityUnit.FaradPerMeter: return _value;
+                case PermittivityUnit.FaradPerMeter: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Permittivity ToBaseUnit()
+        internal Permittivity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Permittivity(baseUnitValue, BaseUnit);
+            return new Permittivity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(PermittivityUnit unit)
+        private T GetValueAs(PermittivityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Permittivity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Permittivity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Permittivity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Permittivity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Permittivity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Permittivity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Permittivity))
+            if(conversionType == typeof(Permittivity<T>))
                 return this;
             else if(conversionType == typeof(PermittivityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Permittivity.QuantityType;
+                return Permittivity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Permittivity.Info;
+                return Permittivity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Permittivity.BaseDimensions;
+                return Permittivity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Permittivity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Permittivity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
index 4919698454..004d299f2a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In physics, power is the rate of doing work. It is equivalent to an amount of energy consumed per unit time.
     /// </summary>
-    public partial struct Power : IQuantity<PowerUnit>, IDecimalQuantity, IEquatable<Power>, IComparable, IComparable<Power>, IConvertible, IFormattable
+    public partial struct Power<T> : IQuantityT<PowerUnit, T>, IDecimalQuantity, IEquatable<Power<T>>, IComparable, IComparable<Power<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly decimal _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -87,12 +83,12 @@ static Power()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Power(decimal value, PowerUnit unit)
+        public Power(T value, PowerUnit unit)
         {
             if(unit == PowerUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = value;
+            Value = value;
             _unit = unit;
         }
 
@@ -104,14 +100,14 @@ public Power(decimal value, PowerUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Power(decimal value, UnitSystem unitSystem)
+        public Power(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = value;
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -126,19 +122,19 @@ public Power(decimal value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Power, which is Watt. All conversions go via this value.
+        ///     The base unit of <see cref="Power{T}" />, which is Watt. All conversions go via this value.
         /// </summary>
         public static PowerUnit BaseUnit { get; } = PowerUnit.Watt;
 
         /// <summary>
-        /// Represents the largest possible value of Power
+        /// Represents the largest possible value of <see cref="Power{T}" />
         /// </summary>
-        public static Power MaxValue { get; } = new Power(decimal.MaxValue, BaseUnit);
+        public static Power<T> MaxValue { get; } = new Power<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Power
+        /// Represents the smallest possible value of <see cref="Power{T}" />
         /// </summary>
-        public static Power MinValue { get; } = new Power(decimal.MinValue, BaseUnit);
+        public static Power<T> MinValue { get; } = new Power<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -147,14 +143,14 @@ public Power(decimal value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Power;
 
         /// <summary>
-        ///     All units of measurement for the Power quantity.
+        ///     All units of measurement for the <see cref="Power{T}" /> quantity.
         /// </summary>
         public static PowerUnit[] Units { get; } = Enum.GetValues(typeof(PowerUnit)).Cast<PowerUnit>().Except(new PowerUnit[]{ PowerUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Watt.
         /// </summary>
-        public static Power Zero { get; } = new Power(0, BaseUnit);
+        public static Power<T> Zero { get; } = new Power<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -163,9 +159,9 @@ public Power(decimal value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public decimal Value => _value;
+        public T Value{ get; }
 
-        double IQuantity.Value => (double) _value;
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         /// <inheritdoc cref="IDecimalQuantity.Value"/>
         decimal IDecimalQuantity.Value => _value;
@@ -184,141 +180,141 @@ public Power(decimal value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Power.QuantityType;
+        public QuantityType Type => Power<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Power.BaseDimensions;
+        public BaseDimensions Dimensions => Power<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Power in BoilerHorsepower.
+        ///     Get <see cref="Power{T}" /> in BoilerHorsepower.
         /// </summary>
-        public double BoilerHorsepower => As(PowerUnit.BoilerHorsepower);
+        public T BoilerHorsepower => As(PowerUnit.BoilerHorsepower);
 
         /// <summary>
-        ///     Get Power in BritishThermalUnitsPerHour.
+        ///     Get <see cref="Power{T}" /> in BritishThermalUnitsPerHour.
         /// </summary>
-        public double BritishThermalUnitsPerHour => As(PowerUnit.BritishThermalUnitPerHour);
+        public T BritishThermalUnitsPerHour => As(PowerUnit.BritishThermalUnitPerHour);
 
         /// <summary>
-        ///     Get Power in Decawatts.
+        ///     Get <see cref="Power{T}" /> in Decawatts.
         /// </summary>
-        public double Decawatts => As(PowerUnit.Decawatt);
+        public T Decawatts => As(PowerUnit.Decawatt);
 
         /// <summary>
-        ///     Get Power in Deciwatts.
+        ///     Get <see cref="Power{T}" /> in Deciwatts.
         /// </summary>
-        public double Deciwatts => As(PowerUnit.Deciwatt);
+        public T Deciwatts => As(PowerUnit.Deciwatt);
 
         /// <summary>
-        ///     Get Power in ElectricalHorsepower.
+        ///     Get <see cref="Power{T}" /> in ElectricalHorsepower.
         /// </summary>
-        public double ElectricalHorsepower => As(PowerUnit.ElectricalHorsepower);
+        public T ElectricalHorsepower => As(PowerUnit.ElectricalHorsepower);
 
         /// <summary>
-        ///     Get Power in Femtowatts.
+        ///     Get <see cref="Power{T}" /> in Femtowatts.
         /// </summary>
-        public double Femtowatts => As(PowerUnit.Femtowatt);
+        public T Femtowatts => As(PowerUnit.Femtowatt);
 
         /// <summary>
-        ///     Get Power in GigajoulesPerHour.
+        ///     Get <see cref="Power{T}" /> in GigajoulesPerHour.
         /// </summary>
-        public double GigajoulesPerHour => As(PowerUnit.GigajoulePerHour);
+        public T GigajoulesPerHour => As(PowerUnit.GigajoulePerHour);
 
         /// <summary>
-        ///     Get Power in Gigawatts.
+        ///     Get <see cref="Power{T}" /> in Gigawatts.
         /// </summary>
-        public double Gigawatts => As(PowerUnit.Gigawatt);
+        public T Gigawatts => As(PowerUnit.Gigawatt);
 
         /// <summary>
-        ///     Get Power in HydraulicHorsepower.
+        ///     Get <see cref="Power{T}" /> in HydraulicHorsepower.
         /// </summary>
-        public double HydraulicHorsepower => As(PowerUnit.HydraulicHorsepower);
+        public T HydraulicHorsepower => As(PowerUnit.HydraulicHorsepower);
 
         /// <summary>
-        ///     Get Power in JoulesPerHour.
+        ///     Get <see cref="Power{T}" /> in JoulesPerHour.
         /// </summary>
-        public double JoulesPerHour => As(PowerUnit.JoulePerHour);
+        public T JoulesPerHour => As(PowerUnit.JoulePerHour);
 
         /// <summary>
-        ///     Get Power in KilobritishThermalUnitsPerHour.
+        ///     Get <see cref="Power{T}" /> in KilobritishThermalUnitsPerHour.
         /// </summary>
-        public double KilobritishThermalUnitsPerHour => As(PowerUnit.KilobritishThermalUnitPerHour);
+        public T KilobritishThermalUnitsPerHour => As(PowerUnit.KilobritishThermalUnitPerHour);
 
         /// <summary>
-        ///     Get Power in KilojoulesPerHour.
+        ///     Get <see cref="Power{T}" /> in KilojoulesPerHour.
         /// </summary>
-        public double KilojoulesPerHour => As(PowerUnit.KilojoulePerHour);
+        public T KilojoulesPerHour => As(PowerUnit.KilojoulePerHour);
 
         /// <summary>
-        ///     Get Power in Kilowatts.
+        ///     Get <see cref="Power{T}" /> in Kilowatts.
         /// </summary>
-        public double Kilowatts => As(PowerUnit.Kilowatt);
+        public T Kilowatts => As(PowerUnit.Kilowatt);
 
         /// <summary>
-        ///     Get Power in MechanicalHorsepower.
+        ///     Get <see cref="Power{T}" /> in MechanicalHorsepower.
         /// </summary>
-        public double MechanicalHorsepower => As(PowerUnit.MechanicalHorsepower);
+        public T MechanicalHorsepower => As(PowerUnit.MechanicalHorsepower);
 
         /// <summary>
-        ///     Get Power in MegajoulesPerHour.
+        ///     Get <see cref="Power{T}" /> in MegajoulesPerHour.
         /// </summary>
-        public double MegajoulesPerHour => As(PowerUnit.MegajoulePerHour);
+        public T MegajoulesPerHour => As(PowerUnit.MegajoulePerHour);
 
         /// <summary>
-        ///     Get Power in Megawatts.
+        ///     Get <see cref="Power{T}" /> in Megawatts.
         /// </summary>
-        public double Megawatts => As(PowerUnit.Megawatt);
+        public T Megawatts => As(PowerUnit.Megawatt);
 
         /// <summary>
-        ///     Get Power in MetricHorsepower.
+        ///     Get <see cref="Power{T}" /> in MetricHorsepower.
         /// </summary>
-        public double MetricHorsepower => As(PowerUnit.MetricHorsepower);
+        public T MetricHorsepower => As(PowerUnit.MetricHorsepower);
 
         /// <summary>
-        ///     Get Power in Microwatts.
+        ///     Get <see cref="Power{T}" /> in Microwatts.
         /// </summary>
-        public double Microwatts => As(PowerUnit.Microwatt);
+        public T Microwatts => As(PowerUnit.Microwatt);
 
         /// <summary>
-        ///     Get Power in MillijoulesPerHour.
+        ///     Get <see cref="Power{T}" /> in MillijoulesPerHour.
         /// </summary>
-        public double MillijoulesPerHour => As(PowerUnit.MillijoulePerHour);
+        public T MillijoulesPerHour => As(PowerUnit.MillijoulePerHour);
 
         /// <summary>
-        ///     Get Power in Milliwatts.
+        ///     Get <see cref="Power{T}" /> in Milliwatts.
         /// </summary>
-        public double Milliwatts => As(PowerUnit.Milliwatt);
+        public T Milliwatts => As(PowerUnit.Milliwatt);
 
         /// <summary>
-        ///     Get Power in Nanowatts.
+        ///     Get <see cref="Power{T}" /> in Nanowatts.
         /// </summary>
-        public double Nanowatts => As(PowerUnit.Nanowatt);
+        public T Nanowatts => As(PowerUnit.Nanowatt);
 
         /// <summary>
-        ///     Get Power in Petawatts.
+        ///     Get <see cref="Power{T}" /> in Petawatts.
         /// </summary>
-        public double Petawatts => As(PowerUnit.Petawatt);
+        public T Petawatts => As(PowerUnit.Petawatt);
 
         /// <summary>
-        ///     Get Power in Picowatts.
+        ///     Get <see cref="Power{T}" /> in Picowatts.
         /// </summary>
-        public double Picowatts => As(PowerUnit.Picowatt);
+        public T Picowatts => As(PowerUnit.Picowatt);
 
         /// <summary>
-        ///     Get Power in Terawatts.
+        ///     Get <see cref="Power{T}" /> in Terawatts.
         /// </summary>
-        public double Terawatts => As(PowerUnit.Terawatt);
+        public T Terawatts => As(PowerUnit.Terawatt);
 
         /// <summary>
-        ///     Get Power in Watts.
+        ///     Get <see cref="Power{T}" /> in Watts.
         /// </summary>
-        public double Watts => As(PowerUnit.Watt);
+        public T Watts => As(PowerUnit.Watt);
 
         #endregion
 
@@ -350,240 +346,215 @@ public static string GetAbbreviation(PowerUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Power from BoilerHorsepower.
+        ///     Get <see cref="Power{T}" /> from BoilerHorsepower.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromBoilerHorsepower(QuantityValue boilerhorsepower)
+        public static Power<T> FromBoilerHorsepower(T boilerhorsepower)
         {
-            decimal value = (decimal) boilerhorsepower;
-            return new Power(value, PowerUnit.BoilerHorsepower);
+            return new Power<T>(boilerhorsepower, PowerUnit.BoilerHorsepower);
         }
         /// <summary>
-        ///     Get Power from BritishThermalUnitsPerHour.
+        ///     Get <see cref="Power{T}" /> from BritishThermalUnitsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromBritishThermalUnitsPerHour(QuantityValue britishthermalunitsperhour)
+        public static Power<T> FromBritishThermalUnitsPerHour(T britishthermalunitsperhour)
         {
-            decimal value = (decimal) britishthermalunitsperhour;
-            return new Power(value, PowerUnit.BritishThermalUnitPerHour);
+            return new Power<T>(britishthermalunitsperhour, PowerUnit.BritishThermalUnitPerHour);
         }
         /// <summary>
-        ///     Get Power from Decawatts.
+        ///     Get <see cref="Power{T}" /> from Decawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromDecawatts(QuantityValue decawatts)
+        public static Power<T> FromDecawatts(T decawatts)
         {
-            decimal value = (decimal) decawatts;
-            return new Power(value, PowerUnit.Decawatt);
+            return new Power<T>(decawatts, PowerUnit.Decawatt);
         }
         /// <summary>
-        ///     Get Power from Deciwatts.
+        ///     Get <see cref="Power{T}" /> from Deciwatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromDeciwatts(QuantityValue deciwatts)
+        public static Power<T> FromDeciwatts(T deciwatts)
         {
-            decimal value = (decimal) deciwatts;
-            return new Power(value, PowerUnit.Deciwatt);
+            return new Power<T>(deciwatts, PowerUnit.Deciwatt);
         }
         /// <summary>
-        ///     Get Power from ElectricalHorsepower.
+        ///     Get <see cref="Power{T}" /> from ElectricalHorsepower.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromElectricalHorsepower(QuantityValue electricalhorsepower)
+        public static Power<T> FromElectricalHorsepower(T electricalhorsepower)
         {
-            decimal value = (decimal) electricalhorsepower;
-            return new Power(value, PowerUnit.ElectricalHorsepower);
+            return new Power<T>(electricalhorsepower, PowerUnit.ElectricalHorsepower);
         }
         /// <summary>
-        ///     Get Power from Femtowatts.
+        ///     Get <see cref="Power{T}" /> from Femtowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromFemtowatts(QuantityValue femtowatts)
+        public static Power<T> FromFemtowatts(T femtowatts)
         {
-            decimal value = (decimal) femtowatts;
-            return new Power(value, PowerUnit.Femtowatt);
+            return new Power<T>(femtowatts, PowerUnit.Femtowatt);
         }
         /// <summary>
-        ///     Get Power from GigajoulesPerHour.
+        ///     Get <see cref="Power{T}" /> from GigajoulesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromGigajoulesPerHour(QuantityValue gigajoulesperhour)
+        public static Power<T> FromGigajoulesPerHour(T gigajoulesperhour)
         {
-            decimal value = (decimal) gigajoulesperhour;
-            return new Power(value, PowerUnit.GigajoulePerHour);
+            return new Power<T>(gigajoulesperhour, PowerUnit.GigajoulePerHour);
         }
         /// <summary>
-        ///     Get Power from Gigawatts.
+        ///     Get <see cref="Power{T}" /> from Gigawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromGigawatts(QuantityValue gigawatts)
+        public static Power<T> FromGigawatts(T gigawatts)
         {
-            decimal value = (decimal) gigawatts;
-            return new Power(value, PowerUnit.Gigawatt);
+            return new Power<T>(gigawatts, PowerUnit.Gigawatt);
         }
         /// <summary>
-        ///     Get Power from HydraulicHorsepower.
+        ///     Get <see cref="Power{T}" /> from HydraulicHorsepower.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromHydraulicHorsepower(QuantityValue hydraulichorsepower)
+        public static Power<T> FromHydraulicHorsepower(T hydraulichorsepower)
         {
-            decimal value = (decimal) hydraulichorsepower;
-            return new Power(value, PowerUnit.HydraulicHorsepower);
+            return new Power<T>(hydraulichorsepower, PowerUnit.HydraulicHorsepower);
         }
         /// <summary>
-        ///     Get Power from JoulesPerHour.
+        ///     Get <see cref="Power{T}" /> from JoulesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromJoulesPerHour(QuantityValue joulesperhour)
+        public static Power<T> FromJoulesPerHour(T joulesperhour)
         {
-            decimal value = (decimal) joulesperhour;
-            return new Power(value, PowerUnit.JoulePerHour);
+            return new Power<T>(joulesperhour, PowerUnit.JoulePerHour);
         }
         /// <summary>
-        ///     Get Power from KilobritishThermalUnitsPerHour.
+        ///     Get <see cref="Power{T}" /> from KilobritishThermalUnitsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilobritishThermalUnitsPerHour(QuantityValue kilobritishthermalunitsperhour)
+        public static Power<T> FromKilobritishThermalUnitsPerHour(T kilobritishthermalunitsperhour)
         {
-            decimal value = (decimal) kilobritishthermalunitsperhour;
-            return new Power(value, PowerUnit.KilobritishThermalUnitPerHour);
+            return new Power<T>(kilobritishthermalunitsperhour, PowerUnit.KilobritishThermalUnitPerHour);
         }
         /// <summary>
-        ///     Get Power from KilojoulesPerHour.
+        ///     Get <see cref="Power{T}" /> from KilojoulesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilojoulesPerHour(QuantityValue kilojoulesperhour)
+        public static Power<T> FromKilojoulesPerHour(T kilojoulesperhour)
         {
-            decimal value = (decimal) kilojoulesperhour;
-            return new Power(value, PowerUnit.KilojoulePerHour);
+            return new Power<T>(kilojoulesperhour, PowerUnit.KilojoulePerHour);
         }
         /// <summary>
-        ///     Get Power from Kilowatts.
+        ///     Get <see cref="Power{T}" /> from Kilowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilowatts(QuantityValue kilowatts)
+        public static Power<T> FromKilowatts(T kilowatts)
         {
-            decimal value = (decimal) kilowatts;
-            return new Power(value, PowerUnit.Kilowatt);
+            return new Power<T>(kilowatts, PowerUnit.Kilowatt);
         }
         /// <summary>
-        ///     Get Power from MechanicalHorsepower.
+        ///     Get <see cref="Power{T}" /> from MechanicalHorsepower.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMechanicalHorsepower(QuantityValue mechanicalhorsepower)
+        public static Power<T> FromMechanicalHorsepower(T mechanicalhorsepower)
         {
-            decimal value = (decimal) mechanicalhorsepower;
-            return new Power(value, PowerUnit.MechanicalHorsepower);
+            return new Power<T>(mechanicalhorsepower, PowerUnit.MechanicalHorsepower);
         }
         /// <summary>
-        ///     Get Power from MegajoulesPerHour.
+        ///     Get <see cref="Power{T}" /> from MegajoulesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegajoulesPerHour(QuantityValue megajoulesperhour)
+        public static Power<T> FromMegajoulesPerHour(T megajoulesperhour)
         {
-            decimal value = (decimal) megajoulesperhour;
-            return new Power(value, PowerUnit.MegajoulePerHour);
+            return new Power<T>(megajoulesperhour, PowerUnit.MegajoulePerHour);
         }
         /// <summary>
-        ///     Get Power from Megawatts.
+        ///     Get <see cref="Power{T}" /> from Megawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegawatts(QuantityValue megawatts)
+        public static Power<T> FromMegawatts(T megawatts)
         {
-            decimal value = (decimal) megawatts;
-            return new Power(value, PowerUnit.Megawatt);
+            return new Power<T>(megawatts, PowerUnit.Megawatt);
         }
         /// <summary>
-        ///     Get Power from MetricHorsepower.
+        ///     Get <see cref="Power{T}" /> from MetricHorsepower.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMetricHorsepower(QuantityValue metrichorsepower)
+        public static Power<T> FromMetricHorsepower(T metrichorsepower)
         {
-            decimal value = (decimal) metrichorsepower;
-            return new Power(value, PowerUnit.MetricHorsepower);
+            return new Power<T>(metrichorsepower, PowerUnit.MetricHorsepower);
         }
         /// <summary>
-        ///     Get Power from Microwatts.
+        ///     Get <see cref="Power{T}" /> from Microwatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMicrowatts(QuantityValue microwatts)
+        public static Power<T> FromMicrowatts(T microwatts)
         {
-            decimal value = (decimal) microwatts;
-            return new Power(value, PowerUnit.Microwatt);
+            return new Power<T>(microwatts, PowerUnit.Microwatt);
         }
         /// <summary>
-        ///     Get Power from MillijoulesPerHour.
+        ///     Get <see cref="Power{T}" /> from MillijoulesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMillijoulesPerHour(QuantityValue millijoulesperhour)
+        public static Power<T> FromMillijoulesPerHour(T millijoulesperhour)
         {
-            decimal value = (decimal) millijoulesperhour;
-            return new Power(value, PowerUnit.MillijoulePerHour);
+            return new Power<T>(millijoulesperhour, PowerUnit.MillijoulePerHour);
         }
         /// <summary>
-        ///     Get Power from Milliwatts.
+        ///     Get <see cref="Power{T}" /> from Milliwatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMilliwatts(QuantityValue milliwatts)
+        public static Power<T> FromMilliwatts(T milliwatts)
         {
-            decimal value = (decimal) milliwatts;
-            return new Power(value, PowerUnit.Milliwatt);
+            return new Power<T>(milliwatts, PowerUnit.Milliwatt);
         }
         /// <summary>
-        ///     Get Power from Nanowatts.
+        ///     Get <see cref="Power{T}" /> from Nanowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromNanowatts(QuantityValue nanowatts)
+        public static Power<T> FromNanowatts(T nanowatts)
         {
-            decimal value = (decimal) nanowatts;
-            return new Power(value, PowerUnit.Nanowatt);
+            return new Power<T>(nanowatts, PowerUnit.Nanowatt);
         }
         /// <summary>
-        ///     Get Power from Petawatts.
+        ///     Get <see cref="Power{T}" /> from Petawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromPetawatts(QuantityValue petawatts)
+        public static Power<T> FromPetawatts(T petawatts)
         {
-            decimal value = (decimal) petawatts;
-            return new Power(value, PowerUnit.Petawatt);
+            return new Power<T>(petawatts, PowerUnit.Petawatt);
         }
         /// <summary>
-        ///     Get Power from Picowatts.
+        ///     Get <see cref="Power{T}" /> from Picowatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromPicowatts(QuantityValue picowatts)
+        public static Power<T> FromPicowatts(T picowatts)
         {
-            decimal value = (decimal) picowatts;
-            return new Power(value, PowerUnit.Picowatt);
+            return new Power<T>(picowatts, PowerUnit.Picowatt);
         }
         /// <summary>
-        ///     Get Power from Terawatts.
+        ///     Get <see cref="Power{T}" /> from Terawatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromTerawatts(QuantityValue terawatts)
+        public static Power<T> FromTerawatts(T terawatts)
         {
-            decimal value = (decimal) terawatts;
-            return new Power(value, PowerUnit.Terawatt);
+            return new Power<T>(terawatts, PowerUnit.Terawatt);
         }
         /// <summary>
-        ///     Get Power from Watts.
+        ///     Get <see cref="Power{T}" /> from Watts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromWatts(QuantityValue watts)
+        public static Power<T> FromWatts(T watts)
         {
-            decimal value = (decimal) watts;
-            return new Power(value, PowerUnit.Watt);
+            return new Power<T>(watts, PowerUnit.Watt);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PowerUnit" /> to <see cref="Power" />.
+        ///     Dynamically convert from value and unit enum <see cref="PowerUnit" /> to <see cref="Power{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Power unit value.</returns>
-        public static Power From(QuantityValue value, PowerUnit fromUnit)
+        /// <returns><see cref="Power{T}" /> unit value.</returns>
+        public static Power<T> From(T value, PowerUnit fromUnit)
         {
-            return new Power((decimal)value, fromUnit);
+            return new Power<T>(value, fromUnit);
         }
 
         #endregion
@@ -612,7 +583,7 @@ public static Power From(QuantityValue value, PowerUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Power Parse(string str)
+        public static Power<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -640,9 +611,9 @@ public static Power Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Power Parse(string str, IFormatProvider? provider)
+        public static Power<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Power, PowerUnit>(
+            return QuantityParser.Default.Parse<T, Power<T>, PowerUnit>(
                 str,
                 provider,
                 From);
@@ -656,7 +627,7 @@ public static Power Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Power result)
+        public static bool TryParse(string? str, out Power<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -671,9 +642,9 @@ public static bool TryParse(string? str, out Power result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Power result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Power<T> result)
         {
-            return QuantityParser.Default.TryParse<Power, PowerUnit>(
+            return QuantityParser.Default.TryParse<T, Power<T>, PowerUnit>(
                 str,
                 provider,
                 From,
@@ -735,45 +706,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Power operator -(Power right)
+        public static Power<T> operator -(Power<T> right)
         {
-            return new Power(-right.Value, right.Unit);
+            return new Power<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Power"/> from adding two <see cref="Power"/>.</summary>
-        public static Power operator +(Power left, Power right)
+        /// <summary>Get <see cref="Power{T}"/> from adding two <see cref="Power{T}"/>.</summary>
+        public static Power<T> operator +(Power<T> left, Power<T> right)
         {
-            return new Power(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Power<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Power"/> from subtracting two <see cref="Power"/>.</summary>
-        public static Power operator -(Power left, Power right)
+        /// <summary>Get <see cref="Power{T}"/> from subtracting two <see cref="Power{T}"/>.</summary>
+        public static Power<T> operator -(Power<T> left, Power<T> right)
         {
-            return new Power(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Power<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Power"/> from multiplying value and <see cref="Power"/>.</summary>
-        public static Power operator *(decimal left, Power right)
+        /// <summary>Get <see cref="Power{T}"/> from multiplying value and <see cref="Power{T}"/>.</summary>
+        public static Power<T> operator *(T left, Power<T> right)
         {
-            return new Power(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Power<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Power"/> from multiplying value and <see cref="Power"/>.</summary>
-        public static Power operator *(Power left, decimal right)
+        /// <summary>Get <see cref="Power{T}"/> from multiplying value and <see cref="Power{T}"/>.</summary>
+        public static Power<T> operator *(Power<T> left, T right)
         {
-            return new Power(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Power<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Power"/> from dividing <see cref="Power"/> by value.</summary>
-        public static Power operator /(Power left, decimal right)
+        /// <summary>Get <see cref="Power{T}"/> from dividing <see cref="Power{T}"/> by value.</summary>
+        public static Power<T> operator /(Power<T> left, T right)
         {
-            return new Power(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Power<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Power"/> by <see cref="Power"/>.</summary>
-        public static double operator /(Power left, Power right)
+        /// <summary>Get ratio value from dividing <see cref="Power{T}"/> by <see cref="Power{T}"/>.</summary>
+        public static T operator /(Power<T> left, Power<T> right)
         {
-            return left.Watts / right.Watts;
+            return CompiledLambdas.Divide(left.Watts, right.Watts);
         }
 
         #endregion
@@ -781,39 +757,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Power left, Power right)
+        public static bool operator <=(Power<T> left, Power<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Power left, Power right)
+        public static bool operator >=(Power<T> left, Power<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Power left, Power right)
+        public static bool operator <(Power<T> left, Power<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Power left, Power right)
+        public static bool operator >(Power<T> left, Power<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Power, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Power left, Power right)
+        /// <remarks>Consider using <see cref="Equals(Power{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Power<T> left, Power<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Power, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Power left, Power right)
+        /// <remarks>Consider using <see cref="Equals(Power{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Power<T> left, Power<T> right)
         {
             return !(left == right);
         }
@@ -822,37 +798,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Power objPower)) throw new ArgumentException("Expected type Power.", nameof(obj));
+            if(!(obj is Power<T> objPower)) throw new ArgumentException("Expected type Power.", nameof(obj));
 
             return CompareTo(objPower);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Power other)
+        public int CompareTo(Power<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Power, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Power{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Power objPower))
+            if(obj is null || !(obj is Power<T> objPower))
                 return false;
 
             return Equals(objPower);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Power, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Power other)
+        /// <remarks>Consider using <see cref="Equals(Power{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Power<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Power within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Power{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -890,21 +866,19 @@ public bool Equals(Power other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Power other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Power<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Power.</returns>
+        /// <returns>A hash code for the current <see cref="Power{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -918,17 +892,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(PowerUnit unit)
+        public T As(PowerUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -948,17 +922,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is PowerUnit unitAsPowerUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerUnit)} is supported.", nameof(unit));
 
-            return As(unitAsPowerUnit);
+            var asValue = As(unitAsPowerUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<PowerUnit>.As(PowerUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Power to another Power with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Power{T}" /> to another <see cref="Power{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Power with the specified unit.</returns>
-        public Power ToUnit(PowerUnit unit)
+        /// <returns>A <see cref="Power{T}" /> with the specified unit.</returns>
+        public Power<T> ToUnit(PowerUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Power(convertedValue, unit);
+            return new Power<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -971,7 +950,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Power ToUnit(UnitSystem unitSystem)
+        public Power<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -991,43 +970,49 @@ public Power ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PowerUnit> IQuantity<PowerUnit>.ToUnit(PowerUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<PowerUnit, T> IQuantityT<PowerUnit, T>.ToUnit(PowerUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<PowerUnit> IQuantity<PowerUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<PowerUnit, T> IQuantityT<PowerUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private decimal GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case PowerUnit.BoilerHorsepower: return _value*9812.5m;
-                case PowerUnit.BritishThermalUnitPerHour: return _value*0.293071m;
-                case PowerUnit.Decawatt: return (_value) * 1e1m;
-                case PowerUnit.Deciwatt: return (_value) * 1e-1m;
-                case PowerUnit.ElectricalHorsepower: return _value*746m;
-                case PowerUnit.Femtowatt: return (_value) * 1e-15m;
-                case PowerUnit.GigajoulePerHour: return (_value/3600m) * 1e9m;
-                case PowerUnit.Gigawatt: return (_value) * 1e9m;
-                case PowerUnit.HydraulicHorsepower: return _value*745.69988145m;
-                case PowerUnit.JoulePerHour: return _value/3600m;
-                case PowerUnit.KilobritishThermalUnitPerHour: return (_value*0.293071m) * 1e3m;
-                case PowerUnit.KilojoulePerHour: return (_value/3600m) * 1e3m;
-                case PowerUnit.Kilowatt: return (_value) * 1e3m;
-                case PowerUnit.MechanicalHorsepower: return _value*745.69m;
-                case PowerUnit.MegajoulePerHour: return (_value/3600m) * 1e6m;
-                case PowerUnit.Megawatt: return (_value) * 1e6m;
-                case PowerUnit.MetricHorsepower: return _value*735.49875m;
-                case PowerUnit.Microwatt: return (_value) * 1e-6m;
-                case PowerUnit.MillijoulePerHour: return (_value/3600m) * 1e-3m;
-                case PowerUnit.Milliwatt: return (_value) * 1e-3m;
-                case PowerUnit.Nanowatt: return (_value) * 1e-9m;
-                case PowerUnit.Petawatt: return (_value) * 1e15m;
-                case PowerUnit.Picowatt: return (_value) * 1e-12m;
-                case PowerUnit.Terawatt: return (_value) * 1e12m;
-                case PowerUnit.Watt: return _value;
+                case PowerUnit.BoilerHorsepower: return Value*9812.5m;
+                case PowerUnit.BritishThermalUnitPerHour: return Value*0.293071m;
+                case PowerUnit.Decawatt: return (Value) * 1e1m;
+                case PowerUnit.Deciwatt: return (Value) * 1e-1m;
+                case PowerUnit.ElectricalHorsepower: return Value*746m;
+                case PowerUnit.Femtowatt: return (Value) * 1e-15m;
+                case PowerUnit.GigajoulePerHour: return (Value/3600m) * 1e9m;
+                case PowerUnit.Gigawatt: return (Value) * 1e9m;
+                case PowerUnit.HydraulicHorsepower: return Value*745.69988145m;
+                case PowerUnit.JoulePerHour: return Value/3600m;
+                case PowerUnit.KilobritishThermalUnitPerHour: return (Value*0.293071m) * 1e3m;
+                case PowerUnit.KilojoulePerHour: return (Value/3600m) * 1e3m;
+                case PowerUnit.Kilowatt: return (Value) * 1e3m;
+                case PowerUnit.MechanicalHorsepower: return Value*745.69m;
+                case PowerUnit.MegajoulePerHour: return (Value/3600m) * 1e6m;
+                case PowerUnit.Megawatt: return (Value) * 1e6m;
+                case PowerUnit.MetricHorsepower: return Value*735.49875m;
+                case PowerUnit.Microwatt: return (Value) * 1e-6m;
+                case PowerUnit.MillijoulePerHour: return (Value/3600m) * 1e-3m;
+                case PowerUnit.Milliwatt: return (Value) * 1e-3m;
+                case PowerUnit.Nanowatt: return (Value) * 1e-9m;
+                case PowerUnit.Petawatt: return (Value) * 1e15m;
+                case PowerUnit.Picowatt: return (Value) * 1e-12m;
+                case PowerUnit.Terawatt: return (Value) * 1e12m;
+                case PowerUnit.Watt: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1038,16 +1023,16 @@ private decimal GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Power ToBaseUnit()
+        internal Power<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Power(baseUnitValue, BaseUnit);
+            return new Power<T>(baseUnitValue, BaseUnit);
         }
 
-        private decimal GetValueAs(PowerUnit unit)
+        private T GetValueAs(PowerUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1174,57 +1159,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Power)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Power<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Power)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Power<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Power)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Power<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1234,33 +1219,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Power))
+            if(conversionType == typeof(Power<T>))
                 return this;
             else if(conversionType == typeof(PowerUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Power.QuantityType;
+                return Power<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Power.Info;
+                return Power<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Power.BaseDimensions;
+                return Power<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Power)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Power<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
index 55350574ad..162fef2295 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The amount of power in a volume.
     /// </summary>
-    public partial struct PowerDensity : IQuantity<PowerDensityUnit>, IEquatable<PowerDensity>, IComparable, IComparable<PowerDensity>, IConvertible, IFormattable
+    public partial struct PowerDensity<T> : IQuantityT<PowerDensityUnit, T>, IEquatable<PowerDensity<T>>, IComparable, IComparable<PowerDensity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -106,12 +102,12 @@ static PowerDensity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public PowerDensity(double value, PowerDensityUnit unit)
+        public PowerDensity(T value, PowerDensityUnit unit)
         {
             if(unit == PowerDensityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -123,14 +119,14 @@ public PowerDensity(double value, PowerDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public PowerDensity(double value, UnitSystem unitSystem)
+        public PowerDensity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -145,19 +141,19 @@ public PowerDensity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of PowerDensity, which is WattPerCubicMeter. All conversions go via this value.
+        ///     The base unit of <see cref="PowerDensity{T}" />, which is WattPerCubicMeter. All conversions go via this value.
         /// </summary>
         public static PowerDensityUnit BaseUnit { get; } = PowerDensityUnit.WattPerCubicMeter;
 
         /// <summary>
-        /// Represents the largest possible value of PowerDensity
+        /// Represents the largest possible value of <see cref="PowerDensity{T}" />
         /// </summary>
-        public static PowerDensity MaxValue { get; } = new PowerDensity(double.MaxValue, BaseUnit);
+        public static PowerDensity<T> MaxValue { get; } = new PowerDensity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of PowerDensity
+        /// Represents the smallest possible value of <see cref="PowerDensity{T}" />
         /// </summary>
-        public static PowerDensity MinValue { get; } = new PowerDensity(double.MinValue, BaseUnit);
+        public static PowerDensity<T> MinValue { get; } = new PowerDensity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -166,14 +162,14 @@ public PowerDensity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.PowerDensity;
 
         /// <summary>
-        ///     All units of measurement for the PowerDensity quantity.
+        ///     All units of measurement for the <see cref="PowerDensity{T}" /> quantity.
         /// </summary>
         public static PowerDensityUnit[] Units { get; } = Enum.GetValues(typeof(PowerDensityUnit)).Cast<PowerDensityUnit>().Except(new PowerDensityUnit[]{ PowerDensityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit WattPerCubicMeter.
         /// </summary>
-        public static PowerDensity Zero { get; } = new PowerDensity(0, BaseUnit);
+        public static PowerDensity<T> Zero { get; } = new PowerDensity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -182,7 +178,9 @@ public PowerDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -198,236 +196,236 @@ public PowerDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => PowerDensity.QuantityType;
+        public QuantityType Type => PowerDensity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => PowerDensity.BaseDimensions;
+        public BaseDimensions Dimensions => PowerDensity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get PowerDensity in DecawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in DecawattsPerCubicFoot.
         /// </summary>
-        public double DecawattsPerCubicFoot => As(PowerDensityUnit.DecawattPerCubicFoot);
+        public T DecawattsPerCubicFoot => As(PowerDensityUnit.DecawattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in DecawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in DecawattsPerCubicInch.
         /// </summary>
-        public double DecawattsPerCubicInch => As(PowerDensityUnit.DecawattPerCubicInch);
+        public T DecawattsPerCubicInch => As(PowerDensityUnit.DecawattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in DecawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in DecawattsPerCubicMeter.
         /// </summary>
-        public double DecawattsPerCubicMeter => As(PowerDensityUnit.DecawattPerCubicMeter);
+        public T DecawattsPerCubicMeter => As(PowerDensityUnit.DecawattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in DecawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in DecawattsPerLiter.
         /// </summary>
-        public double DecawattsPerLiter => As(PowerDensityUnit.DecawattPerLiter);
+        public T DecawattsPerLiter => As(PowerDensityUnit.DecawattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in DeciwattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in DeciwattsPerCubicFoot.
         /// </summary>
-        public double DeciwattsPerCubicFoot => As(PowerDensityUnit.DeciwattPerCubicFoot);
+        public T DeciwattsPerCubicFoot => As(PowerDensityUnit.DeciwattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in DeciwattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in DeciwattsPerCubicInch.
         /// </summary>
-        public double DeciwattsPerCubicInch => As(PowerDensityUnit.DeciwattPerCubicInch);
+        public T DeciwattsPerCubicInch => As(PowerDensityUnit.DeciwattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in DeciwattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in DeciwattsPerCubicMeter.
         /// </summary>
-        public double DeciwattsPerCubicMeter => As(PowerDensityUnit.DeciwattPerCubicMeter);
+        public T DeciwattsPerCubicMeter => As(PowerDensityUnit.DeciwattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in DeciwattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in DeciwattsPerLiter.
         /// </summary>
-        public double DeciwattsPerLiter => As(PowerDensityUnit.DeciwattPerLiter);
+        public T DeciwattsPerLiter => As(PowerDensityUnit.DeciwattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in GigawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in GigawattsPerCubicFoot.
         /// </summary>
-        public double GigawattsPerCubicFoot => As(PowerDensityUnit.GigawattPerCubicFoot);
+        public T GigawattsPerCubicFoot => As(PowerDensityUnit.GigawattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in GigawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in GigawattsPerCubicInch.
         /// </summary>
-        public double GigawattsPerCubicInch => As(PowerDensityUnit.GigawattPerCubicInch);
+        public T GigawattsPerCubicInch => As(PowerDensityUnit.GigawattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in GigawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in GigawattsPerCubicMeter.
         /// </summary>
-        public double GigawattsPerCubicMeter => As(PowerDensityUnit.GigawattPerCubicMeter);
+        public T GigawattsPerCubicMeter => As(PowerDensityUnit.GigawattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in GigawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in GigawattsPerLiter.
         /// </summary>
-        public double GigawattsPerLiter => As(PowerDensityUnit.GigawattPerLiter);
+        public T GigawattsPerLiter => As(PowerDensityUnit.GigawattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in KilowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in KilowattsPerCubicFoot.
         /// </summary>
-        public double KilowattsPerCubicFoot => As(PowerDensityUnit.KilowattPerCubicFoot);
+        public T KilowattsPerCubicFoot => As(PowerDensityUnit.KilowattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in KilowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in KilowattsPerCubicInch.
         /// </summary>
-        public double KilowattsPerCubicInch => As(PowerDensityUnit.KilowattPerCubicInch);
+        public T KilowattsPerCubicInch => As(PowerDensityUnit.KilowattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in KilowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in KilowattsPerCubicMeter.
         /// </summary>
-        public double KilowattsPerCubicMeter => As(PowerDensityUnit.KilowattPerCubicMeter);
+        public T KilowattsPerCubicMeter => As(PowerDensityUnit.KilowattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in KilowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in KilowattsPerLiter.
         /// </summary>
-        public double KilowattsPerLiter => As(PowerDensityUnit.KilowattPerLiter);
+        public T KilowattsPerLiter => As(PowerDensityUnit.KilowattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in MegawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in MegawattsPerCubicFoot.
         /// </summary>
-        public double MegawattsPerCubicFoot => As(PowerDensityUnit.MegawattPerCubicFoot);
+        public T MegawattsPerCubicFoot => As(PowerDensityUnit.MegawattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in MegawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in MegawattsPerCubicInch.
         /// </summary>
-        public double MegawattsPerCubicInch => As(PowerDensityUnit.MegawattPerCubicInch);
+        public T MegawattsPerCubicInch => As(PowerDensityUnit.MegawattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in MegawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in MegawattsPerCubicMeter.
         /// </summary>
-        public double MegawattsPerCubicMeter => As(PowerDensityUnit.MegawattPerCubicMeter);
+        public T MegawattsPerCubicMeter => As(PowerDensityUnit.MegawattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in MegawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in MegawattsPerLiter.
         /// </summary>
-        public double MegawattsPerLiter => As(PowerDensityUnit.MegawattPerLiter);
+        public T MegawattsPerLiter => As(PowerDensityUnit.MegawattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in MicrowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in MicrowattsPerCubicFoot.
         /// </summary>
-        public double MicrowattsPerCubicFoot => As(PowerDensityUnit.MicrowattPerCubicFoot);
+        public T MicrowattsPerCubicFoot => As(PowerDensityUnit.MicrowattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in MicrowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in MicrowattsPerCubicInch.
         /// </summary>
-        public double MicrowattsPerCubicInch => As(PowerDensityUnit.MicrowattPerCubicInch);
+        public T MicrowattsPerCubicInch => As(PowerDensityUnit.MicrowattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in MicrowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in MicrowattsPerCubicMeter.
         /// </summary>
-        public double MicrowattsPerCubicMeter => As(PowerDensityUnit.MicrowattPerCubicMeter);
+        public T MicrowattsPerCubicMeter => As(PowerDensityUnit.MicrowattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in MicrowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in MicrowattsPerLiter.
         /// </summary>
-        public double MicrowattsPerLiter => As(PowerDensityUnit.MicrowattPerLiter);
+        public T MicrowattsPerLiter => As(PowerDensityUnit.MicrowattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in MilliwattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in MilliwattsPerCubicFoot.
         /// </summary>
-        public double MilliwattsPerCubicFoot => As(PowerDensityUnit.MilliwattPerCubicFoot);
+        public T MilliwattsPerCubicFoot => As(PowerDensityUnit.MilliwattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in MilliwattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in MilliwattsPerCubicInch.
         /// </summary>
-        public double MilliwattsPerCubicInch => As(PowerDensityUnit.MilliwattPerCubicInch);
+        public T MilliwattsPerCubicInch => As(PowerDensityUnit.MilliwattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in MilliwattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in MilliwattsPerCubicMeter.
         /// </summary>
-        public double MilliwattsPerCubicMeter => As(PowerDensityUnit.MilliwattPerCubicMeter);
+        public T MilliwattsPerCubicMeter => As(PowerDensityUnit.MilliwattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in MilliwattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in MilliwattsPerLiter.
         /// </summary>
-        public double MilliwattsPerLiter => As(PowerDensityUnit.MilliwattPerLiter);
+        public T MilliwattsPerLiter => As(PowerDensityUnit.MilliwattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in NanowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in NanowattsPerCubicFoot.
         /// </summary>
-        public double NanowattsPerCubicFoot => As(PowerDensityUnit.NanowattPerCubicFoot);
+        public T NanowattsPerCubicFoot => As(PowerDensityUnit.NanowattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in NanowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in NanowattsPerCubicInch.
         /// </summary>
-        public double NanowattsPerCubicInch => As(PowerDensityUnit.NanowattPerCubicInch);
+        public T NanowattsPerCubicInch => As(PowerDensityUnit.NanowattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in NanowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in NanowattsPerCubicMeter.
         /// </summary>
-        public double NanowattsPerCubicMeter => As(PowerDensityUnit.NanowattPerCubicMeter);
+        public T NanowattsPerCubicMeter => As(PowerDensityUnit.NanowattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in NanowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in NanowattsPerLiter.
         /// </summary>
-        public double NanowattsPerLiter => As(PowerDensityUnit.NanowattPerLiter);
+        public T NanowattsPerLiter => As(PowerDensityUnit.NanowattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in PicowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in PicowattsPerCubicFoot.
         /// </summary>
-        public double PicowattsPerCubicFoot => As(PowerDensityUnit.PicowattPerCubicFoot);
+        public T PicowattsPerCubicFoot => As(PowerDensityUnit.PicowattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in PicowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in PicowattsPerCubicInch.
         /// </summary>
-        public double PicowattsPerCubicInch => As(PowerDensityUnit.PicowattPerCubicInch);
+        public T PicowattsPerCubicInch => As(PowerDensityUnit.PicowattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in PicowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in PicowattsPerCubicMeter.
         /// </summary>
-        public double PicowattsPerCubicMeter => As(PowerDensityUnit.PicowattPerCubicMeter);
+        public T PicowattsPerCubicMeter => As(PowerDensityUnit.PicowattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in PicowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in PicowattsPerLiter.
         /// </summary>
-        public double PicowattsPerLiter => As(PowerDensityUnit.PicowattPerLiter);
+        public T PicowattsPerLiter => As(PowerDensityUnit.PicowattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in TerawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in TerawattsPerCubicFoot.
         /// </summary>
-        public double TerawattsPerCubicFoot => As(PowerDensityUnit.TerawattPerCubicFoot);
+        public T TerawattsPerCubicFoot => As(PowerDensityUnit.TerawattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in TerawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in TerawattsPerCubicInch.
         /// </summary>
-        public double TerawattsPerCubicInch => As(PowerDensityUnit.TerawattPerCubicInch);
+        public T TerawattsPerCubicInch => As(PowerDensityUnit.TerawattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in TerawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in TerawattsPerCubicMeter.
         /// </summary>
-        public double TerawattsPerCubicMeter => As(PowerDensityUnit.TerawattPerCubicMeter);
+        public T TerawattsPerCubicMeter => As(PowerDensityUnit.TerawattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in TerawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in TerawattsPerLiter.
         /// </summary>
-        public double TerawattsPerLiter => As(PowerDensityUnit.TerawattPerLiter);
+        public T TerawattsPerLiter => As(PowerDensityUnit.TerawattPerLiter);
 
         /// <summary>
-        ///     Get PowerDensity in WattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> in WattsPerCubicFoot.
         /// </summary>
-        public double WattsPerCubicFoot => As(PowerDensityUnit.WattPerCubicFoot);
+        public T WattsPerCubicFoot => As(PowerDensityUnit.WattPerCubicFoot);
 
         /// <summary>
-        ///     Get PowerDensity in WattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> in WattsPerCubicInch.
         /// </summary>
-        public double WattsPerCubicInch => As(PowerDensityUnit.WattPerCubicInch);
+        public T WattsPerCubicInch => As(PowerDensityUnit.WattPerCubicInch);
 
         /// <summary>
-        ///     Get PowerDensity in WattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> in WattsPerCubicMeter.
         /// </summary>
-        public double WattsPerCubicMeter => As(PowerDensityUnit.WattPerCubicMeter);
+        public T WattsPerCubicMeter => As(PowerDensityUnit.WattPerCubicMeter);
 
         /// <summary>
-        ///     Get PowerDensity in WattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> in WattsPerLiter.
         /// </summary>
-        public double WattsPerLiter => As(PowerDensityUnit.WattPerLiter);
+        public T WattsPerLiter => As(PowerDensityUnit.WattPerLiter);
 
         #endregion
 
@@ -459,411 +457,367 @@ public static string GetAbbreviation(PowerDensityUnit unit, IFormatProvider? pro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get PowerDensity from DecawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from DecawattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicFoot(QuantityValue decawattspercubicfoot)
+        public static PowerDensity<T> FromDecawattsPerCubicFoot(T decawattspercubicfoot)
         {
-            double value = (double) decawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot);
+            return new PowerDensity<T>(decawattspercubicfoot, PowerDensityUnit.DecawattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from DecawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from DecawattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicInch(QuantityValue decawattspercubicinch)
+        public static PowerDensity<T> FromDecawattsPerCubicInch(T decawattspercubicinch)
         {
-            double value = (double) decawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch);
+            return new PowerDensity<T>(decawattspercubicinch, PowerDensityUnit.DecawattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from DecawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from DecawattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicMeter(QuantityValue decawattspercubicmeter)
+        public static PowerDensity<T> FromDecawattsPerCubicMeter(T decawattspercubicmeter)
         {
-            double value = (double) decawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter);
+            return new PowerDensity<T>(decawattspercubicmeter, PowerDensityUnit.DecawattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from DecawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from DecawattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerLiter(QuantityValue decawattsperliter)
+        public static PowerDensity<T> FromDecawattsPerLiter(T decawattsperliter)
         {
-            double value = (double) decawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter);
+            return new PowerDensity<T>(decawattsperliter, PowerDensityUnit.DecawattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from DeciwattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from DeciwattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicFoot(QuantityValue deciwattspercubicfoot)
+        public static PowerDensity<T> FromDeciwattsPerCubicFoot(T deciwattspercubicfoot)
         {
-            double value = (double) deciwattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot);
+            return new PowerDensity<T>(deciwattspercubicfoot, PowerDensityUnit.DeciwattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from DeciwattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from DeciwattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicInch(QuantityValue deciwattspercubicinch)
+        public static PowerDensity<T> FromDeciwattsPerCubicInch(T deciwattspercubicinch)
         {
-            double value = (double) deciwattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch);
+            return new PowerDensity<T>(deciwattspercubicinch, PowerDensityUnit.DeciwattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from DeciwattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from DeciwattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicMeter(QuantityValue deciwattspercubicmeter)
+        public static PowerDensity<T> FromDeciwattsPerCubicMeter(T deciwattspercubicmeter)
         {
-            double value = (double) deciwattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter);
+            return new PowerDensity<T>(deciwattspercubicmeter, PowerDensityUnit.DeciwattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from DeciwattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from DeciwattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerLiter(QuantityValue deciwattsperliter)
+        public static PowerDensity<T> FromDeciwattsPerLiter(T deciwattsperliter)
         {
-            double value = (double) deciwattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter);
+            return new PowerDensity<T>(deciwattsperliter, PowerDensityUnit.DeciwattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from GigawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from GigawattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicFoot(QuantityValue gigawattspercubicfoot)
+        public static PowerDensity<T> FromGigawattsPerCubicFoot(T gigawattspercubicfoot)
         {
-            double value = (double) gigawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot);
+            return new PowerDensity<T>(gigawattspercubicfoot, PowerDensityUnit.GigawattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from GigawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from GigawattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicInch(QuantityValue gigawattspercubicinch)
+        public static PowerDensity<T> FromGigawattsPerCubicInch(T gigawattspercubicinch)
         {
-            double value = (double) gigawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch);
+            return new PowerDensity<T>(gigawattspercubicinch, PowerDensityUnit.GigawattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from GigawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from GigawattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicMeter(QuantityValue gigawattspercubicmeter)
+        public static PowerDensity<T> FromGigawattsPerCubicMeter(T gigawattspercubicmeter)
         {
-            double value = (double) gigawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter);
+            return new PowerDensity<T>(gigawattspercubicmeter, PowerDensityUnit.GigawattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from GigawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from GigawattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerLiter(QuantityValue gigawattsperliter)
+        public static PowerDensity<T> FromGigawattsPerLiter(T gigawattsperliter)
         {
-            double value = (double) gigawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter);
+            return new PowerDensity<T>(gigawattsperliter, PowerDensityUnit.GigawattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from KilowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from KilowattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicFoot(QuantityValue kilowattspercubicfoot)
+        public static PowerDensity<T> FromKilowattsPerCubicFoot(T kilowattspercubicfoot)
         {
-            double value = (double) kilowattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot);
+            return new PowerDensity<T>(kilowattspercubicfoot, PowerDensityUnit.KilowattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from KilowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from KilowattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicInch(QuantityValue kilowattspercubicinch)
+        public static PowerDensity<T> FromKilowattsPerCubicInch(T kilowattspercubicinch)
         {
-            double value = (double) kilowattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch);
+            return new PowerDensity<T>(kilowattspercubicinch, PowerDensityUnit.KilowattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from KilowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from KilowattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicMeter(QuantityValue kilowattspercubicmeter)
+        public static PowerDensity<T> FromKilowattsPerCubicMeter(T kilowattspercubicmeter)
         {
-            double value = (double) kilowattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter);
+            return new PowerDensity<T>(kilowattspercubicmeter, PowerDensityUnit.KilowattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from KilowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from KilowattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerLiter(QuantityValue kilowattsperliter)
+        public static PowerDensity<T> FromKilowattsPerLiter(T kilowattsperliter)
         {
-            double value = (double) kilowattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter);
+            return new PowerDensity<T>(kilowattsperliter, PowerDensityUnit.KilowattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from MegawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from MegawattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicFoot(QuantityValue megawattspercubicfoot)
+        public static PowerDensity<T> FromMegawattsPerCubicFoot(T megawattspercubicfoot)
         {
-            double value = (double) megawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot);
+            return new PowerDensity<T>(megawattspercubicfoot, PowerDensityUnit.MegawattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from MegawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from MegawattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicInch(QuantityValue megawattspercubicinch)
+        public static PowerDensity<T> FromMegawattsPerCubicInch(T megawattspercubicinch)
         {
-            double value = (double) megawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch);
+            return new PowerDensity<T>(megawattspercubicinch, PowerDensityUnit.MegawattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from MegawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from MegawattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicMeter(QuantityValue megawattspercubicmeter)
+        public static PowerDensity<T> FromMegawattsPerCubicMeter(T megawattspercubicmeter)
         {
-            double value = (double) megawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter);
+            return new PowerDensity<T>(megawattspercubicmeter, PowerDensityUnit.MegawattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from MegawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from MegawattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerLiter(QuantityValue megawattsperliter)
+        public static PowerDensity<T> FromMegawattsPerLiter(T megawattsperliter)
         {
-            double value = (double) megawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter);
+            return new PowerDensity<T>(megawattsperliter, PowerDensityUnit.MegawattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from MicrowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from MicrowattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicFoot(QuantityValue microwattspercubicfoot)
+        public static PowerDensity<T> FromMicrowattsPerCubicFoot(T microwattspercubicfoot)
         {
-            double value = (double) microwattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot);
+            return new PowerDensity<T>(microwattspercubicfoot, PowerDensityUnit.MicrowattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from MicrowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from MicrowattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicInch(QuantityValue microwattspercubicinch)
+        public static PowerDensity<T> FromMicrowattsPerCubicInch(T microwattspercubicinch)
         {
-            double value = (double) microwattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch);
+            return new PowerDensity<T>(microwattspercubicinch, PowerDensityUnit.MicrowattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from MicrowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from MicrowattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicMeter(QuantityValue microwattspercubicmeter)
+        public static PowerDensity<T> FromMicrowattsPerCubicMeter(T microwattspercubicmeter)
         {
-            double value = (double) microwattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter);
+            return new PowerDensity<T>(microwattspercubicmeter, PowerDensityUnit.MicrowattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from MicrowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from MicrowattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerLiter(QuantityValue microwattsperliter)
+        public static PowerDensity<T> FromMicrowattsPerLiter(T microwattsperliter)
         {
-            double value = (double) microwattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter);
+            return new PowerDensity<T>(microwattsperliter, PowerDensityUnit.MicrowattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from MilliwattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from MilliwattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicFoot(QuantityValue milliwattspercubicfoot)
+        public static PowerDensity<T> FromMilliwattsPerCubicFoot(T milliwattspercubicfoot)
         {
-            double value = (double) milliwattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot);
+            return new PowerDensity<T>(milliwattspercubicfoot, PowerDensityUnit.MilliwattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from MilliwattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from MilliwattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicInch(QuantityValue milliwattspercubicinch)
+        public static PowerDensity<T> FromMilliwattsPerCubicInch(T milliwattspercubicinch)
         {
-            double value = (double) milliwattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch);
+            return new PowerDensity<T>(milliwattspercubicinch, PowerDensityUnit.MilliwattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from MilliwattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from MilliwattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicMeter(QuantityValue milliwattspercubicmeter)
+        public static PowerDensity<T> FromMilliwattsPerCubicMeter(T milliwattspercubicmeter)
         {
-            double value = (double) milliwattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter);
+            return new PowerDensity<T>(milliwattspercubicmeter, PowerDensityUnit.MilliwattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from MilliwattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from MilliwattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerLiter(QuantityValue milliwattsperliter)
+        public static PowerDensity<T> FromMilliwattsPerLiter(T milliwattsperliter)
         {
-            double value = (double) milliwattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter);
+            return new PowerDensity<T>(milliwattsperliter, PowerDensityUnit.MilliwattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from NanowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from NanowattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicFoot(QuantityValue nanowattspercubicfoot)
+        public static PowerDensity<T> FromNanowattsPerCubicFoot(T nanowattspercubicfoot)
         {
-            double value = (double) nanowattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot);
+            return new PowerDensity<T>(nanowattspercubicfoot, PowerDensityUnit.NanowattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from NanowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from NanowattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicInch(QuantityValue nanowattspercubicinch)
+        public static PowerDensity<T> FromNanowattsPerCubicInch(T nanowattspercubicinch)
         {
-            double value = (double) nanowattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch);
+            return new PowerDensity<T>(nanowattspercubicinch, PowerDensityUnit.NanowattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from NanowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from NanowattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicMeter(QuantityValue nanowattspercubicmeter)
+        public static PowerDensity<T> FromNanowattsPerCubicMeter(T nanowattspercubicmeter)
         {
-            double value = (double) nanowattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter);
+            return new PowerDensity<T>(nanowattspercubicmeter, PowerDensityUnit.NanowattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from NanowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from NanowattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerLiter(QuantityValue nanowattsperliter)
+        public static PowerDensity<T> FromNanowattsPerLiter(T nanowattsperliter)
         {
-            double value = (double) nanowattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter);
+            return new PowerDensity<T>(nanowattsperliter, PowerDensityUnit.NanowattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from PicowattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from PicowattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicFoot(QuantityValue picowattspercubicfoot)
+        public static PowerDensity<T> FromPicowattsPerCubicFoot(T picowattspercubicfoot)
         {
-            double value = (double) picowattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot);
+            return new PowerDensity<T>(picowattspercubicfoot, PowerDensityUnit.PicowattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from PicowattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from PicowattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicInch(QuantityValue picowattspercubicinch)
+        public static PowerDensity<T> FromPicowattsPerCubicInch(T picowattspercubicinch)
         {
-            double value = (double) picowattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch);
+            return new PowerDensity<T>(picowattspercubicinch, PowerDensityUnit.PicowattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from PicowattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from PicowattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicMeter(QuantityValue picowattspercubicmeter)
+        public static PowerDensity<T> FromPicowattsPerCubicMeter(T picowattspercubicmeter)
         {
-            double value = (double) picowattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter);
+            return new PowerDensity<T>(picowattspercubicmeter, PowerDensityUnit.PicowattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from PicowattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from PicowattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerLiter(QuantityValue picowattsperliter)
+        public static PowerDensity<T> FromPicowattsPerLiter(T picowattsperliter)
         {
-            double value = (double) picowattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter);
+            return new PowerDensity<T>(picowattsperliter, PowerDensityUnit.PicowattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from TerawattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from TerawattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicFoot(QuantityValue terawattspercubicfoot)
+        public static PowerDensity<T> FromTerawattsPerCubicFoot(T terawattspercubicfoot)
         {
-            double value = (double) terawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot);
+            return new PowerDensity<T>(terawattspercubicfoot, PowerDensityUnit.TerawattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from TerawattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from TerawattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicInch(QuantityValue terawattspercubicinch)
+        public static PowerDensity<T> FromTerawattsPerCubicInch(T terawattspercubicinch)
         {
-            double value = (double) terawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch);
+            return new PowerDensity<T>(terawattspercubicinch, PowerDensityUnit.TerawattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from TerawattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from TerawattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicMeter(QuantityValue terawattspercubicmeter)
+        public static PowerDensity<T> FromTerawattsPerCubicMeter(T terawattspercubicmeter)
         {
-            double value = (double) terawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter);
+            return new PowerDensity<T>(terawattspercubicmeter, PowerDensityUnit.TerawattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from TerawattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from TerawattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerLiter(QuantityValue terawattsperliter)
+        public static PowerDensity<T> FromTerawattsPerLiter(T terawattsperliter)
         {
-            double value = (double) terawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter);
+            return new PowerDensity<T>(terawattsperliter, PowerDensityUnit.TerawattPerLiter);
         }
         /// <summary>
-        ///     Get PowerDensity from WattsPerCubicFoot.
+        ///     Get <see cref="PowerDensity{T}" /> from WattsPerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicFoot(QuantityValue wattspercubicfoot)
+        public static PowerDensity<T> FromWattsPerCubicFoot(T wattspercubicfoot)
         {
-            double value = (double) wattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot);
+            return new PowerDensity<T>(wattspercubicfoot, PowerDensityUnit.WattPerCubicFoot);
         }
         /// <summary>
-        ///     Get PowerDensity from WattsPerCubicInch.
+        ///     Get <see cref="PowerDensity{T}" /> from WattsPerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicInch(QuantityValue wattspercubicinch)
+        public static PowerDensity<T> FromWattsPerCubicInch(T wattspercubicinch)
         {
-            double value = (double) wattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch);
+            return new PowerDensity<T>(wattspercubicinch, PowerDensityUnit.WattPerCubicInch);
         }
         /// <summary>
-        ///     Get PowerDensity from WattsPerCubicMeter.
+        ///     Get <see cref="PowerDensity{T}" /> from WattsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicMeter(QuantityValue wattspercubicmeter)
+        public static PowerDensity<T> FromWattsPerCubicMeter(T wattspercubicmeter)
         {
-            double value = (double) wattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter);
+            return new PowerDensity<T>(wattspercubicmeter, PowerDensityUnit.WattPerCubicMeter);
         }
         /// <summary>
-        ///     Get PowerDensity from WattsPerLiter.
+        ///     Get <see cref="PowerDensity{T}" /> from WattsPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerLiter(QuantityValue wattsperliter)
+        public static PowerDensity<T> FromWattsPerLiter(T wattsperliter)
         {
-            double value = (double) wattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.WattPerLiter);
+            return new PowerDensity<T>(wattsperliter, PowerDensityUnit.WattPerLiter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PowerDensityUnit" /> to <see cref="PowerDensity" />.
+        ///     Dynamically convert from value and unit enum <see cref="PowerDensityUnit" /> to <see cref="PowerDensity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>PowerDensity unit value.</returns>
-        public static PowerDensity From(QuantityValue value, PowerDensityUnit fromUnit)
+        /// <returns><see cref="PowerDensity{T}" /> unit value.</returns>
+        public static PowerDensity<T> From(T value, PowerDensityUnit fromUnit)
         {
-            return new PowerDensity((double)value, fromUnit);
+            return new PowerDensity<T>(value, fromUnit);
         }
 
         #endregion
@@ -892,7 +846,7 @@ public static PowerDensity From(QuantityValue value, PowerDensityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static PowerDensity Parse(string str)
+        public static PowerDensity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -920,9 +874,9 @@ public static PowerDensity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static PowerDensity Parse(string str, IFormatProvider? provider)
+        public static PowerDensity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<PowerDensity, PowerDensityUnit>(
+            return QuantityParser.Default.Parse<T, PowerDensity<T>, PowerDensityUnit>(
                 str,
                 provider,
                 From);
@@ -936,7 +890,7 @@ public static PowerDensity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out PowerDensity result)
+        public static bool TryParse(string? str, out PowerDensity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -951,9 +905,9 @@ public static bool TryParse(string? str, out PowerDensity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out PowerDensity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out PowerDensity<T> result)
         {
-            return QuantityParser.Default.TryParse<PowerDensity, PowerDensityUnit>(
+            return QuantityParser.Default.TryParse<T, PowerDensity<T>, PowerDensityUnit>(
                 str,
                 provider,
                 From,
@@ -1015,45 +969,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static PowerDensity operator -(PowerDensity right)
+        public static PowerDensity<T> operator -(PowerDensity<T> right)
         {
-            return new PowerDensity(-right.Value, right.Unit);
+            return new PowerDensity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="PowerDensity"/> from adding two <see cref="PowerDensity"/>.</summary>
-        public static PowerDensity operator +(PowerDensity left, PowerDensity right)
+        /// <summary>Get <see cref="PowerDensity{T}"/> from adding two <see cref="PowerDensity{T}"/>.</summary>
+        public static PowerDensity<T> operator +(PowerDensity<T> left, PowerDensity<T> right)
         {
-            return new PowerDensity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new PowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="PowerDensity"/> from subtracting two <see cref="PowerDensity"/>.</summary>
-        public static PowerDensity operator -(PowerDensity left, PowerDensity right)
+        /// <summary>Get <see cref="PowerDensity{T}"/> from subtracting two <see cref="PowerDensity{T}"/>.</summary>
+        public static PowerDensity<T> operator -(PowerDensity<T> left, PowerDensity<T> right)
         {
-            return new PowerDensity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new PowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="PowerDensity"/> from multiplying value and <see cref="PowerDensity"/>.</summary>
-        public static PowerDensity operator *(double left, PowerDensity right)
+        /// <summary>Get <see cref="PowerDensity{T}"/> from multiplying value and <see cref="PowerDensity{T}"/>.</summary>
+        public static PowerDensity<T> operator *(T left, PowerDensity<T> right)
         {
-            return new PowerDensity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new PowerDensity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="PowerDensity"/> from multiplying value and <see cref="PowerDensity"/>.</summary>
-        public static PowerDensity operator *(PowerDensity left, double right)
+        /// <summary>Get <see cref="PowerDensity{T}"/> from multiplying value and <see cref="PowerDensity{T}"/>.</summary>
+        public static PowerDensity<T> operator *(PowerDensity<T> left, T right)
         {
-            return new PowerDensity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new PowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="PowerDensity"/> from dividing <see cref="PowerDensity"/> by value.</summary>
-        public static PowerDensity operator /(PowerDensity left, double right)
+        /// <summary>Get <see cref="PowerDensity{T}"/> from dividing <see cref="PowerDensity{T}"/> by value.</summary>
+        public static PowerDensity<T> operator /(PowerDensity<T> left, T right)
         {
-            return new PowerDensity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new PowerDensity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="PowerDensity"/> by <see cref="PowerDensity"/>.</summary>
-        public static double operator /(PowerDensity left, PowerDensity right)
+        /// <summary>Get ratio value from dividing <see cref="PowerDensity{T}"/> by <see cref="PowerDensity{T}"/>.</summary>
+        public static T operator /(PowerDensity<T> left, PowerDensity<T> right)
         {
-            return left.WattsPerCubicMeter / right.WattsPerCubicMeter;
+            return CompiledLambdas.Divide(left.WattsPerCubicMeter, right.WattsPerCubicMeter);
         }
 
         #endregion
@@ -1061,39 +1020,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(PowerDensity left, PowerDensity right)
+        public static bool operator <=(PowerDensity<T> left, PowerDensity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(PowerDensity left, PowerDensity right)
+        public static bool operator >=(PowerDensity<T> left, PowerDensity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(PowerDensity left, PowerDensity right)
+        public static bool operator <(PowerDensity<T> left, PowerDensity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(PowerDensity left, PowerDensity right)
+        public static bool operator >(PowerDensity<T> left, PowerDensity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(PowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(PowerDensity left, PowerDensity right)
+        /// <remarks>Consider using <see cref="Equals(PowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(PowerDensity<T> left, PowerDensity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(PowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(PowerDensity left, PowerDensity right)
+        /// <remarks>Consider using <see cref="Equals(PowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(PowerDensity<T> left, PowerDensity<T> right)
         {
             return !(left == right);
         }
@@ -1102,37 +1061,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is PowerDensity objPowerDensity)) throw new ArgumentException("Expected type PowerDensity.", nameof(obj));
+            if(!(obj is PowerDensity<T> objPowerDensity)) throw new ArgumentException("Expected type PowerDensity.", nameof(obj));
 
             return CompareTo(objPowerDensity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(PowerDensity other)
+        public int CompareTo(PowerDensity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(PowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(PowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is PowerDensity objPowerDensity))
+            if(obj is null || !(obj is PowerDensity<T> objPowerDensity))
                 return false;
 
             return Equals(objPowerDensity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(PowerDensity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(PowerDensity other)
+        /// <remarks>Consider using <see cref="Equals(PowerDensity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(PowerDensity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another PowerDensity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="PowerDensity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1170,21 +1129,19 @@ public bool Equals(PowerDensity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(PowerDensity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(PowerDensity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current PowerDensity.</returns>
+        /// <returns>A hash code for the current <see cref="PowerDensity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1198,17 +1155,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(PowerDensityUnit unit)
+        public T As(PowerDensityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1228,17 +1185,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is PowerDensityUnit unitAsPowerDensityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerDensityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsPowerDensityUnit);
+            var asValue = As(unitAsPowerDensityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<PowerDensityUnit>.As(PowerDensityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this PowerDensity to another PowerDensity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="PowerDensity{T}" /> to another <see cref="PowerDensity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A PowerDensity with the specified unit.</returns>
-        public PowerDensity ToUnit(PowerDensityUnit unit)
+        /// <returns>A <see cref="PowerDensity{T}" /> with the specified unit.</returns>
+        public PowerDensity<T> ToUnit(PowerDensityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new PowerDensity(convertedValue, unit);
+            return new PowerDensity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1251,7 +1213,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public PowerDensity ToUnit(UnitSystem unitSystem)
+        public PowerDensity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1271,62 +1233,68 @@ public PowerDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PowerDensityUnit> IQuantity<PowerDensityUnit>.ToUnit(PowerDensityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<PowerDensityUnit, T> IQuantityT<PowerDensityUnit, T>.ToUnit(PowerDensityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<PowerDensityUnit> IQuantity<PowerDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<PowerDensityUnit, T> IQuantityT<PowerDensityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case PowerDensityUnit.DecawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e1d;
-                case PowerDensityUnit.DecawattPerCubicInch: return (_value*6.102374409473228e4) * 1e1d;
-                case PowerDensityUnit.DecawattPerCubicMeter: return (_value) * 1e1d;
-                case PowerDensityUnit.DecawattPerLiter: return (_value*1.0e3) * 1e1d;
-                case PowerDensityUnit.DeciwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-1d;
-                case PowerDensityUnit.DeciwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-1d;
-                case PowerDensityUnit.DeciwattPerCubicMeter: return (_value) * 1e-1d;
-                case PowerDensityUnit.DeciwattPerLiter: return (_value*1.0e3) * 1e-1d;
-                case PowerDensityUnit.GigawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e9d;
-                case PowerDensityUnit.GigawattPerCubicInch: return (_value*6.102374409473228e4) * 1e9d;
-                case PowerDensityUnit.GigawattPerCubicMeter: return (_value) * 1e9d;
-                case PowerDensityUnit.GigawattPerLiter: return (_value*1.0e3) * 1e9d;
-                case PowerDensityUnit.KilowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e3d;
-                case PowerDensityUnit.KilowattPerCubicInch: return (_value*6.102374409473228e4) * 1e3d;
-                case PowerDensityUnit.KilowattPerCubicMeter: return (_value) * 1e3d;
-                case PowerDensityUnit.KilowattPerLiter: return (_value*1.0e3) * 1e3d;
-                case PowerDensityUnit.MegawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e6d;
-                case PowerDensityUnit.MegawattPerCubicInch: return (_value*6.102374409473228e4) * 1e6d;
-                case PowerDensityUnit.MegawattPerCubicMeter: return (_value) * 1e6d;
-                case PowerDensityUnit.MegawattPerLiter: return (_value*1.0e3) * 1e6d;
-                case PowerDensityUnit.MicrowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-6d;
-                case PowerDensityUnit.MicrowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-6d;
-                case PowerDensityUnit.MicrowattPerCubicMeter: return (_value) * 1e-6d;
-                case PowerDensityUnit.MicrowattPerLiter: return (_value*1.0e3) * 1e-6d;
-                case PowerDensityUnit.MilliwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-3d;
-                case PowerDensityUnit.MilliwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-3d;
-                case PowerDensityUnit.MilliwattPerCubicMeter: return (_value) * 1e-3d;
-                case PowerDensityUnit.MilliwattPerLiter: return (_value*1.0e3) * 1e-3d;
-                case PowerDensityUnit.NanowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-9d;
-                case PowerDensityUnit.NanowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-9d;
-                case PowerDensityUnit.NanowattPerCubicMeter: return (_value) * 1e-9d;
-                case PowerDensityUnit.NanowattPerLiter: return (_value*1.0e3) * 1e-9d;
-                case PowerDensityUnit.PicowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-12d;
-                case PowerDensityUnit.PicowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-12d;
-                case PowerDensityUnit.PicowattPerCubicMeter: return (_value) * 1e-12d;
-                case PowerDensityUnit.PicowattPerLiter: return (_value*1.0e3) * 1e-12d;
-                case PowerDensityUnit.TerawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e12d;
-                case PowerDensityUnit.TerawattPerCubicInch: return (_value*6.102374409473228e4) * 1e12d;
-                case PowerDensityUnit.TerawattPerCubicMeter: return (_value) * 1e12d;
-                case PowerDensityUnit.TerawattPerLiter: return (_value*1.0e3) * 1e12d;
-                case PowerDensityUnit.WattPerCubicFoot: return _value*3.531466672148859e1;
-                case PowerDensityUnit.WattPerCubicInch: return _value*6.102374409473228e4;
-                case PowerDensityUnit.WattPerCubicMeter: return _value;
-                case PowerDensityUnit.WattPerLiter: return _value*1.0e3;
+                case PowerDensityUnit.DecawattPerCubicFoot: return (Value*3.531466672148859e1) * 1e1d;
+                case PowerDensityUnit.DecawattPerCubicInch: return (Value*6.102374409473228e4) * 1e1d;
+                case PowerDensityUnit.DecawattPerCubicMeter: return (Value) * 1e1d;
+                case PowerDensityUnit.DecawattPerLiter: return (Value*1.0e3) * 1e1d;
+                case PowerDensityUnit.DeciwattPerCubicFoot: return (Value*3.531466672148859e1) * 1e-1d;
+                case PowerDensityUnit.DeciwattPerCubicInch: return (Value*6.102374409473228e4) * 1e-1d;
+                case PowerDensityUnit.DeciwattPerCubicMeter: return (Value) * 1e-1d;
+                case PowerDensityUnit.DeciwattPerLiter: return (Value*1.0e3) * 1e-1d;
+                case PowerDensityUnit.GigawattPerCubicFoot: return (Value*3.531466672148859e1) * 1e9d;
+                case PowerDensityUnit.GigawattPerCubicInch: return (Value*6.102374409473228e4) * 1e9d;
+                case PowerDensityUnit.GigawattPerCubicMeter: return (Value) * 1e9d;
+                case PowerDensityUnit.GigawattPerLiter: return (Value*1.0e3) * 1e9d;
+                case PowerDensityUnit.KilowattPerCubicFoot: return (Value*3.531466672148859e1) * 1e3d;
+                case PowerDensityUnit.KilowattPerCubicInch: return (Value*6.102374409473228e4) * 1e3d;
+                case PowerDensityUnit.KilowattPerCubicMeter: return (Value) * 1e3d;
+                case PowerDensityUnit.KilowattPerLiter: return (Value*1.0e3) * 1e3d;
+                case PowerDensityUnit.MegawattPerCubicFoot: return (Value*3.531466672148859e1) * 1e6d;
+                case PowerDensityUnit.MegawattPerCubicInch: return (Value*6.102374409473228e4) * 1e6d;
+                case PowerDensityUnit.MegawattPerCubicMeter: return (Value) * 1e6d;
+                case PowerDensityUnit.MegawattPerLiter: return (Value*1.0e3) * 1e6d;
+                case PowerDensityUnit.MicrowattPerCubicFoot: return (Value*3.531466672148859e1) * 1e-6d;
+                case PowerDensityUnit.MicrowattPerCubicInch: return (Value*6.102374409473228e4) * 1e-6d;
+                case PowerDensityUnit.MicrowattPerCubicMeter: return (Value) * 1e-6d;
+                case PowerDensityUnit.MicrowattPerLiter: return (Value*1.0e3) * 1e-6d;
+                case PowerDensityUnit.MilliwattPerCubicFoot: return (Value*3.531466672148859e1) * 1e-3d;
+                case PowerDensityUnit.MilliwattPerCubicInch: return (Value*6.102374409473228e4) * 1e-3d;
+                case PowerDensityUnit.MilliwattPerCubicMeter: return (Value) * 1e-3d;
+                case PowerDensityUnit.MilliwattPerLiter: return (Value*1.0e3) * 1e-3d;
+                case PowerDensityUnit.NanowattPerCubicFoot: return (Value*3.531466672148859e1) * 1e-9d;
+                case PowerDensityUnit.NanowattPerCubicInch: return (Value*6.102374409473228e4) * 1e-9d;
+                case PowerDensityUnit.NanowattPerCubicMeter: return (Value) * 1e-9d;
+                case PowerDensityUnit.NanowattPerLiter: return (Value*1.0e3) * 1e-9d;
+                case PowerDensityUnit.PicowattPerCubicFoot: return (Value*3.531466672148859e1) * 1e-12d;
+                case PowerDensityUnit.PicowattPerCubicInch: return (Value*6.102374409473228e4) * 1e-12d;
+                case PowerDensityUnit.PicowattPerCubicMeter: return (Value) * 1e-12d;
+                case PowerDensityUnit.PicowattPerLiter: return (Value*1.0e3) * 1e-12d;
+                case PowerDensityUnit.TerawattPerCubicFoot: return (Value*3.531466672148859e1) * 1e12d;
+                case PowerDensityUnit.TerawattPerCubicInch: return (Value*6.102374409473228e4) * 1e12d;
+                case PowerDensityUnit.TerawattPerCubicMeter: return (Value) * 1e12d;
+                case PowerDensityUnit.TerawattPerLiter: return (Value*1.0e3) * 1e12d;
+                case PowerDensityUnit.WattPerCubicFoot: return Value*3.531466672148859e1;
+                case PowerDensityUnit.WattPerCubicInch: return Value*6.102374409473228e4;
+                case PowerDensityUnit.WattPerCubicMeter: return Value;
+                case PowerDensityUnit.WattPerLiter: return Value*1.0e3;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1337,16 +1305,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal PowerDensity ToBaseUnit()
+        internal PowerDensity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new PowerDensity(baseUnitValue, BaseUnit);
+            return new PowerDensity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(PowerDensityUnit unit)
+        private T GetValueAs(PowerDensityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1492,57 +1460,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PowerDensity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PowerDensity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PowerDensity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PowerDensity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PowerDensity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PowerDensity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1552,33 +1520,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(PowerDensity))
+            if(conversionType == typeof(PowerDensity<T>))
                 return this;
             else if(conversionType == typeof(PowerDensityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return PowerDensity.QuantityType;
+                return PowerDensity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return PowerDensity.Info;
+                return PowerDensity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return PowerDensity.BaseDimensions;
+                return PowerDensity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(PowerDensity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(PowerDensity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
index 4bea934a26..c4e7126379 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The strength of a signal expressed in decibels (dB) relative to one watt.
     /// </summary>
-    public partial struct PowerRatio : IQuantity<PowerRatioUnit>, IEquatable<PowerRatio>, IComparable, IComparable<PowerRatio>, IConvertible, IFormattable
+    public partial struct PowerRatio<T> : IQuantityT<PowerRatioUnit, T>, IEquatable<PowerRatio<T>>, IComparable, IComparable<PowerRatio<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -64,12 +60,12 @@ static PowerRatio()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public PowerRatio(double value, PowerRatioUnit unit)
+        public PowerRatio(T value, PowerRatioUnit unit)
         {
             if(unit == PowerRatioUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -81,14 +77,14 @@ public PowerRatio(double value, PowerRatioUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public PowerRatio(double value, UnitSystem unitSystem)
+        public PowerRatio(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -103,19 +99,19 @@ public PowerRatio(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of PowerRatio, which is DecibelWatt. All conversions go via this value.
+        ///     The base unit of <see cref="PowerRatio{T}" />, which is DecibelWatt. All conversions go via this value.
         /// </summary>
         public static PowerRatioUnit BaseUnit { get; } = PowerRatioUnit.DecibelWatt;
 
         /// <summary>
-        /// Represents the largest possible value of PowerRatio
+        /// Represents the largest possible value of <see cref="PowerRatio{T}" />
         /// </summary>
-        public static PowerRatio MaxValue { get; } = new PowerRatio(double.MaxValue, BaseUnit);
+        public static PowerRatio<T> MaxValue { get; } = new PowerRatio<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of PowerRatio
+        /// Represents the smallest possible value of <see cref="PowerRatio{T}" />
         /// </summary>
-        public static PowerRatio MinValue { get; } = new PowerRatio(double.MinValue, BaseUnit);
+        public static PowerRatio<T> MinValue { get; } = new PowerRatio<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -124,14 +120,14 @@ public PowerRatio(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.PowerRatio;
 
         /// <summary>
-        ///     All units of measurement for the PowerRatio quantity.
+        ///     All units of measurement for the <see cref="PowerRatio{T}" /> quantity.
         /// </summary>
         public static PowerRatioUnit[] Units { get; } = Enum.GetValues(typeof(PowerRatioUnit)).Cast<PowerRatioUnit>().Except(new PowerRatioUnit[]{ PowerRatioUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DecibelWatt.
         /// </summary>
-        public static PowerRatio Zero { get; } = new PowerRatio(0, BaseUnit);
+        public static PowerRatio<T> Zero { get; } = new PowerRatio<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -140,7 +136,9 @@ public PowerRatio(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -156,26 +154,26 @@ public PowerRatio(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => PowerRatio.QuantityType;
+        public QuantityType Type => PowerRatio<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => PowerRatio.BaseDimensions;
+        public BaseDimensions Dimensions => PowerRatio<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get PowerRatio in DecibelMilliwatts.
+        ///     Get <see cref="PowerRatio{T}" /> in DecibelMilliwatts.
         /// </summary>
-        public double DecibelMilliwatts => As(PowerRatioUnit.DecibelMilliwatt);
+        public T DecibelMilliwatts => As(PowerRatioUnit.DecibelMilliwatt);
 
         /// <summary>
-        ///     Get PowerRatio in DecibelWatts.
+        ///     Get <see cref="PowerRatio{T}" /> in DecibelWatts.
         /// </summary>
-        public double DecibelWatts => As(PowerRatioUnit.DecibelWatt);
+        public T DecibelWatts => As(PowerRatioUnit.DecibelWatt);
 
         #endregion
 
@@ -207,33 +205,31 @@ public static string GetAbbreviation(PowerRatioUnit unit, IFormatProvider? provi
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get PowerRatio from DecibelMilliwatts.
+        ///     Get <see cref="PowerRatio{T}" /> from DecibelMilliwatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerRatio FromDecibelMilliwatts(QuantityValue decibelmilliwatts)
+        public static PowerRatio<T> FromDecibelMilliwatts(T decibelmilliwatts)
         {
-            double value = (double) decibelmilliwatts;
-            return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt);
+            return new PowerRatio<T>(decibelmilliwatts, PowerRatioUnit.DecibelMilliwatt);
         }
         /// <summary>
-        ///     Get PowerRatio from DecibelWatts.
+        ///     Get <see cref="PowerRatio{T}" /> from DecibelWatts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerRatio FromDecibelWatts(QuantityValue decibelwatts)
+        public static PowerRatio<T> FromDecibelWatts(T decibelwatts)
         {
-            double value = (double) decibelwatts;
-            return new PowerRatio(value, PowerRatioUnit.DecibelWatt);
+            return new PowerRatio<T>(decibelwatts, PowerRatioUnit.DecibelWatt);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PowerRatioUnit" /> to <see cref="PowerRatio" />.
+        ///     Dynamically convert from value and unit enum <see cref="PowerRatioUnit" /> to <see cref="PowerRatio{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>PowerRatio unit value.</returns>
-        public static PowerRatio From(QuantityValue value, PowerRatioUnit fromUnit)
+        /// <returns><see cref="PowerRatio{T}" /> unit value.</returns>
+        public static PowerRatio<T> From(T value, PowerRatioUnit fromUnit)
         {
-            return new PowerRatio((double)value, fromUnit);
+            return new PowerRatio<T>(value, fromUnit);
         }
 
         #endregion
@@ -262,7 +258,7 @@ public static PowerRatio From(QuantityValue value, PowerRatioUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static PowerRatio Parse(string str)
+        public static PowerRatio<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -290,9 +286,9 @@ public static PowerRatio Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static PowerRatio Parse(string str, IFormatProvider? provider)
+        public static PowerRatio<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<PowerRatio, PowerRatioUnit>(
+            return QuantityParser.Default.Parse<T, PowerRatio<T>, PowerRatioUnit>(
                 str,
                 provider,
                 From);
@@ -306,7 +302,7 @@ public static PowerRatio Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out PowerRatio result)
+        public static bool TryParse(string? str, out PowerRatio<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -321,9 +317,9 @@ public static bool TryParse(string? str, out PowerRatio result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out PowerRatio result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out PowerRatio<T> result)
         {
-            return QuantityParser.Default.TryParse<PowerRatio, PowerRatioUnit>(
+            return QuantityParser.Default.TryParse<T, PowerRatio<T>, PowerRatioUnit>(
                 str,
                 provider,
                 From,
@@ -385,50 +381,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static PowerRatio operator -(PowerRatio right)
+        public static PowerRatio<T> operator -(PowerRatio<T> right)
         {
-            return new PowerRatio(-right.Value, right.Unit);
+            return new PowerRatio<T>(-right.Value, right.Unit);
         }
 
-        /// <summary>Get <see cref="PowerRatio"/> from logarithmic addition of two <see cref="PowerRatio"/>.</summary>
-        public static PowerRatio operator +(PowerRatio left, PowerRatio right)
+        /// <summary>Get <see cref="PowerRatio{T}"/> from logarithmic addition of two <see cref="PowerRatio{T}"/>.</summary>
+        public static PowerRatio<T> operator +(PowerRatio<T> left, PowerRatio<T> right)
         {
             // Logarithmic addition
             // Formula: 10*log10(10^(x/10) + 10^(y/10))
-            return new PowerRatio(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
+            return new PowerRatio<T>(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
         }
 
-        /// <summary>Get <see cref="PowerRatio"/> from logarithmic subtraction of two <see cref="PowerRatio"/>.</summary>
-        public static PowerRatio operator -(PowerRatio left, PowerRatio right)
+        /// <summary>Get <see cref="PowerRatio{T}"/> from logarithmic subtraction of two <see cref="PowerRatio{T}"/>.</summary>
+        public static PowerRatio<T> operator -(PowerRatio<T> left, PowerRatio<T> right)
         {
             // Logarithmic subtraction
             // Formula: 10*log10(10^(x/10) - 10^(y/10))
-            return new PowerRatio(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
+            return new PowerRatio<T>(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit);
         }
 
-        /// <summary>Get <see cref="PowerRatio"/> from logarithmic multiplication of value and <see cref="PowerRatio"/>.</summary>
-        public static PowerRatio operator *(double left, PowerRatio right)
+        /// <summary>Get <see cref="PowerRatio{T}"/> from logarithmic multiplication of value and <see cref="PowerRatio{T}"/>.</summary>
+        public static PowerRatio<T> operator *(double left, PowerRatio<T> right)
         {
             // Logarithmic multiplication = addition
-            return new PowerRatio(left + right.Value, right.Unit);
+            return new PowerRatio<T>(left + right.Value, right.Unit);
         }
 
-        /// <summary>Get <see cref="PowerRatio"/> from logarithmic multiplication of value and <see cref="PowerRatio"/>.</summary>
-        public static PowerRatio operator *(PowerRatio left, double right)
+        /// <summary>Get <see cref="PowerRatio{T}"/> from logarithmic multiplication of value and <see cref="PowerRatio{T}"/>.</summary>
+        public static PowerRatio<T> operator *(PowerRatio<T> left, double right)
         {
             // Logarithmic multiplication = addition
-            return new PowerRatio(left.Value + (double)right, left.Unit);
+            return new PowerRatio<T>(left.Value + (double)right, left.Unit);
         }
 
-        /// <summary>Get <see cref="PowerRatio"/> from logarithmic division of <see cref="PowerRatio"/> by value.</summary>
-        public static PowerRatio operator /(PowerRatio left, double right)
+        /// <summary>Get <see cref="PowerRatio{T}"/> from logarithmic division of <see cref="PowerRatio{T}"/> by value.</summary>
+        public static PowerRatio<T> operator /(PowerRatio<T> left, double right)
         {
             // Logarithmic division = subtraction
-            return new PowerRatio(left.Value - (double)right, left.Unit);
+            return new PowerRatio<T>(left.Value - (double)right, left.Unit);
         }
 
-        /// <summary>Get ratio value from logarithmic division of <see cref="PowerRatio"/> by <see cref="PowerRatio"/>.</summary>
-        public static double operator /(PowerRatio left, PowerRatio right)
+        /// <summary>Get ratio value from logarithmic division of <see cref="PowerRatio{T}"/> by <see cref="PowerRatio{T}"/>.</summary>
+        public static double operator /(PowerRatio<T> left, PowerRatio<T> right)
         {
             // Logarithmic division = subtraction
             return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit));
@@ -439,39 +435,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(PowerRatio left, PowerRatio right)
+        public static bool operator <=(PowerRatio<T> left, PowerRatio<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(PowerRatio left, PowerRatio right)
+        public static bool operator >=(PowerRatio<T> left, PowerRatio<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(PowerRatio left, PowerRatio right)
+        public static bool operator <(PowerRatio<T> left, PowerRatio<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(PowerRatio left, PowerRatio right)
+        public static bool operator >(PowerRatio<T> left, PowerRatio<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(PowerRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(PowerRatio left, PowerRatio right)
+        /// <remarks>Consider using <see cref="Equals(PowerRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(PowerRatio<T> left, PowerRatio<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(PowerRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(PowerRatio left, PowerRatio right)
+        /// <remarks>Consider using <see cref="Equals(PowerRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(PowerRatio<T> left, PowerRatio<T> right)
         {
             return !(left == right);
         }
@@ -480,37 +476,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is PowerRatio objPowerRatio)) throw new ArgumentException("Expected type PowerRatio.", nameof(obj));
+            if(!(obj is PowerRatio<T> objPowerRatio)) throw new ArgumentException("Expected type PowerRatio.", nameof(obj));
 
             return CompareTo(objPowerRatio);
         }
 
         /// <inheritdoc />
-        public int CompareTo(PowerRatio other)
+        public int CompareTo(PowerRatio<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(PowerRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(PowerRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is PowerRatio objPowerRatio))
+            if(obj is null || !(obj is PowerRatio<T> objPowerRatio))
                 return false;
 
             return Equals(objPowerRatio);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(PowerRatio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(PowerRatio other)
+        /// <remarks>Consider using <see cref="Equals(PowerRatio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(PowerRatio<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another PowerRatio within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="PowerRatio{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -548,21 +544,19 @@ public bool Equals(PowerRatio other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(PowerRatio other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(PowerRatio<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current PowerRatio.</returns>
+        /// <returns>A hash code for the current <see cref="PowerRatio{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -576,17 +570,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(PowerRatioUnit unit)
+        public T As(PowerRatioUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -606,17 +600,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is PowerRatioUnit unitAsPowerRatioUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerRatioUnit)} is supported.", nameof(unit));
 
-            return As(unitAsPowerRatioUnit);
+            var asValue = As(unitAsPowerRatioUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<PowerRatioUnit>.As(PowerRatioUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this PowerRatio to another PowerRatio with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="PowerRatio{T}" /> to another <see cref="PowerRatio{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A PowerRatio with the specified unit.</returns>
-        public PowerRatio ToUnit(PowerRatioUnit unit)
+        /// <returns>A <see cref="PowerRatio{T}" /> with the specified unit.</returns>
+        public PowerRatio<T> ToUnit(PowerRatioUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new PowerRatio(convertedValue, unit);
+            return new PowerRatio<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -629,7 +628,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public PowerRatio ToUnit(UnitSystem unitSystem)
+        public PowerRatio<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -649,20 +648,26 @@ public PowerRatio ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PowerRatioUnit> IQuantity<PowerRatioUnit>.ToUnit(PowerRatioUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<PowerRatioUnit, T> IQuantityT<PowerRatioUnit, T>.ToUnit(PowerRatioUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<PowerRatioUnit> IQuantity<PowerRatioUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<PowerRatioUnit, T> IQuantityT<PowerRatioUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case PowerRatioUnit.DecibelMilliwatt: return _value - 30;
-                case PowerRatioUnit.DecibelWatt: return _value;
+                case PowerRatioUnit.DecibelMilliwatt: return Value - 30;
+                case PowerRatioUnit.DecibelWatt: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -673,16 +678,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal PowerRatio ToBaseUnit()
+        internal PowerRatio<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new PowerRatio(baseUnitValue, BaseUnit);
+            return new PowerRatio<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(PowerRatioUnit unit)
+        private T GetValueAs(PowerRatioUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -786,57 +791,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PowerRatio)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PowerRatio<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PowerRatio)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PowerRatio<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PowerRatio)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PowerRatio<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -846,33 +851,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(PowerRatio))
+            if(conversionType == typeof(PowerRatio<T>))
                 return this;
             else if(conversionType == typeof(PowerRatioUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return PowerRatio.QuantityType;
+                return PowerRatio<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return PowerRatio.Info;
+                return PowerRatio<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return PowerRatio.BaseDimensions;
+                return PowerRatio<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(PowerRatio)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(PowerRatio<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
index f0d45f6af0..e05ca97e5d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Pressure (symbol: P or p) is the ratio of force to the area over which that force is distributed. Pressure is force per unit area applied in a direction perpendicular to the surface of an object. Gauge pressure (also spelled gage pressure)[a] is the pressure relative to the local atmospheric or ambient pressure. Pressure is measured in any unit of force divided by any unit of area. The SI unit of pressure is the newton per square metre, which is called the pascal (Pa) after the seventeenth-century philosopher and scientist Blaise Pascal. A pressure of 1 Pa is small; it approximately equals the pressure exerted by a dollar bill resting flat on a table. Everyday pressures are often stated in kilopascals (1 kPa = 1000 Pa).
     /// </summary>
-    public partial struct Pressure : IQuantity<PressureUnit>, IEquatable<Pressure>, IComparable, IComparable<Pressure>, IConvertible, IFormattable
+    public partial struct Pressure<T> : IQuantityT<PressureUnit, T>, IEquatable<Pressure<T>>, IComparable, IComparable<Pressure<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -104,12 +100,12 @@ static Pressure()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Pressure(double value, PressureUnit unit)
+        public Pressure(T value, PressureUnit unit)
         {
             if(unit == PressureUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -121,14 +117,14 @@ public Pressure(double value, PressureUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Pressure(double value, UnitSystem unitSystem)
+        public Pressure(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -143,19 +139,19 @@ public Pressure(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Pressure, which is Pascal. All conversions go via this value.
+        ///     The base unit of <see cref="Pressure{T}" />, which is Pascal. All conversions go via this value.
         /// </summary>
         public static PressureUnit BaseUnit { get; } = PressureUnit.Pascal;
 
         /// <summary>
-        /// Represents the largest possible value of Pressure
+        /// Represents the largest possible value of <see cref="Pressure{T}" />
         /// </summary>
-        public static Pressure MaxValue { get; } = new Pressure(double.MaxValue, BaseUnit);
+        public static Pressure<T> MaxValue { get; } = new Pressure<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Pressure
+        /// Represents the smallest possible value of <see cref="Pressure{T}" />
         /// </summary>
-        public static Pressure MinValue { get; } = new Pressure(double.MinValue, BaseUnit);
+        public static Pressure<T> MinValue { get; } = new Pressure<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -164,14 +160,14 @@ public Pressure(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Pressure;
 
         /// <summary>
-        ///     All units of measurement for the Pressure quantity.
+        ///     All units of measurement for the <see cref="Pressure{T}" /> quantity.
         /// </summary>
         public static PressureUnit[] Units { get; } = Enum.GetValues(typeof(PressureUnit)).Cast<PressureUnit>().Except(new PressureUnit[]{ PressureUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Pascal.
         /// </summary>
-        public static Pressure Zero { get; } = new Pressure(0, BaseUnit);
+        public static Pressure<T> Zero { get; } = new Pressure<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -180,7 +176,9 @@ public Pressure(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -196,226 +194,226 @@ public Pressure(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Pressure.QuantityType;
+        public QuantityType Type => Pressure<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Pressure.BaseDimensions;
+        public BaseDimensions Dimensions => Pressure<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Pressure in Atmospheres.
+        ///     Get <see cref="Pressure{T}" /> in Atmospheres.
         /// </summary>
-        public double Atmospheres => As(PressureUnit.Atmosphere);
+        public T Atmospheres => As(PressureUnit.Atmosphere);
 
         /// <summary>
-        ///     Get Pressure in Bars.
+        ///     Get <see cref="Pressure{T}" /> in Bars.
         /// </summary>
-        public double Bars => As(PressureUnit.Bar);
+        public T Bars => As(PressureUnit.Bar);
 
         /// <summary>
-        ///     Get Pressure in Centibars.
+        ///     Get <see cref="Pressure{T}" /> in Centibars.
         /// </summary>
-        public double Centibars => As(PressureUnit.Centibar);
+        public T Centibars => As(PressureUnit.Centibar);
 
         /// <summary>
-        ///     Get Pressure in Decapascals.
+        ///     Get <see cref="Pressure{T}" /> in Decapascals.
         /// </summary>
-        public double Decapascals => As(PressureUnit.Decapascal);
+        public T Decapascals => As(PressureUnit.Decapascal);
 
         /// <summary>
-        ///     Get Pressure in Decibars.
+        ///     Get <see cref="Pressure{T}" /> in Decibars.
         /// </summary>
-        public double Decibars => As(PressureUnit.Decibar);
+        public T Decibars => As(PressureUnit.Decibar);
 
         /// <summary>
-        ///     Get Pressure in DynesPerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> in DynesPerSquareCentimeter.
         /// </summary>
-        public double DynesPerSquareCentimeter => As(PressureUnit.DynePerSquareCentimeter);
+        public T DynesPerSquareCentimeter => As(PressureUnit.DynePerSquareCentimeter);
 
         /// <summary>
-        ///     Get Pressure in FeetOfHead.
+        ///     Get <see cref="Pressure{T}" /> in FeetOfHead.
         /// </summary>
-        public double FeetOfHead => As(PressureUnit.FootOfHead);
+        public T FeetOfHead => As(PressureUnit.FootOfHead);
 
         /// <summary>
-        ///     Get Pressure in Gigapascals.
+        ///     Get <see cref="Pressure{T}" /> in Gigapascals.
         /// </summary>
-        public double Gigapascals => As(PressureUnit.Gigapascal);
+        public T Gigapascals => As(PressureUnit.Gigapascal);
 
         /// <summary>
-        ///     Get Pressure in Hectopascals.
+        ///     Get <see cref="Pressure{T}" /> in Hectopascals.
         /// </summary>
-        public double Hectopascals => As(PressureUnit.Hectopascal);
+        public T Hectopascals => As(PressureUnit.Hectopascal);
 
         /// <summary>
-        ///     Get Pressure in InchesOfMercury.
+        ///     Get <see cref="Pressure{T}" /> in InchesOfMercury.
         /// </summary>
-        public double InchesOfMercury => As(PressureUnit.InchOfMercury);
+        public T InchesOfMercury => As(PressureUnit.InchOfMercury);
 
         /// <summary>
-        ///     Get Pressure in InchesOfWaterColumn.
+        ///     Get <see cref="Pressure{T}" /> in InchesOfWaterColumn.
         /// </summary>
-        public double InchesOfWaterColumn => As(PressureUnit.InchOfWaterColumn);
+        public T InchesOfWaterColumn => As(PressureUnit.InchOfWaterColumn);
 
         /// <summary>
-        ///     Get Pressure in Kilobars.
+        ///     Get <see cref="Pressure{T}" /> in Kilobars.
         /// </summary>
-        public double Kilobars => As(PressureUnit.Kilobar);
+        public T Kilobars => As(PressureUnit.Kilobar);
 
         /// <summary>
-        ///     Get Pressure in KilogramsForcePerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> in KilogramsForcePerSquareCentimeter.
         /// </summary>
-        public double KilogramsForcePerSquareCentimeter => As(PressureUnit.KilogramForcePerSquareCentimeter);
+        public T KilogramsForcePerSquareCentimeter => As(PressureUnit.KilogramForcePerSquareCentimeter);
 
         /// <summary>
-        ///     Get Pressure in KilogramsForcePerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> in KilogramsForcePerSquareMeter.
         /// </summary>
-        public double KilogramsForcePerSquareMeter => As(PressureUnit.KilogramForcePerSquareMeter);
+        public T KilogramsForcePerSquareMeter => As(PressureUnit.KilogramForcePerSquareMeter);
 
         /// <summary>
-        ///     Get Pressure in KilogramsForcePerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> in KilogramsForcePerSquareMillimeter.
         /// </summary>
-        public double KilogramsForcePerSquareMillimeter => As(PressureUnit.KilogramForcePerSquareMillimeter);
+        public T KilogramsForcePerSquareMillimeter => As(PressureUnit.KilogramForcePerSquareMillimeter);
 
         /// <summary>
-        ///     Get Pressure in KilonewtonsPerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> in KilonewtonsPerSquareCentimeter.
         /// </summary>
-        public double KilonewtonsPerSquareCentimeter => As(PressureUnit.KilonewtonPerSquareCentimeter);
+        public T KilonewtonsPerSquareCentimeter => As(PressureUnit.KilonewtonPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Pressure in KilonewtonsPerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> in KilonewtonsPerSquareMeter.
         /// </summary>
-        public double KilonewtonsPerSquareMeter => As(PressureUnit.KilonewtonPerSquareMeter);
+        public T KilonewtonsPerSquareMeter => As(PressureUnit.KilonewtonPerSquareMeter);
 
         /// <summary>
-        ///     Get Pressure in KilonewtonsPerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> in KilonewtonsPerSquareMillimeter.
         /// </summary>
-        public double KilonewtonsPerSquareMillimeter => As(PressureUnit.KilonewtonPerSquareMillimeter);
+        public T KilonewtonsPerSquareMillimeter => As(PressureUnit.KilonewtonPerSquareMillimeter);
 
         /// <summary>
-        ///     Get Pressure in Kilopascals.
+        ///     Get <see cref="Pressure{T}" /> in Kilopascals.
         /// </summary>
-        public double Kilopascals => As(PressureUnit.Kilopascal);
+        public T Kilopascals => As(PressureUnit.Kilopascal);
 
         /// <summary>
-        ///     Get Pressure in KilopoundsForcePerSquareFoot.
+        ///     Get <see cref="Pressure{T}" /> in KilopoundsForcePerSquareFoot.
         /// </summary>
-        public double KilopoundsForcePerSquareFoot => As(PressureUnit.KilopoundForcePerSquareFoot);
+        public T KilopoundsForcePerSquareFoot => As(PressureUnit.KilopoundForcePerSquareFoot);
 
         /// <summary>
-        ///     Get Pressure in KilopoundsForcePerSquareInch.
+        ///     Get <see cref="Pressure{T}" /> in KilopoundsForcePerSquareInch.
         /// </summary>
-        public double KilopoundsForcePerSquareInch => As(PressureUnit.KilopoundForcePerSquareInch);
+        public T KilopoundsForcePerSquareInch => As(PressureUnit.KilopoundForcePerSquareInch);
 
         /// <summary>
-        ///     Get Pressure in Megabars.
+        ///     Get <see cref="Pressure{T}" /> in Megabars.
         /// </summary>
-        public double Megabars => As(PressureUnit.Megabar);
+        public T Megabars => As(PressureUnit.Megabar);
 
         /// <summary>
-        ///     Get Pressure in MeganewtonsPerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> in MeganewtonsPerSquareMeter.
         /// </summary>
-        public double MeganewtonsPerSquareMeter => As(PressureUnit.MeganewtonPerSquareMeter);
+        public T MeganewtonsPerSquareMeter => As(PressureUnit.MeganewtonPerSquareMeter);
 
         /// <summary>
-        ///     Get Pressure in Megapascals.
+        ///     Get <see cref="Pressure{T}" /> in Megapascals.
         /// </summary>
-        public double Megapascals => As(PressureUnit.Megapascal);
+        public T Megapascals => As(PressureUnit.Megapascal);
 
         /// <summary>
-        ///     Get Pressure in MetersOfHead.
+        ///     Get <see cref="Pressure{T}" /> in MetersOfHead.
         /// </summary>
-        public double MetersOfHead => As(PressureUnit.MeterOfHead);
+        public T MetersOfHead => As(PressureUnit.MeterOfHead);
 
         /// <summary>
-        ///     Get Pressure in Microbars.
+        ///     Get <see cref="Pressure{T}" /> in Microbars.
         /// </summary>
-        public double Microbars => As(PressureUnit.Microbar);
+        public T Microbars => As(PressureUnit.Microbar);
 
         /// <summary>
-        ///     Get Pressure in Micropascals.
+        ///     Get <see cref="Pressure{T}" /> in Micropascals.
         /// </summary>
-        public double Micropascals => As(PressureUnit.Micropascal);
+        public T Micropascals => As(PressureUnit.Micropascal);
 
         /// <summary>
-        ///     Get Pressure in Millibars.
+        ///     Get <see cref="Pressure{T}" /> in Millibars.
         /// </summary>
-        public double Millibars => As(PressureUnit.Millibar);
+        public T Millibars => As(PressureUnit.Millibar);
 
         /// <summary>
-        ///     Get Pressure in MillimetersOfMercury.
+        ///     Get <see cref="Pressure{T}" /> in MillimetersOfMercury.
         /// </summary>
-        public double MillimetersOfMercury => As(PressureUnit.MillimeterOfMercury);
+        public T MillimetersOfMercury => As(PressureUnit.MillimeterOfMercury);
 
         /// <summary>
-        ///     Get Pressure in Millipascals.
+        ///     Get <see cref="Pressure{T}" /> in Millipascals.
         /// </summary>
-        public double Millipascals => As(PressureUnit.Millipascal);
+        public T Millipascals => As(PressureUnit.Millipascal);
 
         /// <summary>
-        ///     Get Pressure in NewtonsPerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> in NewtonsPerSquareCentimeter.
         /// </summary>
-        public double NewtonsPerSquareCentimeter => As(PressureUnit.NewtonPerSquareCentimeter);
+        public T NewtonsPerSquareCentimeter => As(PressureUnit.NewtonPerSquareCentimeter);
 
         /// <summary>
-        ///     Get Pressure in NewtonsPerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> in NewtonsPerSquareMeter.
         /// </summary>
-        public double NewtonsPerSquareMeter => As(PressureUnit.NewtonPerSquareMeter);
+        public T NewtonsPerSquareMeter => As(PressureUnit.NewtonPerSquareMeter);
 
         /// <summary>
-        ///     Get Pressure in NewtonsPerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> in NewtonsPerSquareMillimeter.
         /// </summary>
-        public double NewtonsPerSquareMillimeter => As(PressureUnit.NewtonPerSquareMillimeter);
+        public T NewtonsPerSquareMillimeter => As(PressureUnit.NewtonPerSquareMillimeter);
 
         /// <summary>
-        ///     Get Pressure in Pascals.
+        ///     Get <see cref="Pressure{T}" /> in Pascals.
         /// </summary>
-        public double Pascals => As(PressureUnit.Pascal);
+        public T Pascals => As(PressureUnit.Pascal);
 
         /// <summary>
-        ///     Get Pressure in PoundsForcePerSquareFoot.
+        ///     Get <see cref="Pressure{T}" /> in PoundsForcePerSquareFoot.
         /// </summary>
-        public double PoundsForcePerSquareFoot => As(PressureUnit.PoundForcePerSquareFoot);
+        public T PoundsForcePerSquareFoot => As(PressureUnit.PoundForcePerSquareFoot);
 
         /// <summary>
-        ///     Get Pressure in PoundsForcePerSquareInch.
+        ///     Get <see cref="Pressure{T}" /> in PoundsForcePerSquareInch.
         /// </summary>
-        public double PoundsForcePerSquareInch => As(PressureUnit.PoundForcePerSquareInch);
+        public T PoundsForcePerSquareInch => As(PressureUnit.PoundForcePerSquareInch);
 
         /// <summary>
-        ///     Get Pressure in PoundsPerInchSecondSquared.
+        ///     Get <see cref="Pressure{T}" /> in PoundsPerInchSecondSquared.
         /// </summary>
-        public double PoundsPerInchSecondSquared => As(PressureUnit.PoundPerInchSecondSquared);
+        public T PoundsPerInchSecondSquared => As(PressureUnit.PoundPerInchSecondSquared);
 
         /// <summary>
-        ///     Get Pressure in TechnicalAtmospheres.
+        ///     Get <see cref="Pressure{T}" /> in TechnicalAtmospheres.
         /// </summary>
-        public double TechnicalAtmospheres => As(PressureUnit.TechnicalAtmosphere);
+        public T TechnicalAtmospheres => As(PressureUnit.TechnicalAtmosphere);
 
         /// <summary>
-        ///     Get Pressure in TonnesForcePerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> in TonnesForcePerSquareCentimeter.
         /// </summary>
-        public double TonnesForcePerSquareCentimeter => As(PressureUnit.TonneForcePerSquareCentimeter);
+        public T TonnesForcePerSquareCentimeter => As(PressureUnit.TonneForcePerSquareCentimeter);
 
         /// <summary>
-        ///     Get Pressure in TonnesForcePerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> in TonnesForcePerSquareMeter.
         /// </summary>
-        public double TonnesForcePerSquareMeter => As(PressureUnit.TonneForcePerSquareMeter);
+        public T TonnesForcePerSquareMeter => As(PressureUnit.TonneForcePerSquareMeter);
 
         /// <summary>
-        ///     Get Pressure in TonnesForcePerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> in TonnesForcePerSquareMillimeter.
         /// </summary>
-        public double TonnesForcePerSquareMillimeter => As(PressureUnit.TonneForcePerSquareMillimeter);
+        public T TonnesForcePerSquareMillimeter => As(PressureUnit.TonneForcePerSquareMillimeter);
 
         /// <summary>
-        ///     Get Pressure in Torrs.
+        ///     Get <see cref="Pressure{T}" /> in Torrs.
         /// </summary>
-        public double Torrs => As(PressureUnit.Torr);
+        public T Torrs => As(PressureUnit.Torr);
 
         #endregion
 
@@ -447,393 +445,351 @@ public static string GetAbbreviation(PressureUnit unit, IFormatProvider? provide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Pressure from Atmospheres.
+        ///     Get <see cref="Pressure{T}" /> from Atmospheres.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromAtmospheres(QuantityValue atmospheres)
+        public static Pressure<T> FromAtmospheres(T atmospheres)
         {
-            double value = (double) atmospheres;
-            return new Pressure(value, PressureUnit.Atmosphere);
+            return new Pressure<T>(atmospheres, PressureUnit.Atmosphere);
         }
         /// <summary>
-        ///     Get Pressure from Bars.
+        ///     Get <see cref="Pressure{T}" /> from Bars.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromBars(QuantityValue bars)
+        public static Pressure<T> FromBars(T bars)
         {
-            double value = (double) bars;
-            return new Pressure(value, PressureUnit.Bar);
+            return new Pressure<T>(bars, PressureUnit.Bar);
         }
         /// <summary>
-        ///     Get Pressure from Centibars.
+        ///     Get <see cref="Pressure{T}" /> from Centibars.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromCentibars(QuantityValue centibars)
+        public static Pressure<T> FromCentibars(T centibars)
         {
-            double value = (double) centibars;
-            return new Pressure(value, PressureUnit.Centibar);
+            return new Pressure<T>(centibars, PressureUnit.Centibar);
         }
         /// <summary>
-        ///     Get Pressure from Decapascals.
+        ///     Get <see cref="Pressure{T}" /> from Decapascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDecapascals(QuantityValue decapascals)
+        public static Pressure<T> FromDecapascals(T decapascals)
         {
-            double value = (double) decapascals;
-            return new Pressure(value, PressureUnit.Decapascal);
+            return new Pressure<T>(decapascals, PressureUnit.Decapascal);
         }
         /// <summary>
-        ///     Get Pressure from Decibars.
+        ///     Get <see cref="Pressure{T}" /> from Decibars.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDecibars(QuantityValue decibars)
+        public static Pressure<T> FromDecibars(T decibars)
         {
-            double value = (double) decibars;
-            return new Pressure(value, PressureUnit.Decibar);
+            return new Pressure<T>(decibars, PressureUnit.Decibar);
         }
         /// <summary>
-        ///     Get Pressure from DynesPerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> from DynesPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDynesPerSquareCentimeter(QuantityValue dynespersquarecentimeter)
+        public static Pressure<T> FromDynesPerSquareCentimeter(T dynespersquarecentimeter)
         {
-            double value = (double) dynespersquarecentimeter;
-            return new Pressure(value, PressureUnit.DynePerSquareCentimeter);
+            return new Pressure<T>(dynespersquarecentimeter, PressureUnit.DynePerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Pressure from FeetOfHead.
+        ///     Get <see cref="Pressure{T}" /> from FeetOfHead.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromFeetOfHead(QuantityValue feetofhead)
+        public static Pressure<T> FromFeetOfHead(T feetofhead)
         {
-            double value = (double) feetofhead;
-            return new Pressure(value, PressureUnit.FootOfHead);
+            return new Pressure<T>(feetofhead, PressureUnit.FootOfHead);
         }
         /// <summary>
-        ///     Get Pressure from Gigapascals.
+        ///     Get <see cref="Pressure{T}" /> from Gigapascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromGigapascals(QuantityValue gigapascals)
+        public static Pressure<T> FromGigapascals(T gigapascals)
         {
-            double value = (double) gigapascals;
-            return new Pressure(value, PressureUnit.Gigapascal);
+            return new Pressure<T>(gigapascals, PressureUnit.Gigapascal);
         }
         /// <summary>
-        ///     Get Pressure from Hectopascals.
+        ///     Get <see cref="Pressure{T}" /> from Hectopascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromHectopascals(QuantityValue hectopascals)
+        public static Pressure<T> FromHectopascals(T hectopascals)
         {
-            double value = (double) hectopascals;
-            return new Pressure(value, PressureUnit.Hectopascal);
+            return new Pressure<T>(hectopascals, PressureUnit.Hectopascal);
         }
         /// <summary>
-        ///     Get Pressure from InchesOfMercury.
+        ///     Get <see cref="Pressure{T}" /> from InchesOfMercury.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromInchesOfMercury(QuantityValue inchesofmercury)
+        public static Pressure<T> FromInchesOfMercury(T inchesofmercury)
         {
-            double value = (double) inchesofmercury;
-            return new Pressure(value, PressureUnit.InchOfMercury);
+            return new Pressure<T>(inchesofmercury, PressureUnit.InchOfMercury);
         }
         /// <summary>
-        ///     Get Pressure from InchesOfWaterColumn.
+        ///     Get <see cref="Pressure{T}" /> from InchesOfWaterColumn.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromInchesOfWaterColumn(QuantityValue inchesofwatercolumn)
+        public static Pressure<T> FromInchesOfWaterColumn(T inchesofwatercolumn)
         {
-            double value = (double) inchesofwatercolumn;
-            return new Pressure(value, PressureUnit.InchOfWaterColumn);
+            return new Pressure<T>(inchesofwatercolumn, PressureUnit.InchOfWaterColumn);
         }
         /// <summary>
-        ///     Get Pressure from Kilobars.
+        ///     Get <see cref="Pressure{T}" /> from Kilobars.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilobars(QuantityValue kilobars)
+        public static Pressure<T> FromKilobars(T kilobars)
         {
-            double value = (double) kilobars;
-            return new Pressure(value, PressureUnit.Kilobar);
+            return new Pressure<T>(kilobars, PressureUnit.Kilobar);
         }
         /// <summary>
-        ///     Get Pressure from KilogramsForcePerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> from KilogramsForcePerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareCentimeter(QuantityValue kilogramsforcepersquarecentimeter)
+        public static Pressure<T> FromKilogramsForcePerSquareCentimeter(T kilogramsforcepersquarecentimeter)
         {
-            double value = (double) kilogramsforcepersquarecentimeter;
-            return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter);
+            return new Pressure<T>(kilogramsforcepersquarecentimeter, PressureUnit.KilogramForcePerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Pressure from KilogramsForcePerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> from KilogramsForcePerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareMeter(QuantityValue kilogramsforcepersquaremeter)
+        public static Pressure<T> FromKilogramsForcePerSquareMeter(T kilogramsforcepersquaremeter)
         {
-            double value = (double) kilogramsforcepersquaremeter;
-            return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter);
+            return new Pressure<T>(kilogramsforcepersquaremeter, PressureUnit.KilogramForcePerSquareMeter);
         }
         /// <summary>
-        ///     Get Pressure from KilogramsForcePerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> from KilogramsForcePerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareMillimeter(QuantityValue kilogramsforcepersquaremillimeter)
+        public static Pressure<T> FromKilogramsForcePerSquareMillimeter(T kilogramsforcepersquaremillimeter)
         {
-            double value = (double) kilogramsforcepersquaremillimeter;
-            return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter);
+            return new Pressure<T>(kilogramsforcepersquaremillimeter, PressureUnit.KilogramForcePerSquareMillimeter);
         }
         /// <summary>
-        ///     Get Pressure from KilonewtonsPerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> from KilonewtonsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareCentimeter(QuantityValue kilonewtonspersquarecentimeter)
+        public static Pressure<T> FromKilonewtonsPerSquareCentimeter(T kilonewtonspersquarecentimeter)
         {
-            double value = (double) kilonewtonspersquarecentimeter;
-            return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter);
+            return new Pressure<T>(kilonewtonspersquarecentimeter, PressureUnit.KilonewtonPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Pressure from KilonewtonsPerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> from KilonewtonsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareMeter(QuantityValue kilonewtonspersquaremeter)
+        public static Pressure<T> FromKilonewtonsPerSquareMeter(T kilonewtonspersquaremeter)
         {
-            double value = (double) kilonewtonspersquaremeter;
-            return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter);
+            return new Pressure<T>(kilonewtonspersquaremeter, PressureUnit.KilonewtonPerSquareMeter);
         }
         /// <summary>
-        ///     Get Pressure from KilonewtonsPerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> from KilonewtonsPerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareMillimeter(QuantityValue kilonewtonspersquaremillimeter)
+        public static Pressure<T> FromKilonewtonsPerSquareMillimeter(T kilonewtonspersquaremillimeter)
         {
-            double value = (double) kilonewtonspersquaremillimeter;
-            return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter);
+            return new Pressure<T>(kilonewtonspersquaremillimeter, PressureUnit.KilonewtonPerSquareMillimeter);
         }
         /// <summary>
-        ///     Get Pressure from Kilopascals.
+        ///     Get <see cref="Pressure{T}" /> from Kilopascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopascals(QuantityValue kilopascals)
+        public static Pressure<T> FromKilopascals(T kilopascals)
         {
-            double value = (double) kilopascals;
-            return new Pressure(value, PressureUnit.Kilopascal);
+            return new Pressure<T>(kilopascals, PressureUnit.Kilopascal);
         }
         /// <summary>
-        ///     Get Pressure from KilopoundsForcePerSquareFoot.
+        ///     Get <see cref="Pressure{T}" /> from KilopoundsForcePerSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareFoot(QuantityValue kilopoundsforcepersquarefoot)
+        public static Pressure<T> FromKilopoundsForcePerSquareFoot(T kilopoundsforcepersquarefoot)
         {
-            double value = (double) kilopoundsforcepersquarefoot;
-            return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot);
+            return new Pressure<T>(kilopoundsforcepersquarefoot, PressureUnit.KilopoundForcePerSquareFoot);
         }
         /// <summary>
-        ///     Get Pressure from KilopoundsForcePerSquareInch.
+        ///     Get <see cref="Pressure{T}" /> from KilopoundsForcePerSquareInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareInch(QuantityValue kilopoundsforcepersquareinch)
+        public static Pressure<T> FromKilopoundsForcePerSquareInch(T kilopoundsforcepersquareinch)
         {
-            double value = (double) kilopoundsforcepersquareinch;
-            return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch);
+            return new Pressure<T>(kilopoundsforcepersquareinch, PressureUnit.KilopoundForcePerSquareInch);
         }
         /// <summary>
-        ///     Get Pressure from Megabars.
+        ///     Get <see cref="Pressure{T}" /> from Megabars.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMegabars(QuantityValue megabars)
+        public static Pressure<T> FromMegabars(T megabars)
         {
-            double value = (double) megabars;
-            return new Pressure(value, PressureUnit.Megabar);
+            return new Pressure<T>(megabars, PressureUnit.Megabar);
         }
         /// <summary>
-        ///     Get Pressure from MeganewtonsPerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> from MeganewtonsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMeganewtonsPerSquareMeter(QuantityValue meganewtonspersquaremeter)
+        public static Pressure<T> FromMeganewtonsPerSquareMeter(T meganewtonspersquaremeter)
         {
-            double value = (double) meganewtonspersquaremeter;
-            return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter);
+            return new Pressure<T>(meganewtonspersquaremeter, PressureUnit.MeganewtonPerSquareMeter);
         }
         /// <summary>
-        ///     Get Pressure from Megapascals.
+        ///     Get <see cref="Pressure{T}" /> from Megapascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMegapascals(QuantityValue megapascals)
+        public static Pressure<T> FromMegapascals(T megapascals)
         {
-            double value = (double) megapascals;
-            return new Pressure(value, PressureUnit.Megapascal);
+            return new Pressure<T>(megapascals, PressureUnit.Megapascal);
         }
         /// <summary>
-        ///     Get Pressure from MetersOfHead.
+        ///     Get <see cref="Pressure{T}" /> from MetersOfHead.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMetersOfHead(QuantityValue metersofhead)
+        public static Pressure<T> FromMetersOfHead(T metersofhead)
         {
-            double value = (double) metersofhead;
-            return new Pressure(value, PressureUnit.MeterOfHead);
+            return new Pressure<T>(metersofhead, PressureUnit.MeterOfHead);
         }
         /// <summary>
-        ///     Get Pressure from Microbars.
+        ///     Get <see cref="Pressure{T}" /> from Microbars.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMicrobars(QuantityValue microbars)
+        public static Pressure<T> FromMicrobars(T microbars)
         {
-            double value = (double) microbars;
-            return new Pressure(value, PressureUnit.Microbar);
+            return new Pressure<T>(microbars, PressureUnit.Microbar);
         }
         /// <summary>
-        ///     Get Pressure from Micropascals.
+        ///     Get <see cref="Pressure{T}" /> from Micropascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMicropascals(QuantityValue micropascals)
+        public static Pressure<T> FromMicropascals(T micropascals)
         {
-            double value = (double) micropascals;
-            return new Pressure(value, PressureUnit.Micropascal);
+            return new Pressure<T>(micropascals, PressureUnit.Micropascal);
         }
         /// <summary>
-        ///     Get Pressure from Millibars.
+        ///     Get <see cref="Pressure{T}" /> from Millibars.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillibars(QuantityValue millibars)
+        public static Pressure<T> FromMillibars(T millibars)
         {
-            double value = (double) millibars;
-            return new Pressure(value, PressureUnit.Millibar);
+            return new Pressure<T>(millibars, PressureUnit.Millibar);
         }
         /// <summary>
-        ///     Get Pressure from MillimetersOfMercury.
+        ///     Get <see cref="Pressure{T}" /> from MillimetersOfMercury.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillimetersOfMercury(QuantityValue millimetersofmercury)
+        public static Pressure<T> FromMillimetersOfMercury(T millimetersofmercury)
         {
-            double value = (double) millimetersofmercury;
-            return new Pressure(value, PressureUnit.MillimeterOfMercury);
+            return new Pressure<T>(millimetersofmercury, PressureUnit.MillimeterOfMercury);
         }
         /// <summary>
-        ///     Get Pressure from Millipascals.
+        ///     Get <see cref="Pressure{T}" /> from Millipascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillipascals(QuantityValue millipascals)
+        public static Pressure<T> FromMillipascals(T millipascals)
         {
-            double value = (double) millipascals;
-            return new Pressure(value, PressureUnit.Millipascal);
+            return new Pressure<T>(millipascals, PressureUnit.Millipascal);
         }
         /// <summary>
-        ///     Get Pressure from NewtonsPerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> from NewtonsPerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareCentimeter(QuantityValue newtonspersquarecentimeter)
+        public static Pressure<T> FromNewtonsPerSquareCentimeter(T newtonspersquarecentimeter)
         {
-            double value = (double) newtonspersquarecentimeter;
-            return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter);
+            return new Pressure<T>(newtonspersquarecentimeter, PressureUnit.NewtonPerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Pressure from NewtonsPerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> from NewtonsPerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareMeter(QuantityValue newtonspersquaremeter)
+        public static Pressure<T> FromNewtonsPerSquareMeter(T newtonspersquaremeter)
         {
-            double value = (double) newtonspersquaremeter;
-            return new Pressure(value, PressureUnit.NewtonPerSquareMeter);
+            return new Pressure<T>(newtonspersquaremeter, PressureUnit.NewtonPerSquareMeter);
         }
         /// <summary>
-        ///     Get Pressure from NewtonsPerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> from NewtonsPerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareMillimeter(QuantityValue newtonspersquaremillimeter)
+        public static Pressure<T> FromNewtonsPerSquareMillimeter(T newtonspersquaremillimeter)
         {
-            double value = (double) newtonspersquaremillimeter;
-            return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter);
+            return new Pressure<T>(newtonspersquaremillimeter, PressureUnit.NewtonPerSquareMillimeter);
         }
         /// <summary>
-        ///     Get Pressure from Pascals.
+        ///     Get <see cref="Pressure{T}" /> from Pascals.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPascals(QuantityValue pascals)
+        public static Pressure<T> FromPascals(T pascals)
         {
-            double value = (double) pascals;
-            return new Pressure(value, PressureUnit.Pascal);
+            return new Pressure<T>(pascals, PressureUnit.Pascal);
         }
         /// <summary>
-        ///     Get Pressure from PoundsForcePerSquareFoot.
+        ///     Get <see cref="Pressure{T}" /> from PoundsForcePerSquareFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareFoot(QuantityValue poundsforcepersquarefoot)
+        public static Pressure<T> FromPoundsForcePerSquareFoot(T poundsforcepersquarefoot)
         {
-            double value = (double) poundsforcepersquarefoot;
-            return new Pressure(value, PressureUnit.PoundForcePerSquareFoot);
+            return new Pressure<T>(poundsforcepersquarefoot, PressureUnit.PoundForcePerSquareFoot);
         }
         /// <summary>
-        ///     Get Pressure from PoundsForcePerSquareInch.
+        ///     Get <see cref="Pressure{T}" /> from PoundsForcePerSquareInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareInch(QuantityValue poundsforcepersquareinch)
+        public static Pressure<T> FromPoundsForcePerSquareInch(T poundsforcepersquareinch)
         {
-            double value = (double) poundsforcepersquareinch;
-            return new Pressure(value, PressureUnit.PoundForcePerSquareInch);
+            return new Pressure<T>(poundsforcepersquareinch, PressureUnit.PoundForcePerSquareInch);
         }
         /// <summary>
-        ///     Get Pressure from PoundsPerInchSecondSquared.
+        ///     Get <see cref="Pressure{T}" /> from PoundsPerInchSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsPerInchSecondSquared(QuantityValue poundsperinchsecondsquared)
+        public static Pressure<T> FromPoundsPerInchSecondSquared(T poundsperinchsecondsquared)
         {
-            double value = (double) poundsperinchsecondsquared;
-            return new Pressure(value, PressureUnit.PoundPerInchSecondSquared);
+            return new Pressure<T>(poundsperinchsecondsquared, PressureUnit.PoundPerInchSecondSquared);
         }
         /// <summary>
-        ///     Get Pressure from TechnicalAtmospheres.
+        ///     Get <see cref="Pressure{T}" /> from TechnicalAtmospheres.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTechnicalAtmospheres(QuantityValue technicalatmospheres)
+        public static Pressure<T> FromTechnicalAtmospheres(T technicalatmospheres)
         {
-            double value = (double) technicalatmospheres;
-            return new Pressure(value, PressureUnit.TechnicalAtmosphere);
+            return new Pressure<T>(technicalatmospheres, PressureUnit.TechnicalAtmosphere);
         }
         /// <summary>
-        ///     Get Pressure from TonnesForcePerSquareCentimeter.
+        ///     Get <see cref="Pressure{T}" /> from TonnesForcePerSquareCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareCentimeter(QuantityValue tonnesforcepersquarecentimeter)
+        public static Pressure<T> FromTonnesForcePerSquareCentimeter(T tonnesforcepersquarecentimeter)
         {
-            double value = (double) tonnesforcepersquarecentimeter;
-            return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter);
+            return new Pressure<T>(tonnesforcepersquarecentimeter, PressureUnit.TonneForcePerSquareCentimeter);
         }
         /// <summary>
-        ///     Get Pressure from TonnesForcePerSquareMeter.
+        ///     Get <see cref="Pressure{T}" /> from TonnesForcePerSquareMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareMeter(QuantityValue tonnesforcepersquaremeter)
+        public static Pressure<T> FromTonnesForcePerSquareMeter(T tonnesforcepersquaremeter)
         {
-            double value = (double) tonnesforcepersquaremeter;
-            return new Pressure(value, PressureUnit.TonneForcePerSquareMeter);
+            return new Pressure<T>(tonnesforcepersquaremeter, PressureUnit.TonneForcePerSquareMeter);
         }
         /// <summary>
-        ///     Get Pressure from TonnesForcePerSquareMillimeter.
+        ///     Get <see cref="Pressure{T}" /> from TonnesForcePerSquareMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareMillimeter(QuantityValue tonnesforcepersquaremillimeter)
+        public static Pressure<T> FromTonnesForcePerSquareMillimeter(T tonnesforcepersquaremillimeter)
         {
-            double value = (double) tonnesforcepersquaremillimeter;
-            return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter);
+            return new Pressure<T>(tonnesforcepersquaremillimeter, PressureUnit.TonneForcePerSquareMillimeter);
         }
         /// <summary>
-        ///     Get Pressure from Torrs.
+        ///     Get <see cref="Pressure{T}" /> from Torrs.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTorrs(QuantityValue torrs)
+        public static Pressure<T> FromTorrs(T torrs)
         {
-            double value = (double) torrs;
-            return new Pressure(value, PressureUnit.Torr);
+            return new Pressure<T>(torrs, PressureUnit.Torr);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PressureUnit" /> to <see cref="Pressure" />.
+        ///     Dynamically convert from value and unit enum <see cref="PressureUnit" /> to <see cref="Pressure{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Pressure unit value.</returns>
-        public static Pressure From(QuantityValue value, PressureUnit fromUnit)
+        /// <returns><see cref="Pressure{T}" /> unit value.</returns>
+        public static Pressure<T> From(T value, PressureUnit fromUnit)
         {
-            return new Pressure((double)value, fromUnit);
+            return new Pressure<T>(value, fromUnit);
         }
 
         #endregion
@@ -862,7 +818,7 @@ public static Pressure From(QuantityValue value, PressureUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Pressure Parse(string str)
+        public static Pressure<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -890,9 +846,9 @@ public static Pressure Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Pressure Parse(string str, IFormatProvider? provider)
+        public static Pressure<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Pressure, PressureUnit>(
+            return QuantityParser.Default.Parse<T, Pressure<T>, PressureUnit>(
                 str,
                 provider,
                 From);
@@ -906,7 +862,7 @@ public static Pressure Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Pressure result)
+        public static bool TryParse(string? str, out Pressure<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -921,9 +877,9 @@ public static bool TryParse(string? str, out Pressure result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Pressure result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Pressure<T> result)
         {
-            return QuantityParser.Default.TryParse<Pressure, PressureUnit>(
+            return QuantityParser.Default.TryParse<T, Pressure<T>, PressureUnit>(
                 str,
                 provider,
                 From,
@@ -985,45 +941,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Press
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Pressure operator -(Pressure right)
+        public static Pressure<T> operator -(Pressure<T> right)
         {
-            return new Pressure(-right.Value, right.Unit);
+            return new Pressure<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from adding two <see cref="Pressure"/>.</summary>
-        public static Pressure operator +(Pressure left, Pressure right)
+        /// <summary>Get <see cref="Pressure{T}"/> from adding two <see cref="Pressure{T}"/>.</summary>
+        public static Pressure<T> operator +(Pressure<T> left, Pressure<T> right)
         {
-            return new Pressure(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Pressure<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from subtracting two <see cref="Pressure"/>.</summary>
-        public static Pressure operator -(Pressure left, Pressure right)
+        /// <summary>Get <see cref="Pressure{T}"/> from subtracting two <see cref="Pressure{T}"/>.</summary>
+        public static Pressure<T> operator -(Pressure<T> left, Pressure<T> right)
         {
-            return new Pressure(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Pressure<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from multiplying value and <see cref="Pressure"/>.</summary>
-        public static Pressure operator *(double left, Pressure right)
+        /// <summary>Get <see cref="Pressure{T}"/> from multiplying value and <see cref="Pressure{T}"/>.</summary>
+        public static Pressure<T> operator *(T left, Pressure<T> right)
         {
-            return new Pressure(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Pressure<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from multiplying value and <see cref="Pressure"/>.</summary>
-        public static Pressure operator *(Pressure left, double right)
+        /// <summary>Get <see cref="Pressure{T}"/> from multiplying value and <see cref="Pressure{T}"/>.</summary>
+        public static Pressure<T> operator *(Pressure<T> left, T right)
         {
-            return new Pressure(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Pressure<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Pressure"/> from dividing <see cref="Pressure"/> by value.</summary>
-        public static Pressure operator /(Pressure left, double right)
+        /// <summary>Get <see cref="Pressure{T}"/> from dividing <see cref="Pressure{T}"/> by value.</summary>
+        public static Pressure<T> operator /(Pressure<T> left, T right)
         {
-            return new Pressure(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Pressure<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Pressure"/> by <see cref="Pressure"/>.</summary>
-        public static double operator /(Pressure left, Pressure right)
+        /// <summary>Get ratio value from dividing <see cref="Pressure{T}"/> by <see cref="Pressure{T}"/>.</summary>
+        public static T operator /(Pressure<T> left, Pressure<T> right)
         {
-            return left.Pascals / right.Pascals;
+            return CompiledLambdas.Divide(left.Pascals, right.Pascals);
         }
 
         #endregion
@@ -1031,39 +992,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Press
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Pressure left, Pressure right)
+        public static bool operator <=(Pressure<T> left, Pressure<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Pressure left, Pressure right)
+        public static bool operator >=(Pressure<T> left, Pressure<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Pressure left, Pressure right)
+        public static bool operator <(Pressure<T> left, Pressure<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Pressure left, Pressure right)
+        public static bool operator >(Pressure<T> left, Pressure<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Pressure, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Pressure left, Pressure right)
+        /// <remarks>Consider using <see cref="Equals(Pressure{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Pressure<T> left, Pressure<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Pressure, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Pressure left, Pressure right)
+        /// <remarks>Consider using <see cref="Equals(Pressure{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Pressure<T> left, Pressure<T> right)
         {
             return !(left == right);
         }
@@ -1072,37 +1033,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Press
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Pressure objPressure)) throw new ArgumentException("Expected type Pressure.", nameof(obj));
+            if(!(obj is Pressure<T> objPressure)) throw new ArgumentException("Expected type Pressure.", nameof(obj));
 
             return CompareTo(objPressure);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Pressure other)
+        public int CompareTo(Pressure<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Pressure, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Pressure{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Pressure objPressure))
+            if(obj is null || !(obj is Pressure<T> objPressure))
                 return false;
 
             return Equals(objPressure);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Pressure, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Pressure other)
+        /// <remarks>Consider using <see cref="Equals(Pressure{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Pressure<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Pressure within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Pressure{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1140,21 +1101,19 @@ public bool Equals(Pressure other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Pressure other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Pressure<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Pressure.</returns>
+        /// <returns>A hash code for the current <see cref="Pressure{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1168,17 +1127,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(PressureUnit unit)
+        public T As(PressureUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1198,17 +1157,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is PressureUnit unitAsPressureUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureUnit)} is supported.", nameof(unit));
 
-            return As(unitAsPressureUnit);
+            var asValue = As(unitAsPressureUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<PressureUnit>.As(PressureUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Pressure to another Pressure with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Pressure{T}" /> to another <see cref="Pressure{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Pressure with the specified unit.</returns>
-        public Pressure ToUnit(PressureUnit unit)
+        /// <returns>A <see cref="Pressure{T}" /> with the specified unit.</returns>
+        public Pressure<T> ToUnit(PressureUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Pressure(convertedValue, unit);
+            return new Pressure<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1221,7 +1185,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Pressure ToUnit(UnitSystem unitSystem)
+        public Pressure<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1241,60 +1205,66 @@ public Pressure ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PressureUnit> IQuantity<PressureUnit>.ToUnit(PressureUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<PressureUnit, T> IQuantityT<PressureUnit, T>.ToUnit(PressureUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<PressureUnit> IQuantity<PressureUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<PressureUnit, T> IQuantityT<PressureUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case PressureUnit.Atmosphere: return _value*1.01325*1e5;
-                case PressureUnit.Bar: return _value*1e5;
-                case PressureUnit.Centibar: return (_value*1e5) * 1e-2d;
-                case PressureUnit.Decapascal: return (_value) * 1e1d;
-                case PressureUnit.Decibar: return (_value*1e5) * 1e-1d;
-                case PressureUnit.DynePerSquareCentimeter: return _value*1.0e-1;
-                case PressureUnit.FootOfHead: return _value*2989.0669;
-                case PressureUnit.Gigapascal: return (_value) * 1e9d;
-                case PressureUnit.Hectopascal: return (_value) * 1e2d;
-                case PressureUnit.InchOfMercury: return _value/2.95299830714159e-4;
-                case PressureUnit.InchOfWaterColumn: return _value*249.08890833333;
-                case PressureUnit.Kilobar: return (_value*1e5) * 1e3d;
-                case PressureUnit.KilogramForcePerSquareCentimeter: return _value*9.80665e4;
-                case PressureUnit.KilogramForcePerSquareMeter: return _value*9.80665019960652;
-                case PressureUnit.KilogramForcePerSquareMillimeter: return _value*9.80665e6;
-                case PressureUnit.KilonewtonPerSquareCentimeter: return (_value*1e4) * 1e3d;
-                case PressureUnit.KilonewtonPerSquareMeter: return (_value) * 1e3d;
-                case PressureUnit.KilonewtonPerSquareMillimeter: return (_value*1e6) * 1e3d;
-                case PressureUnit.Kilopascal: return (_value) * 1e3d;
-                case PressureUnit.KilopoundForcePerSquareFoot: return (_value*4.788025898033584e1) * 1e3d;
-                case PressureUnit.KilopoundForcePerSquareInch: return (_value*6.894757293168361e3) * 1e3d;
-                case PressureUnit.Megabar: return (_value*1e5) * 1e6d;
-                case PressureUnit.MeganewtonPerSquareMeter: return (_value) * 1e6d;
-                case PressureUnit.Megapascal: return (_value) * 1e6d;
-                case PressureUnit.MeterOfHead: return _value*9804.139432;
-                case PressureUnit.Microbar: return (_value*1e5) * 1e-6d;
-                case PressureUnit.Micropascal: return (_value) * 1e-6d;
-                case PressureUnit.Millibar: return (_value*1e5) * 1e-3d;
-                case PressureUnit.MillimeterOfMercury: return _value/7.50061561302643e-3;
-                case PressureUnit.Millipascal: return (_value) * 1e-3d;
-                case PressureUnit.NewtonPerSquareCentimeter: return _value*1e4;
-                case PressureUnit.NewtonPerSquareMeter: return _value;
-                case PressureUnit.NewtonPerSquareMillimeter: return _value*1e6;
-                case PressureUnit.Pascal: return _value;
-                case PressureUnit.PoundForcePerSquareFoot: return _value*4.788025898033584e1;
-                case PressureUnit.PoundForcePerSquareInch: return _value*6.894757293168361e3;
-                case PressureUnit.PoundPerInchSecondSquared: return _value*1.785796732283465e1;
-                case PressureUnit.TechnicalAtmosphere: return _value*9.80680592331*1e4;
-                case PressureUnit.TonneForcePerSquareCentimeter: return _value*9.80665e7;
-                case PressureUnit.TonneForcePerSquareMeter: return _value*9.80665e3;
-                case PressureUnit.TonneForcePerSquareMillimeter: return _value*9.80665e9;
-                case PressureUnit.Torr: return _value*1.3332266752*1e2;
+                case PressureUnit.Atmosphere: return Value*1.01325*1e5;
+                case PressureUnit.Bar: return Value*1e5;
+                case PressureUnit.Centibar: return (Value*1e5) * 1e-2d;
+                case PressureUnit.Decapascal: return (Value) * 1e1d;
+                case PressureUnit.Decibar: return (Value*1e5) * 1e-1d;
+                case PressureUnit.DynePerSquareCentimeter: return Value*1.0e-1;
+                case PressureUnit.FootOfHead: return Value*2989.0669;
+                case PressureUnit.Gigapascal: return (Value) * 1e9d;
+                case PressureUnit.Hectopascal: return (Value) * 1e2d;
+                case PressureUnit.InchOfMercury: return Value/2.95299830714159e-4;
+                case PressureUnit.InchOfWaterColumn: return Value*249.08890833333;
+                case PressureUnit.Kilobar: return (Value*1e5) * 1e3d;
+                case PressureUnit.KilogramForcePerSquareCentimeter: return Value*9.80665e4;
+                case PressureUnit.KilogramForcePerSquareMeter: return Value*9.80665019960652;
+                case PressureUnit.KilogramForcePerSquareMillimeter: return Value*9.80665e6;
+                case PressureUnit.KilonewtonPerSquareCentimeter: return (Value*1e4) * 1e3d;
+                case PressureUnit.KilonewtonPerSquareMeter: return (Value) * 1e3d;
+                case PressureUnit.KilonewtonPerSquareMillimeter: return (Value*1e6) * 1e3d;
+                case PressureUnit.Kilopascal: return (Value) * 1e3d;
+                case PressureUnit.KilopoundForcePerSquareFoot: return (Value*4.788025898033584e1) * 1e3d;
+                case PressureUnit.KilopoundForcePerSquareInch: return (Value*6.894757293168361e3) * 1e3d;
+                case PressureUnit.Megabar: return (Value*1e5) * 1e6d;
+                case PressureUnit.MeganewtonPerSquareMeter: return (Value) * 1e6d;
+                case PressureUnit.Megapascal: return (Value) * 1e6d;
+                case PressureUnit.MeterOfHead: return Value*9804.139432;
+                case PressureUnit.Microbar: return (Value*1e5) * 1e-6d;
+                case PressureUnit.Micropascal: return (Value) * 1e-6d;
+                case PressureUnit.Millibar: return (Value*1e5) * 1e-3d;
+                case PressureUnit.MillimeterOfMercury: return Value/7.50061561302643e-3;
+                case PressureUnit.Millipascal: return (Value) * 1e-3d;
+                case PressureUnit.NewtonPerSquareCentimeter: return Value*1e4;
+                case PressureUnit.NewtonPerSquareMeter: return Value;
+                case PressureUnit.NewtonPerSquareMillimeter: return Value*1e6;
+                case PressureUnit.Pascal: return Value;
+                case PressureUnit.PoundForcePerSquareFoot: return Value*4.788025898033584e1;
+                case PressureUnit.PoundForcePerSquareInch: return Value*6.894757293168361e3;
+                case PressureUnit.PoundPerInchSecondSquared: return Value*1.785796732283465e1;
+                case PressureUnit.TechnicalAtmosphere: return Value*9.80680592331*1e4;
+                case PressureUnit.TonneForcePerSquareCentimeter: return Value*9.80665e7;
+                case PressureUnit.TonneForcePerSquareMeter: return Value*9.80665e3;
+                case PressureUnit.TonneForcePerSquareMillimeter: return Value*9.80665e9;
+                case PressureUnit.Torr: return Value*1.3332266752*1e2;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1305,16 +1275,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Pressure ToBaseUnit()
+        internal Pressure<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Pressure(baseUnitValue, BaseUnit);
+            return new Pressure<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(PressureUnit unit)
+        private T GetValueAs(PressureUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1458,57 +1428,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Pressure)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Pressure<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Pressure)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Pressure<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Pressure)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Pressure<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1518,33 +1488,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Pressure))
+            if(conversionType == typeof(Pressure<T>))
                 return this;
             else if(conversionType == typeof(PressureUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Pressure.QuantityType;
+                return Pressure<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Pressure.Info;
+                return Pressure<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Pressure.BaseDimensions;
+                return Pressure<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Pressure)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Pressure<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
index f1799435f5..ded01f65eb 100644
--- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Pressure change rate is the ratio of the pressure change to the time during which the change occurred (value of pressure changes per unit time).
     /// </summary>
-    public partial struct PressureChangeRate : IQuantity<PressureChangeRateUnit>, IEquatable<PressureChangeRate>, IComparable, IComparable<PressureChangeRate>, IConvertible, IFormattable
+    public partial struct PressureChangeRate<T> : IQuantityT<PressureChangeRateUnit, T>, IEquatable<PressureChangeRate<T>>, IComparable, IComparable<PressureChangeRate<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -69,12 +65,12 @@ static PressureChangeRate()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public PressureChangeRate(double value, PressureChangeRateUnit unit)
+        public PressureChangeRate(T value, PressureChangeRateUnit unit)
         {
             if(unit == PressureChangeRateUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -86,14 +82,14 @@ public PressureChangeRate(double value, PressureChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public PressureChangeRate(double value, UnitSystem unitSystem)
+        public PressureChangeRate(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -108,19 +104,19 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of PressureChangeRate, which is PascalPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="PressureChangeRate{T}" />, which is PascalPerSecond. All conversions go via this value.
         /// </summary>
         public static PressureChangeRateUnit BaseUnit { get; } = PressureChangeRateUnit.PascalPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of PressureChangeRate
+        /// Represents the largest possible value of <see cref="PressureChangeRate{T}" />
         /// </summary>
-        public static PressureChangeRate MaxValue { get; } = new PressureChangeRate(double.MaxValue, BaseUnit);
+        public static PressureChangeRate<T> MaxValue { get; } = new PressureChangeRate<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of PressureChangeRate
+        /// Represents the smallest possible value of <see cref="PressureChangeRate{T}" />
         /// </summary>
-        public static PressureChangeRate MinValue { get; } = new PressureChangeRate(double.MinValue, BaseUnit);
+        public static PressureChangeRate<T> MinValue { get; } = new PressureChangeRate<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -129,14 +125,14 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.PressureChangeRate;
 
         /// <summary>
-        ///     All units of measurement for the PressureChangeRate quantity.
+        ///     All units of measurement for the <see cref="PressureChangeRate{T}" /> quantity.
         /// </summary>
         public static PressureChangeRateUnit[] Units { get; } = Enum.GetValues(typeof(PressureChangeRateUnit)).Cast<PressureChangeRateUnit>().Except(new PressureChangeRateUnit[]{ PressureChangeRateUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit PascalPerSecond.
         /// </summary>
-        public static PressureChangeRate Zero { get; } = new PressureChangeRate(0, BaseUnit);
+        public static PressureChangeRate<T> Zero { get; } = new PressureChangeRate<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -145,7 +141,9 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -161,51 +159,51 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => PressureChangeRate.QuantityType;
+        public QuantityType Type => PressureChangeRate<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => PressureChangeRate.BaseDimensions;
+        public BaseDimensions Dimensions => PressureChangeRate<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get PressureChangeRate in AtmospheresPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> in AtmospheresPerSecond.
         /// </summary>
-        public double AtmospheresPerSecond => As(PressureChangeRateUnit.AtmospherePerSecond);
+        public T AtmospheresPerSecond => As(PressureChangeRateUnit.AtmospherePerSecond);
 
         /// <summary>
-        ///     Get PressureChangeRate in KilopascalsPerMinute.
+        ///     Get <see cref="PressureChangeRate{T}" /> in KilopascalsPerMinute.
         /// </summary>
-        public double KilopascalsPerMinute => As(PressureChangeRateUnit.KilopascalPerMinute);
+        public T KilopascalsPerMinute => As(PressureChangeRateUnit.KilopascalPerMinute);
 
         /// <summary>
-        ///     Get PressureChangeRate in KilopascalsPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> in KilopascalsPerSecond.
         /// </summary>
-        public double KilopascalsPerSecond => As(PressureChangeRateUnit.KilopascalPerSecond);
+        public T KilopascalsPerSecond => As(PressureChangeRateUnit.KilopascalPerSecond);
 
         /// <summary>
-        ///     Get PressureChangeRate in MegapascalsPerMinute.
+        ///     Get <see cref="PressureChangeRate{T}" /> in MegapascalsPerMinute.
         /// </summary>
-        public double MegapascalsPerMinute => As(PressureChangeRateUnit.MegapascalPerMinute);
+        public T MegapascalsPerMinute => As(PressureChangeRateUnit.MegapascalPerMinute);
 
         /// <summary>
-        ///     Get PressureChangeRate in MegapascalsPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> in MegapascalsPerSecond.
         /// </summary>
-        public double MegapascalsPerSecond => As(PressureChangeRateUnit.MegapascalPerSecond);
+        public T MegapascalsPerSecond => As(PressureChangeRateUnit.MegapascalPerSecond);
 
         /// <summary>
-        ///     Get PressureChangeRate in PascalsPerMinute.
+        ///     Get <see cref="PressureChangeRate{T}" /> in PascalsPerMinute.
         /// </summary>
-        public double PascalsPerMinute => As(PressureChangeRateUnit.PascalPerMinute);
+        public T PascalsPerMinute => As(PressureChangeRateUnit.PascalPerMinute);
 
         /// <summary>
-        ///     Get PressureChangeRate in PascalsPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> in PascalsPerSecond.
         /// </summary>
-        public double PascalsPerSecond => As(PressureChangeRateUnit.PascalPerSecond);
+        public T PascalsPerSecond => As(PressureChangeRateUnit.PascalPerSecond);
 
         #endregion
 
@@ -237,78 +235,71 @@ public static string GetAbbreviation(PressureChangeRateUnit unit, IFormatProvide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get PressureChangeRate from AtmospheresPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> from AtmospheresPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromAtmospheresPerSecond(QuantityValue atmospherespersecond)
+        public static PressureChangeRate<T> FromAtmospheresPerSecond(T atmospherespersecond)
         {
-            double value = (double) atmospherespersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond);
+            return new PressureChangeRate<T>(atmospherespersecond, PressureChangeRateUnit.AtmospherePerSecond);
         }
         /// <summary>
-        ///     Get PressureChangeRate from KilopascalsPerMinute.
+        ///     Get <see cref="PressureChangeRate{T}" /> from KilopascalsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopascalsPerMinute(QuantityValue kilopascalsperminute)
+        public static PressureChangeRate<T> FromKilopascalsPerMinute(T kilopascalsperminute)
         {
-            double value = (double) kilopascalsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute);
+            return new PressureChangeRate<T>(kilopascalsperminute, PressureChangeRateUnit.KilopascalPerMinute);
         }
         /// <summary>
-        ///     Get PressureChangeRate from KilopascalsPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> from KilopascalsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopascalsPerSecond(QuantityValue kilopascalspersecond)
+        public static PressureChangeRate<T> FromKilopascalsPerSecond(T kilopascalspersecond)
         {
-            double value = (double) kilopascalspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond);
+            return new PressureChangeRate<T>(kilopascalspersecond, PressureChangeRateUnit.KilopascalPerSecond);
         }
         /// <summary>
-        ///     Get PressureChangeRate from MegapascalsPerMinute.
+        ///     Get <see cref="PressureChangeRate{T}" /> from MegapascalsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapascalsPerMinute(QuantityValue megapascalsperminute)
+        public static PressureChangeRate<T> FromMegapascalsPerMinute(T megapascalsperminute)
         {
-            double value = (double) megapascalsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute);
+            return new PressureChangeRate<T>(megapascalsperminute, PressureChangeRateUnit.MegapascalPerMinute);
         }
         /// <summary>
-        ///     Get PressureChangeRate from MegapascalsPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> from MegapascalsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapascalsPerSecond(QuantityValue megapascalspersecond)
+        public static PressureChangeRate<T> FromMegapascalsPerSecond(T megapascalspersecond)
         {
-            double value = (double) megapascalspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond);
+            return new PressureChangeRate<T>(megapascalspersecond, PressureChangeRateUnit.MegapascalPerSecond);
         }
         /// <summary>
-        ///     Get PressureChangeRate from PascalsPerMinute.
+        ///     Get <see cref="PressureChangeRate{T}" /> from PascalsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPascalsPerMinute(QuantityValue pascalsperminute)
+        public static PressureChangeRate<T> FromPascalsPerMinute(T pascalsperminute)
         {
-            double value = (double) pascalsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute);
+            return new PressureChangeRate<T>(pascalsperminute, PressureChangeRateUnit.PascalPerMinute);
         }
         /// <summary>
-        ///     Get PressureChangeRate from PascalsPerSecond.
+        ///     Get <see cref="PressureChangeRate{T}" /> from PascalsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPascalsPerSecond(QuantityValue pascalspersecond)
+        public static PressureChangeRate<T> FromPascalsPerSecond(T pascalspersecond)
         {
-            double value = (double) pascalspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond);
+            return new PressureChangeRate<T>(pascalspersecond, PressureChangeRateUnit.PascalPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PressureChangeRateUnit" /> to <see cref="PressureChangeRate" />.
+        ///     Dynamically convert from value and unit enum <see cref="PressureChangeRateUnit" /> to <see cref="PressureChangeRate{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>PressureChangeRate unit value.</returns>
-        public static PressureChangeRate From(QuantityValue value, PressureChangeRateUnit fromUnit)
+        /// <returns><see cref="PressureChangeRate{T}" /> unit value.</returns>
+        public static PressureChangeRate<T> From(T value, PressureChangeRateUnit fromUnit)
         {
-            return new PressureChangeRate((double)value, fromUnit);
+            return new PressureChangeRate<T>(value, fromUnit);
         }
 
         #endregion
@@ -337,7 +328,7 @@ public static PressureChangeRate From(QuantityValue value, PressureChangeRateUni
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static PressureChangeRate Parse(string str)
+        public static PressureChangeRate<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -365,9 +356,9 @@ public static PressureChangeRate Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static PressureChangeRate Parse(string str, IFormatProvider? provider)
+        public static PressureChangeRate<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<PressureChangeRate, PressureChangeRateUnit>(
+            return QuantityParser.Default.Parse<T, PressureChangeRate<T>, PressureChangeRateUnit>(
                 str,
                 provider,
                 From);
@@ -381,7 +372,7 @@ public static PressureChangeRate Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out PressureChangeRate result)
+        public static bool TryParse(string? str, out PressureChangeRate<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -396,9 +387,9 @@ public static bool TryParse(string? str, out PressureChangeRate result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out PressureChangeRate result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out PressureChangeRate<T> result)
         {
-            return QuantityParser.Default.TryParse<PressureChangeRate, PressureChangeRateUnit>(
+            return QuantityParser.Default.TryParse<T, PressureChangeRate<T>, PressureChangeRateUnit>(
                 str,
                 provider,
                 From,
@@ -460,45 +451,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Press
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static PressureChangeRate operator -(PressureChangeRate right)
+        public static PressureChangeRate<T> operator -(PressureChangeRate<T> right)
         {
-            return new PressureChangeRate(-right.Value, right.Unit);
+            return new PressureChangeRate<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="PressureChangeRate"/> from adding two <see cref="PressureChangeRate"/>.</summary>
-        public static PressureChangeRate operator +(PressureChangeRate left, PressureChangeRate right)
+        /// <summary>Get <see cref="PressureChangeRate{T}"/> from adding two <see cref="PressureChangeRate{T}"/>.</summary>
+        public static PressureChangeRate<T> operator +(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
-            return new PressureChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new PressureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="PressureChangeRate"/> from subtracting two <see cref="PressureChangeRate"/>.</summary>
-        public static PressureChangeRate operator -(PressureChangeRate left, PressureChangeRate right)
+        /// <summary>Get <see cref="PressureChangeRate{T}"/> from subtracting two <see cref="PressureChangeRate{T}"/>.</summary>
+        public static PressureChangeRate<T> operator -(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
-            return new PressureChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new PressureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="PressureChangeRate"/> from multiplying value and <see cref="PressureChangeRate"/>.</summary>
-        public static PressureChangeRate operator *(double left, PressureChangeRate right)
+        /// <summary>Get <see cref="PressureChangeRate{T}"/> from multiplying value and <see cref="PressureChangeRate{T}"/>.</summary>
+        public static PressureChangeRate<T> operator *(T left, PressureChangeRate<T> right)
         {
-            return new PressureChangeRate(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new PressureChangeRate<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="PressureChangeRate"/> from multiplying value and <see cref="PressureChangeRate"/>.</summary>
-        public static PressureChangeRate operator *(PressureChangeRate left, double right)
+        /// <summary>Get <see cref="PressureChangeRate{T}"/> from multiplying value and <see cref="PressureChangeRate{T}"/>.</summary>
+        public static PressureChangeRate<T> operator *(PressureChangeRate<T> left, T right)
         {
-            return new PressureChangeRate(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new PressureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="PressureChangeRate"/> from dividing <see cref="PressureChangeRate"/> by value.</summary>
-        public static PressureChangeRate operator /(PressureChangeRate left, double right)
+        /// <summary>Get <see cref="PressureChangeRate{T}"/> from dividing <see cref="PressureChangeRate{T}"/> by value.</summary>
+        public static PressureChangeRate<T> operator /(PressureChangeRate<T> left, T right)
         {
-            return new PressureChangeRate(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new PressureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="PressureChangeRate"/> by <see cref="PressureChangeRate"/>.</summary>
-        public static double operator /(PressureChangeRate left, PressureChangeRate right)
+        /// <summary>Get ratio value from dividing <see cref="PressureChangeRate{T}"/> by <see cref="PressureChangeRate{T}"/>.</summary>
+        public static T operator /(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
-            return left.PascalsPerSecond / right.PascalsPerSecond;
+            return CompiledLambdas.Divide(left.PascalsPerSecond, right.PascalsPerSecond);
         }
 
         #endregion
@@ -506,39 +502,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Press
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(PressureChangeRate left, PressureChangeRate right)
+        public static bool operator <=(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(PressureChangeRate left, PressureChangeRate right)
+        public static bool operator >=(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(PressureChangeRate left, PressureChangeRate right)
+        public static bool operator <(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(PressureChangeRate left, PressureChangeRate right)
+        public static bool operator >(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(PressureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(PressureChangeRate left, PressureChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(PressureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(PressureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(PressureChangeRate left, PressureChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(PressureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(PressureChangeRate<T> left, PressureChangeRate<T> right)
         {
             return !(left == right);
         }
@@ -547,37 +543,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Press
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is PressureChangeRate objPressureChangeRate)) throw new ArgumentException("Expected type PressureChangeRate.", nameof(obj));
+            if(!(obj is PressureChangeRate<T> objPressureChangeRate)) throw new ArgumentException("Expected type PressureChangeRate.", nameof(obj));
 
             return CompareTo(objPressureChangeRate);
         }
 
         /// <inheritdoc />
-        public int CompareTo(PressureChangeRate other)
+        public int CompareTo(PressureChangeRate<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(PressureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(PressureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is PressureChangeRate objPressureChangeRate))
+            if(obj is null || !(obj is PressureChangeRate<T> objPressureChangeRate))
                 return false;
 
             return Equals(objPressureChangeRate);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(PressureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(PressureChangeRate other)
+        /// <remarks>Consider using <see cref="Equals(PressureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(PressureChangeRate<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another PressureChangeRate within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="PressureChangeRate{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -615,21 +611,19 @@ public bool Equals(PressureChangeRate other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(PressureChangeRate other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(PressureChangeRate<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current PressureChangeRate.</returns>
+        /// <returns>A hash code for the current <see cref="PressureChangeRate{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -643,17 +637,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(PressureChangeRateUnit unit)
+        public T As(PressureChangeRateUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -673,17 +667,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is PressureChangeRateUnit unitAsPressureChangeRateUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureChangeRateUnit)} is supported.", nameof(unit));
 
-            return As(unitAsPressureChangeRateUnit);
+            var asValue = As(unitAsPressureChangeRateUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<PressureChangeRateUnit>.As(PressureChangeRateUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this PressureChangeRate to another PressureChangeRate with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="PressureChangeRate{T}" /> to another <see cref="PressureChangeRate{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A PressureChangeRate with the specified unit.</returns>
-        public PressureChangeRate ToUnit(PressureChangeRateUnit unit)
+        /// <returns>A <see cref="PressureChangeRate{T}" /> with the specified unit.</returns>
+        public PressureChangeRate<T> ToUnit(PressureChangeRateUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new PressureChangeRate(convertedValue, unit);
+            return new PressureChangeRate<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -696,7 +695,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public PressureChangeRate ToUnit(UnitSystem unitSystem)
+        public PressureChangeRate<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -716,25 +715,31 @@ public PressureChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PressureChangeRateUnit> IQuantity<PressureChangeRateUnit>.ToUnit(PressureChangeRateUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<PressureChangeRateUnit, T> IQuantityT<PressureChangeRateUnit, T>.ToUnit(PressureChangeRateUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<PressureChangeRateUnit> IQuantity<PressureChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<PressureChangeRateUnit, T> IQuantityT<PressureChangeRateUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case PressureChangeRateUnit.AtmospherePerSecond: return _value * 1.01325*1e5;
-                case PressureChangeRateUnit.KilopascalPerMinute: return (_value/60) * 1e3d;
-                case PressureChangeRateUnit.KilopascalPerSecond: return (_value) * 1e3d;
-                case PressureChangeRateUnit.MegapascalPerMinute: return (_value/60) * 1e6d;
-                case PressureChangeRateUnit.MegapascalPerSecond: return (_value) * 1e6d;
-                case PressureChangeRateUnit.PascalPerMinute: return _value/60;
-                case PressureChangeRateUnit.PascalPerSecond: return _value;
+                case PressureChangeRateUnit.AtmospherePerSecond: return Value * 1.01325*1e5;
+                case PressureChangeRateUnit.KilopascalPerMinute: return (Value/60) * 1e3d;
+                case PressureChangeRateUnit.KilopascalPerSecond: return (Value) * 1e3d;
+                case PressureChangeRateUnit.MegapascalPerMinute: return (Value/60) * 1e6d;
+                case PressureChangeRateUnit.MegapascalPerSecond: return (Value) * 1e6d;
+                case PressureChangeRateUnit.PascalPerMinute: return Value/60;
+                case PressureChangeRateUnit.PascalPerSecond: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -745,16 +750,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal PressureChangeRate ToBaseUnit()
+        internal PressureChangeRate<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new PressureChangeRate(baseUnitValue, BaseUnit);
+            return new PressureChangeRate<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(PressureChangeRateUnit unit)
+        private T GetValueAs(PressureChangeRateUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -863,57 +868,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PressureChangeRate)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PressureChangeRate<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PressureChangeRate)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PressureChangeRate<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(PressureChangeRate)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(PressureChangeRate<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -923,33 +928,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(PressureChangeRate))
+            if(conversionType == typeof(PressureChangeRate<T>))
                 return this;
             else if(conversionType == typeof(PressureChangeRateUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return PressureChangeRate.QuantityType;
+                return PressureChangeRate<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return PressureChangeRate.Info;
+                return PressureChangeRate<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return PressureChangeRate.BaseDimensions;
+                return PressureChangeRate<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(PressureChangeRate)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(PressureChangeRate<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
index 35c8207aea..c43b15921f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In mathematics, a ratio is a relationship between two numbers of the same kind (e.g., objects, persons, students, spoonfuls, units of whatever identical dimension), usually expressed as "a to b" or a:b, sometimes expressed arithmetically as a dimensionless quotient of the two that explicitly indicates how many times the first number contains the second (not necessarily an integer).
     /// </summary>
-    public partial struct Ratio : IQuantity<RatioUnit>, IEquatable<Ratio>, IComparable, IComparable<Ratio>, IConvertible, IFormattable
+    public partial struct Ratio<T> : IQuantityT<RatioUnit, T>, IEquatable<Ratio<T>>, IComparable, IComparable<Ratio<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static Ratio()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Ratio(double value, RatioUnit unit)
+        public Ratio(T value, RatioUnit unit)
         {
             if(unit == RatioUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public Ratio(double value, RatioUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Ratio(double value, UnitSystem unitSystem)
+        public Ratio(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public Ratio(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Ratio, which is DecimalFraction. All conversions go via this value.
+        ///     The base unit of <see cref="Ratio{T}" />, which is DecimalFraction. All conversions go via this value.
         /// </summary>
         public static RatioUnit BaseUnit { get; } = RatioUnit.DecimalFraction;
 
         /// <summary>
-        /// Represents the largest possible value of Ratio
+        /// Represents the largest possible value of <see cref="Ratio{T}" />
         /// </summary>
-        public static Ratio MaxValue { get; } = new Ratio(double.MaxValue, BaseUnit);
+        public static Ratio<T> MaxValue { get; } = new Ratio<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Ratio
+        /// Represents the smallest possible value of <see cref="Ratio{T}" />
         /// </summary>
-        public static Ratio MinValue { get; } = new Ratio(double.MinValue, BaseUnit);
+        public static Ratio<T> MinValue { get; } = new Ratio<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public Ratio(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Ratio;
 
         /// <summary>
-        ///     All units of measurement for the Ratio quantity.
+        ///     All units of measurement for the <see cref="Ratio{T}" /> quantity.
         /// </summary>
         public static RatioUnit[] Units { get; } = Enum.GetValues(typeof(RatioUnit)).Cast<RatioUnit>().Except(new RatioUnit[]{ RatioUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DecimalFraction.
         /// </summary>
-        public static Ratio Zero { get; } = new Ratio(0, BaseUnit);
+        public static Ratio<T> Zero { get; } = new Ratio<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public Ratio(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,46 +158,46 @@ public Ratio(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Ratio.QuantityType;
+        public QuantityType Type => Ratio<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Ratio.BaseDimensions;
+        public BaseDimensions Dimensions => Ratio<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Ratio in DecimalFractions.
+        ///     Get <see cref="Ratio{T}" /> in DecimalFractions.
         /// </summary>
-        public double DecimalFractions => As(RatioUnit.DecimalFraction);
+        public T DecimalFractions => As(RatioUnit.DecimalFraction);
 
         /// <summary>
-        ///     Get Ratio in PartsPerBillion.
+        ///     Get <see cref="Ratio{T}" /> in PartsPerBillion.
         /// </summary>
-        public double PartsPerBillion => As(RatioUnit.PartPerBillion);
+        public T PartsPerBillion => As(RatioUnit.PartPerBillion);
 
         /// <summary>
-        ///     Get Ratio in PartsPerMillion.
+        ///     Get <see cref="Ratio{T}" /> in PartsPerMillion.
         /// </summary>
-        public double PartsPerMillion => As(RatioUnit.PartPerMillion);
+        public T PartsPerMillion => As(RatioUnit.PartPerMillion);
 
         /// <summary>
-        ///     Get Ratio in PartsPerThousand.
+        ///     Get <see cref="Ratio{T}" /> in PartsPerThousand.
         /// </summary>
-        public double PartsPerThousand => As(RatioUnit.PartPerThousand);
+        public T PartsPerThousand => As(RatioUnit.PartPerThousand);
 
         /// <summary>
-        ///     Get Ratio in PartsPerTrillion.
+        ///     Get <see cref="Ratio{T}" /> in PartsPerTrillion.
         /// </summary>
-        public double PartsPerTrillion => As(RatioUnit.PartPerTrillion);
+        public T PartsPerTrillion => As(RatioUnit.PartPerTrillion);
 
         /// <summary>
-        ///     Get Ratio in Percent.
+        ///     Get <see cref="Ratio{T}" /> in Percent.
         /// </summary>
-        public double Percent => As(RatioUnit.Percent);
+        public T Percent => As(RatioUnit.Percent);
 
         #endregion
 
@@ -231,69 +229,63 @@ public static string GetAbbreviation(RatioUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Ratio from DecimalFractions.
+        ///     Get <see cref="Ratio{T}" /> from DecimalFractions.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromDecimalFractions(QuantityValue decimalfractions)
+        public static Ratio<T> FromDecimalFractions(T decimalfractions)
         {
-            double value = (double) decimalfractions;
-            return new Ratio(value, RatioUnit.DecimalFraction);
+            return new Ratio<T>(decimalfractions, RatioUnit.DecimalFraction);
         }
         /// <summary>
-        ///     Get Ratio from PartsPerBillion.
+        ///     Get <see cref="Ratio{T}" /> from PartsPerBillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerBillion(QuantityValue partsperbillion)
+        public static Ratio<T> FromPartsPerBillion(T partsperbillion)
         {
-            double value = (double) partsperbillion;
-            return new Ratio(value, RatioUnit.PartPerBillion);
+            return new Ratio<T>(partsperbillion, RatioUnit.PartPerBillion);
         }
         /// <summary>
-        ///     Get Ratio from PartsPerMillion.
+        ///     Get <see cref="Ratio{T}" /> from PartsPerMillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerMillion(QuantityValue partspermillion)
+        public static Ratio<T> FromPartsPerMillion(T partspermillion)
         {
-            double value = (double) partspermillion;
-            return new Ratio(value, RatioUnit.PartPerMillion);
+            return new Ratio<T>(partspermillion, RatioUnit.PartPerMillion);
         }
         /// <summary>
-        ///     Get Ratio from PartsPerThousand.
+        ///     Get <see cref="Ratio{T}" /> from PartsPerThousand.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerThousand(QuantityValue partsperthousand)
+        public static Ratio<T> FromPartsPerThousand(T partsperthousand)
         {
-            double value = (double) partsperthousand;
-            return new Ratio(value, RatioUnit.PartPerThousand);
+            return new Ratio<T>(partsperthousand, RatioUnit.PartPerThousand);
         }
         /// <summary>
-        ///     Get Ratio from PartsPerTrillion.
+        ///     Get <see cref="Ratio{T}" /> from PartsPerTrillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerTrillion(QuantityValue partspertrillion)
+        public static Ratio<T> FromPartsPerTrillion(T partspertrillion)
         {
-            double value = (double) partspertrillion;
-            return new Ratio(value, RatioUnit.PartPerTrillion);
+            return new Ratio<T>(partspertrillion, RatioUnit.PartPerTrillion);
         }
         /// <summary>
-        ///     Get Ratio from Percent.
+        ///     Get <see cref="Ratio{T}" /> from Percent.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPercent(QuantityValue percent)
+        public static Ratio<T> FromPercent(T percent)
         {
-            double value = (double) percent;
-            return new Ratio(value, RatioUnit.Percent);
+            return new Ratio<T>(percent, RatioUnit.Percent);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RatioUnit" /> to <see cref="Ratio" />.
+        ///     Dynamically convert from value and unit enum <see cref="RatioUnit" /> to <see cref="Ratio{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Ratio unit value.</returns>
-        public static Ratio From(QuantityValue value, RatioUnit fromUnit)
+        /// <returns><see cref="Ratio{T}" /> unit value.</returns>
+        public static Ratio<T> From(T value, RatioUnit fromUnit)
         {
-            return new Ratio((double)value, fromUnit);
+            return new Ratio<T>(value, fromUnit);
         }
 
         #endregion
@@ -322,7 +314,7 @@ public static Ratio From(QuantityValue value, RatioUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Ratio Parse(string str)
+        public static Ratio<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -350,9 +342,9 @@ public static Ratio Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Ratio Parse(string str, IFormatProvider? provider)
+        public static Ratio<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Ratio, RatioUnit>(
+            return QuantityParser.Default.Parse<T, Ratio<T>, RatioUnit>(
                 str,
                 provider,
                 From);
@@ -366,7 +358,7 @@ public static Ratio Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Ratio result)
+        public static bool TryParse(string? str, out Ratio<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -381,9 +373,9 @@ public static bool TryParse(string? str, out Ratio result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Ratio result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Ratio<T> result)
         {
-            return QuantityParser.Default.TryParse<Ratio, RatioUnit>(
+            return QuantityParser.Default.TryParse<T, Ratio<T>, RatioUnit>(
                 str,
                 provider,
                 From,
@@ -445,45 +437,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ratio
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Ratio operator -(Ratio right)
+        public static Ratio<T> operator -(Ratio<T> right)
         {
-            return new Ratio(-right.Value, right.Unit);
+            return new Ratio<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Ratio"/> from adding two <see cref="Ratio"/>.</summary>
-        public static Ratio operator +(Ratio left, Ratio right)
+        /// <summary>Get <see cref="Ratio{T}"/> from adding two <see cref="Ratio{T}"/>.</summary>
+        public static Ratio<T> operator +(Ratio<T> left, Ratio<T> right)
         {
-            return new Ratio(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Ratio<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Ratio"/> from subtracting two <see cref="Ratio"/>.</summary>
-        public static Ratio operator -(Ratio left, Ratio right)
+        /// <summary>Get <see cref="Ratio{T}"/> from subtracting two <see cref="Ratio{T}"/>.</summary>
+        public static Ratio<T> operator -(Ratio<T> left, Ratio<T> right)
         {
-            return new Ratio(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Ratio<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Ratio"/> from multiplying value and <see cref="Ratio"/>.</summary>
-        public static Ratio operator *(double left, Ratio right)
+        /// <summary>Get <see cref="Ratio{T}"/> from multiplying value and <see cref="Ratio{T}"/>.</summary>
+        public static Ratio<T> operator *(T left, Ratio<T> right)
         {
-            return new Ratio(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Ratio<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Ratio"/> from multiplying value and <see cref="Ratio"/>.</summary>
-        public static Ratio operator *(Ratio left, double right)
+        /// <summary>Get <see cref="Ratio{T}"/> from multiplying value and <see cref="Ratio{T}"/>.</summary>
+        public static Ratio<T> operator *(Ratio<T> left, T right)
         {
-            return new Ratio(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Ratio<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Ratio"/> from dividing <see cref="Ratio"/> by value.</summary>
-        public static Ratio operator /(Ratio left, double right)
+        /// <summary>Get <see cref="Ratio{T}"/> from dividing <see cref="Ratio{T}"/> by value.</summary>
+        public static Ratio<T> operator /(Ratio<T> left, T right)
         {
-            return new Ratio(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Ratio<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Ratio"/> by <see cref="Ratio"/>.</summary>
-        public static double operator /(Ratio left, Ratio right)
+        /// <summary>Get ratio value from dividing <see cref="Ratio{T}"/> by <see cref="Ratio{T}"/>.</summary>
+        public static T operator /(Ratio<T> left, Ratio<T> right)
         {
-            return left.DecimalFractions / right.DecimalFractions;
+            return CompiledLambdas.Divide(left.DecimalFractions, right.DecimalFractions);
         }
 
         #endregion
@@ -491,39 +488,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ratio
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Ratio left, Ratio right)
+        public static bool operator <=(Ratio<T> left, Ratio<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Ratio left, Ratio right)
+        public static bool operator >=(Ratio<T> left, Ratio<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Ratio left, Ratio right)
+        public static bool operator <(Ratio<T> left, Ratio<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Ratio left, Ratio right)
+        public static bool operator >(Ratio<T> left, Ratio<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Ratio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Ratio left, Ratio right)
+        /// <remarks>Consider using <see cref="Equals(Ratio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Ratio<T> left, Ratio<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Ratio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Ratio left, Ratio right)
+        /// <remarks>Consider using <see cref="Equals(Ratio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Ratio<T> left, Ratio<T> right)
         {
             return !(left == right);
         }
@@ -532,37 +529,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ratio
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Ratio objRatio)) throw new ArgumentException("Expected type Ratio.", nameof(obj));
+            if(!(obj is Ratio<T> objRatio)) throw new ArgumentException("Expected type Ratio.", nameof(obj));
 
             return CompareTo(objRatio);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Ratio other)
+        public int CompareTo(Ratio<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Ratio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Ratio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Ratio objRatio))
+            if(obj is null || !(obj is Ratio<T> objRatio))
                 return false;
 
             return Equals(objRatio);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Ratio, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Ratio other)
+        /// <remarks>Consider using <see cref="Equals(Ratio{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Ratio<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Ratio within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Ratio{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -600,21 +597,19 @@ public bool Equals(Ratio other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Ratio other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Ratio<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Ratio.</returns>
+        /// <returns>A hash code for the current <see cref="Ratio{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -628,17 +623,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(RatioUnit unit)
+        public T As(RatioUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -658,17 +653,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is RatioUnit unitAsRatioUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioUnit)} is supported.", nameof(unit));
 
-            return As(unitAsRatioUnit);
+            var asValue = As(unitAsRatioUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<RatioUnit>.As(RatioUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Ratio to another Ratio with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Ratio{T}" /> to another <see cref="Ratio{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Ratio with the specified unit.</returns>
-        public Ratio ToUnit(RatioUnit unit)
+        /// <returns>A <see cref="Ratio{T}" /> with the specified unit.</returns>
+        public Ratio<T> ToUnit(RatioUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Ratio(convertedValue, unit);
+            return new Ratio<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -681,7 +681,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Ratio ToUnit(UnitSystem unitSystem)
+        public Ratio<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -701,24 +701,30 @@ public Ratio ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RatioUnit> IQuantity<RatioUnit>.ToUnit(RatioUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<RatioUnit, T> IQuantityT<RatioUnit, T>.ToUnit(RatioUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<RatioUnit> IQuantity<RatioUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<RatioUnit, T> IQuantityT<RatioUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case RatioUnit.DecimalFraction: return _value;
-                case RatioUnit.PartPerBillion: return _value/1e9;
-                case RatioUnit.PartPerMillion: return _value/1e6;
-                case RatioUnit.PartPerThousand: return _value/1e3;
-                case RatioUnit.PartPerTrillion: return _value/1e12;
-                case RatioUnit.Percent: return _value/1e2;
+                case RatioUnit.DecimalFraction: return Value;
+                case RatioUnit.PartPerBillion: return Value/1e9;
+                case RatioUnit.PartPerMillion: return Value/1e6;
+                case RatioUnit.PartPerThousand: return Value/1e3;
+                case RatioUnit.PartPerTrillion: return Value/1e12;
+                case RatioUnit.Percent: return Value/1e2;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -729,16 +735,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Ratio ToBaseUnit()
+        internal Ratio<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Ratio(baseUnitValue, BaseUnit);
+            return new Ratio<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(RatioUnit unit)
+        private T GetValueAs(RatioUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -846,57 +852,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Ratio)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Ratio<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Ratio)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Ratio<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Ratio)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Ratio<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -906,33 +912,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Ratio))
+            if(conversionType == typeof(Ratio<T>))
                 return this;
             else if(conversionType == typeof(RatioUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Ratio.QuantityType;
+                return Ratio<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Ratio.Info;
+                return Ratio<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Ratio.BaseDimensions;
+                return Ratio<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Ratio)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Ratio<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
index 1d59dd8aee..bcc5a685c0 100644
--- a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The change in ratio per unit of time.
     /// </summary>
-    public partial struct RatioChangeRate : IQuantity<RatioChangeRateUnit>, IEquatable<RatioChangeRate>, IComparable, IComparable<RatioChangeRate>, IConvertible, IFormattable
+    public partial struct RatioChangeRate<T> : IQuantityT<RatioChangeRateUnit, T>, IEquatable<RatioChangeRate<T>>, IComparable, IComparable<RatioChangeRate<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -64,12 +60,12 @@ static RatioChangeRate()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public RatioChangeRate(double value, RatioChangeRateUnit unit)
+        public RatioChangeRate(T value, RatioChangeRateUnit unit)
         {
             if(unit == RatioChangeRateUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -81,14 +77,14 @@ public RatioChangeRate(double value, RatioChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RatioChangeRate(double value, UnitSystem unitSystem)
+        public RatioChangeRate(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -103,19 +99,19 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of RatioChangeRate, which is DecimalFractionPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="RatioChangeRate{T}" />, which is DecimalFractionPerSecond. All conversions go via this value.
         /// </summary>
         public static RatioChangeRateUnit BaseUnit { get; } = RatioChangeRateUnit.DecimalFractionPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of RatioChangeRate
+        /// Represents the largest possible value of <see cref="RatioChangeRate{T}" />
         /// </summary>
-        public static RatioChangeRate MaxValue { get; } = new RatioChangeRate(double.MaxValue, BaseUnit);
+        public static RatioChangeRate<T> MaxValue { get; } = new RatioChangeRate<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of RatioChangeRate
+        /// Represents the smallest possible value of <see cref="RatioChangeRate{T}" />
         /// </summary>
-        public static RatioChangeRate MinValue { get; } = new RatioChangeRate(double.MinValue, BaseUnit);
+        public static RatioChangeRate<T> MinValue { get; } = new RatioChangeRate<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -124,14 +120,14 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.RatioChangeRate;
 
         /// <summary>
-        ///     All units of measurement for the RatioChangeRate quantity.
+        ///     All units of measurement for the <see cref="RatioChangeRate{T}" /> quantity.
         /// </summary>
         public static RatioChangeRateUnit[] Units { get; } = Enum.GetValues(typeof(RatioChangeRateUnit)).Cast<RatioChangeRateUnit>().Except(new RatioChangeRateUnit[]{ RatioChangeRateUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DecimalFractionPerSecond.
         /// </summary>
-        public static RatioChangeRate Zero { get; } = new RatioChangeRate(0, BaseUnit);
+        public static RatioChangeRate<T> Zero { get; } = new RatioChangeRate<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -140,7 +136,9 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -156,26 +154,26 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => RatioChangeRate.QuantityType;
+        public QuantityType Type => RatioChangeRate<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => RatioChangeRate.BaseDimensions;
+        public BaseDimensions Dimensions => RatioChangeRate<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get RatioChangeRate in DecimalFractionsPerSecond.
+        ///     Get <see cref="RatioChangeRate{T}" /> in DecimalFractionsPerSecond.
         /// </summary>
-        public double DecimalFractionsPerSecond => As(RatioChangeRateUnit.DecimalFractionPerSecond);
+        public T DecimalFractionsPerSecond => As(RatioChangeRateUnit.DecimalFractionPerSecond);
 
         /// <summary>
-        ///     Get RatioChangeRate in PercentsPerSecond.
+        ///     Get <see cref="RatioChangeRate{T}" /> in PercentsPerSecond.
         /// </summary>
-        public double PercentsPerSecond => As(RatioChangeRateUnit.PercentPerSecond);
+        public T PercentsPerSecond => As(RatioChangeRateUnit.PercentPerSecond);
 
         #endregion
 
@@ -207,33 +205,31 @@ public static string GetAbbreviation(RatioChangeRateUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get RatioChangeRate from DecimalFractionsPerSecond.
+        ///     Get <see cref="RatioChangeRate{T}" /> from DecimalFractionsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RatioChangeRate FromDecimalFractionsPerSecond(QuantityValue decimalfractionspersecond)
+        public static RatioChangeRate<T> FromDecimalFractionsPerSecond(T decimalfractionspersecond)
         {
-            double value = (double) decimalfractionspersecond;
-            return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond);
+            return new RatioChangeRate<T>(decimalfractionspersecond, RatioChangeRateUnit.DecimalFractionPerSecond);
         }
         /// <summary>
-        ///     Get RatioChangeRate from PercentsPerSecond.
+        ///     Get <see cref="RatioChangeRate{T}" /> from PercentsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RatioChangeRate FromPercentsPerSecond(QuantityValue percentspersecond)
+        public static RatioChangeRate<T> FromPercentsPerSecond(T percentspersecond)
         {
-            double value = (double) percentspersecond;
-            return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond);
+            return new RatioChangeRate<T>(percentspersecond, RatioChangeRateUnit.PercentPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RatioChangeRateUnit" /> to <see cref="RatioChangeRate" />.
+        ///     Dynamically convert from value and unit enum <see cref="RatioChangeRateUnit" /> to <see cref="RatioChangeRate{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RatioChangeRate unit value.</returns>
-        public static RatioChangeRate From(QuantityValue value, RatioChangeRateUnit fromUnit)
+        /// <returns><see cref="RatioChangeRate{T}" /> unit value.</returns>
+        public static RatioChangeRate<T> From(T value, RatioChangeRateUnit fromUnit)
         {
-            return new RatioChangeRate((double)value, fromUnit);
+            return new RatioChangeRate<T>(value, fromUnit);
         }
 
         #endregion
@@ -262,7 +258,7 @@ public static RatioChangeRate From(QuantityValue value, RatioChangeRateUnit from
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static RatioChangeRate Parse(string str)
+        public static RatioChangeRate<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -290,9 +286,9 @@ public static RatioChangeRate Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static RatioChangeRate Parse(string str, IFormatProvider? provider)
+        public static RatioChangeRate<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<RatioChangeRate, RatioChangeRateUnit>(
+            return QuantityParser.Default.Parse<T, RatioChangeRate<T>, RatioChangeRateUnit>(
                 str,
                 provider,
                 From);
@@ -306,7 +302,7 @@ public static RatioChangeRate Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out RatioChangeRate result)
+        public static bool TryParse(string? str, out RatioChangeRate<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -321,9 +317,9 @@ public static bool TryParse(string? str, out RatioChangeRate result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out RatioChangeRate result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out RatioChangeRate<T> result)
         {
-            return QuantityParser.Default.TryParse<RatioChangeRate, RatioChangeRateUnit>(
+            return QuantityParser.Default.TryParse<T, RatioChangeRate<T>, RatioChangeRateUnit>(
                 str,
                 provider,
                 From,
@@ -385,45 +381,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ratio
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static RatioChangeRate operator -(RatioChangeRate right)
+        public static RatioChangeRate<T> operator -(RatioChangeRate<T> right)
         {
-            return new RatioChangeRate(-right.Value, right.Unit);
+            return new RatioChangeRate<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="RatioChangeRate"/> from adding two <see cref="RatioChangeRate"/>.</summary>
-        public static RatioChangeRate operator +(RatioChangeRate left, RatioChangeRate right)
+        /// <summary>Get <see cref="RatioChangeRate{T}"/> from adding two <see cref="RatioChangeRate{T}"/>.</summary>
+        public static RatioChangeRate<T> operator +(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
-            return new RatioChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new RatioChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RatioChangeRate"/> from subtracting two <see cref="RatioChangeRate"/>.</summary>
-        public static RatioChangeRate operator -(RatioChangeRate left, RatioChangeRate right)
+        /// <summary>Get <see cref="RatioChangeRate{T}"/> from subtracting two <see cref="RatioChangeRate{T}"/>.</summary>
+        public static RatioChangeRate<T> operator -(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
-            return new RatioChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new RatioChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RatioChangeRate"/> from multiplying value and <see cref="RatioChangeRate"/>.</summary>
-        public static RatioChangeRate operator *(double left, RatioChangeRate right)
+        /// <summary>Get <see cref="RatioChangeRate{T}"/> from multiplying value and <see cref="RatioChangeRate{T}"/>.</summary>
+        public static RatioChangeRate<T> operator *(T left, RatioChangeRate<T> right)
         {
-            return new RatioChangeRate(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new RatioChangeRate<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="RatioChangeRate"/> from multiplying value and <see cref="RatioChangeRate"/>.</summary>
-        public static RatioChangeRate operator *(RatioChangeRate left, double right)
+        /// <summary>Get <see cref="RatioChangeRate{T}"/> from multiplying value and <see cref="RatioChangeRate{T}"/>.</summary>
+        public static RatioChangeRate<T> operator *(RatioChangeRate<T> left, T right)
         {
-            return new RatioChangeRate(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new RatioChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RatioChangeRate"/> from dividing <see cref="RatioChangeRate"/> by value.</summary>
-        public static RatioChangeRate operator /(RatioChangeRate left, double right)
+        /// <summary>Get <see cref="RatioChangeRate{T}"/> from dividing <see cref="RatioChangeRate{T}"/> by value.</summary>
+        public static RatioChangeRate<T> operator /(RatioChangeRate<T> left, T right)
         {
-            return new RatioChangeRate(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new RatioChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="RatioChangeRate"/> by <see cref="RatioChangeRate"/>.</summary>
-        public static double operator /(RatioChangeRate left, RatioChangeRate right)
+        /// <summary>Get ratio value from dividing <see cref="RatioChangeRate{T}"/> by <see cref="RatioChangeRate{T}"/>.</summary>
+        public static T operator /(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
-            return left.DecimalFractionsPerSecond / right.DecimalFractionsPerSecond;
+            return CompiledLambdas.Divide(left.DecimalFractionsPerSecond, right.DecimalFractionsPerSecond);
         }
 
         #endregion
@@ -431,39 +432,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ratio
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(RatioChangeRate left, RatioChangeRate right)
+        public static bool operator <=(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(RatioChangeRate left, RatioChangeRate right)
+        public static bool operator >=(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(RatioChangeRate left, RatioChangeRate right)
+        public static bool operator <(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(RatioChangeRate left, RatioChangeRate right)
+        public static bool operator >(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RatioChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(RatioChangeRate left, RatioChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(RatioChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RatioChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(RatioChangeRate left, RatioChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(RatioChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(RatioChangeRate<T> left, RatioChangeRate<T> right)
         {
             return !(left == right);
         }
@@ -472,37 +473,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ratio
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is RatioChangeRate objRatioChangeRate)) throw new ArgumentException("Expected type RatioChangeRate.", nameof(obj));
+            if(!(obj is RatioChangeRate<T> objRatioChangeRate)) throw new ArgumentException("Expected type RatioChangeRate.", nameof(obj));
 
             return CompareTo(objRatioChangeRate);
         }
 
         /// <inheritdoc />
-        public int CompareTo(RatioChangeRate other)
+        public int CompareTo(RatioChangeRate<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RatioChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(RatioChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is RatioChangeRate objRatioChangeRate))
+            if(obj is null || !(obj is RatioChangeRate<T> objRatioChangeRate))
                 return false;
 
             return Equals(objRatioChangeRate);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RatioChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(RatioChangeRate other)
+        /// <remarks>Consider using <see cref="Equals(RatioChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(RatioChangeRate<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another RatioChangeRate within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="RatioChangeRate{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -540,21 +541,19 @@ public bool Equals(RatioChangeRate other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(RatioChangeRate other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(RatioChangeRate<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current RatioChangeRate.</returns>
+        /// <returns>A hash code for the current <see cref="RatioChangeRate{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -568,17 +567,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(RatioChangeRateUnit unit)
+        public T As(RatioChangeRateUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -598,17 +597,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is RatioChangeRateUnit unitAsRatioChangeRateUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioChangeRateUnit)} is supported.", nameof(unit));
 
-            return As(unitAsRatioChangeRateUnit);
+            var asValue = As(unitAsRatioChangeRateUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<RatioChangeRateUnit>.As(RatioChangeRateUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this RatioChangeRate to another RatioChangeRate with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="RatioChangeRate{T}" /> to another <see cref="RatioChangeRate{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A RatioChangeRate with the specified unit.</returns>
-        public RatioChangeRate ToUnit(RatioChangeRateUnit unit)
+        /// <returns>A <see cref="RatioChangeRate{T}" /> with the specified unit.</returns>
+        public RatioChangeRate<T> ToUnit(RatioChangeRateUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new RatioChangeRate(convertedValue, unit);
+            return new RatioChangeRate<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -621,7 +625,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public RatioChangeRate ToUnit(UnitSystem unitSystem)
+        public RatioChangeRate<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -641,20 +645,26 @@ public RatioChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RatioChangeRateUnit> IQuantity<RatioChangeRateUnit>.ToUnit(RatioChangeRateUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<RatioChangeRateUnit, T> IQuantityT<RatioChangeRateUnit, T>.ToUnit(RatioChangeRateUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<RatioChangeRateUnit> IQuantity<RatioChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<RatioChangeRateUnit, T> IQuantityT<RatioChangeRateUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case RatioChangeRateUnit.DecimalFractionPerSecond: return _value;
-                case RatioChangeRateUnit.PercentPerSecond: return _value/1e2;
+                case RatioChangeRateUnit.DecimalFractionPerSecond: return Value;
+                case RatioChangeRateUnit.PercentPerSecond: return Value/1e2;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -665,16 +675,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal RatioChangeRate ToBaseUnit()
+        internal RatioChangeRate<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new RatioChangeRate(baseUnitValue, BaseUnit);
+            return new RatioChangeRate<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(RatioChangeRateUnit unit)
+        private T GetValueAs(RatioChangeRateUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -778,57 +788,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RatioChangeRate)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RatioChangeRate<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RatioChangeRate)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RatioChangeRate<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RatioChangeRate)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RatioChangeRate<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -838,33 +848,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(RatioChangeRate))
+            if(conversionType == typeof(RatioChangeRate<T>))
                 return this;
             else if(conversionType == typeof(RatioChangeRateUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return RatioChangeRate.QuantityType;
+                return RatioChangeRate<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return RatioChangeRate.Info;
+                return RatioChangeRate<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return RatioChangeRate.BaseDimensions;
+                return RatioChangeRate<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(RatioChangeRate)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(RatioChangeRate<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
index 9b5e7b1001..952d38474c 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The Volt-ampere reactive hour (expressed as varh) is the reactive power of one Volt-ampere reactive produced in one hour.
     /// </summary>
-    public partial struct ReactiveEnergy : IQuantity<ReactiveEnergyUnit>, IEquatable<ReactiveEnergy>, IComparable, IComparable<ReactiveEnergy>, IConvertible, IFormattable
+    public partial struct ReactiveEnergy<T> : IQuantityT<ReactiveEnergyUnit, T>, IEquatable<ReactiveEnergy<T>>, IComparable, IComparable<ReactiveEnergy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static ReactiveEnergy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ReactiveEnergy(double value, ReactiveEnergyUnit unit)
+        public ReactiveEnergy(T value, ReactiveEnergyUnit unit)
         {
             if(unit == ReactiveEnergyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public ReactiveEnergy(double value, ReactiveEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ReactiveEnergy(double value, UnitSystem unitSystem)
+        public ReactiveEnergy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public ReactiveEnergy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ReactiveEnergy, which is VoltampereReactiveHour. All conversions go via this value.
+        ///     The base unit of <see cref="ReactiveEnergy{T}" />, which is VoltampereReactiveHour. All conversions go via this value.
         /// </summary>
         public static ReactiveEnergyUnit BaseUnit { get; } = ReactiveEnergyUnit.VoltampereReactiveHour;
 
         /// <summary>
-        /// Represents the largest possible value of ReactiveEnergy
+        /// Represents the largest possible value of <see cref="ReactiveEnergy{T}" />
         /// </summary>
-        public static ReactiveEnergy MaxValue { get; } = new ReactiveEnergy(double.MaxValue, BaseUnit);
+        public static ReactiveEnergy<T> MaxValue { get; } = new ReactiveEnergy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ReactiveEnergy
+        /// Represents the smallest possible value of <see cref="ReactiveEnergy{T}" />
         /// </summary>
-        public static ReactiveEnergy MinValue { get; } = new ReactiveEnergy(double.MinValue, BaseUnit);
+        public static ReactiveEnergy<T> MinValue { get; } = new ReactiveEnergy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public ReactiveEnergy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ReactiveEnergy;
 
         /// <summary>
-        ///     All units of measurement for the ReactiveEnergy quantity.
+        ///     All units of measurement for the <see cref="ReactiveEnergy{T}" /> quantity.
         /// </summary>
         public static ReactiveEnergyUnit[] Units { get; } = Enum.GetValues(typeof(ReactiveEnergyUnit)).Cast<ReactiveEnergyUnit>().Except(new ReactiveEnergyUnit[]{ ReactiveEnergyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit VoltampereReactiveHour.
         /// </summary>
-        public static ReactiveEnergy Zero { get; } = new ReactiveEnergy(0, BaseUnit);
+        public static ReactiveEnergy<T> Zero { get; } = new ReactiveEnergy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public ReactiveEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public ReactiveEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ReactiveEnergy.QuantityType;
+        public QuantityType Type => ReactiveEnergy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ReactiveEnergy.BaseDimensions;
+        public BaseDimensions Dimensions => ReactiveEnergy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ReactiveEnergy in KilovoltampereReactiveHours.
+        ///     Get <see cref="ReactiveEnergy{T}" /> in KilovoltampereReactiveHours.
         /// </summary>
-        public double KilovoltampereReactiveHours => As(ReactiveEnergyUnit.KilovoltampereReactiveHour);
+        public T KilovoltampereReactiveHours => As(ReactiveEnergyUnit.KilovoltampereReactiveHour);
 
         /// <summary>
-        ///     Get ReactiveEnergy in MegavoltampereReactiveHours.
+        ///     Get <see cref="ReactiveEnergy{T}" /> in MegavoltampereReactiveHours.
         /// </summary>
-        public double MegavoltampereReactiveHours => As(ReactiveEnergyUnit.MegavoltampereReactiveHour);
+        public T MegavoltampereReactiveHours => As(ReactiveEnergyUnit.MegavoltampereReactiveHour);
 
         /// <summary>
-        ///     Get ReactiveEnergy in VoltampereReactiveHours.
+        ///     Get <see cref="ReactiveEnergy{T}" /> in VoltampereReactiveHours.
         /// </summary>
-        public double VoltampereReactiveHours => As(ReactiveEnergyUnit.VoltampereReactiveHour);
+        public T VoltampereReactiveHours => As(ReactiveEnergyUnit.VoltampereReactiveHour);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(ReactiveEnergyUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ReactiveEnergy from KilovoltampereReactiveHours.
+        ///     Get <see cref="ReactiveEnergy{T}" /> from KilovoltampereReactiveHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromKilovoltampereReactiveHours(QuantityValue kilovoltamperereactivehours)
+        public static ReactiveEnergy<T> FromKilovoltampereReactiveHours(T kilovoltamperereactivehours)
         {
-            double value = (double) kilovoltamperereactivehours;
-            return new ReactiveEnergy(value, ReactiveEnergyUnit.KilovoltampereReactiveHour);
+            return new ReactiveEnergy<T>(kilovoltamperereactivehours, ReactiveEnergyUnit.KilovoltampereReactiveHour);
         }
         /// <summary>
-        ///     Get ReactiveEnergy from MegavoltampereReactiveHours.
+        ///     Get <see cref="ReactiveEnergy{T}" /> from MegavoltampereReactiveHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromMegavoltampereReactiveHours(QuantityValue megavoltamperereactivehours)
+        public static ReactiveEnergy<T> FromMegavoltampereReactiveHours(T megavoltamperereactivehours)
         {
-            double value = (double) megavoltamperereactivehours;
-            return new ReactiveEnergy(value, ReactiveEnergyUnit.MegavoltampereReactiveHour);
+            return new ReactiveEnergy<T>(megavoltamperereactivehours, ReactiveEnergyUnit.MegavoltampereReactiveHour);
         }
         /// <summary>
-        ///     Get ReactiveEnergy from VoltampereReactiveHours.
+        ///     Get <see cref="ReactiveEnergy{T}" /> from VoltampereReactiveHours.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromVoltampereReactiveHours(QuantityValue voltamperereactivehours)
+        public static ReactiveEnergy<T> FromVoltampereReactiveHours(T voltamperereactivehours)
         {
-            double value = (double) voltamperereactivehours;
-            return new ReactiveEnergy(value, ReactiveEnergyUnit.VoltampereReactiveHour);
+            return new ReactiveEnergy<T>(voltamperereactivehours, ReactiveEnergyUnit.VoltampereReactiveHour);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ReactiveEnergyUnit" /> to <see cref="ReactiveEnergy" />.
+        ///     Dynamically convert from value and unit enum <see cref="ReactiveEnergyUnit" /> to <see cref="ReactiveEnergy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ReactiveEnergy unit value.</returns>
-        public static ReactiveEnergy From(QuantityValue value, ReactiveEnergyUnit fromUnit)
+        /// <returns><see cref="ReactiveEnergy{T}" /> unit value.</returns>
+        public static ReactiveEnergy<T> From(T value, ReactiveEnergyUnit fromUnit)
         {
-            return new ReactiveEnergy((double)value, fromUnit);
+            return new ReactiveEnergy<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static ReactiveEnergy From(QuantityValue value, ReactiveEnergyUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ReactiveEnergy Parse(string str)
+        public static ReactiveEnergy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static ReactiveEnergy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ReactiveEnergy Parse(string str, IFormatProvider? provider)
+        public static ReactiveEnergy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ReactiveEnergy, ReactiveEnergyUnit>(
+            return QuantityParser.Default.Parse<T, ReactiveEnergy<T>, ReactiveEnergyUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static ReactiveEnergy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ReactiveEnergy result)
+        public static bool TryParse(string? str, out ReactiveEnergy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out ReactiveEnergy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ReactiveEnergy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ReactiveEnergy<T> result)
         {
-            return QuantityParser.Default.TryParse<ReactiveEnergy, ReactiveEnergyUnit>(
+            return QuantityParser.Default.TryParse<T, ReactiveEnergy<T>, ReactiveEnergyUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out React
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ReactiveEnergy operator -(ReactiveEnergy right)
+        public static ReactiveEnergy<T> operator -(ReactiveEnergy<T> right)
         {
-            return new ReactiveEnergy(-right.Value, right.Unit);
+            return new ReactiveEnergy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ReactiveEnergy"/> from adding two <see cref="ReactiveEnergy"/>.</summary>
-        public static ReactiveEnergy operator +(ReactiveEnergy left, ReactiveEnergy right)
+        /// <summary>Get <see cref="ReactiveEnergy{T}"/> from adding two <see cref="ReactiveEnergy{T}"/>.</summary>
+        public static ReactiveEnergy<T> operator +(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
-            return new ReactiveEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ReactiveEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ReactiveEnergy"/> from subtracting two <see cref="ReactiveEnergy"/>.</summary>
-        public static ReactiveEnergy operator -(ReactiveEnergy left, ReactiveEnergy right)
+        /// <summary>Get <see cref="ReactiveEnergy{T}"/> from subtracting two <see cref="ReactiveEnergy{T}"/>.</summary>
+        public static ReactiveEnergy<T> operator -(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
-            return new ReactiveEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ReactiveEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ReactiveEnergy"/> from multiplying value and <see cref="ReactiveEnergy"/>.</summary>
-        public static ReactiveEnergy operator *(double left, ReactiveEnergy right)
+        /// <summary>Get <see cref="ReactiveEnergy{T}"/> from multiplying value and <see cref="ReactiveEnergy{T}"/>.</summary>
+        public static ReactiveEnergy<T> operator *(T left, ReactiveEnergy<T> right)
         {
-            return new ReactiveEnergy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ReactiveEnergy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ReactiveEnergy"/> from multiplying value and <see cref="ReactiveEnergy"/>.</summary>
-        public static ReactiveEnergy operator *(ReactiveEnergy left, double right)
+        /// <summary>Get <see cref="ReactiveEnergy{T}"/> from multiplying value and <see cref="ReactiveEnergy{T}"/>.</summary>
+        public static ReactiveEnergy<T> operator *(ReactiveEnergy<T> left, T right)
         {
-            return new ReactiveEnergy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ReactiveEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ReactiveEnergy"/> from dividing <see cref="ReactiveEnergy"/> by value.</summary>
-        public static ReactiveEnergy operator /(ReactiveEnergy left, double right)
+        /// <summary>Get <see cref="ReactiveEnergy{T}"/> from dividing <see cref="ReactiveEnergy{T}"/> by value.</summary>
+        public static ReactiveEnergy<T> operator /(ReactiveEnergy<T> left, T right)
         {
-            return new ReactiveEnergy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ReactiveEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ReactiveEnergy"/> by <see cref="ReactiveEnergy"/>.</summary>
-        public static double operator /(ReactiveEnergy left, ReactiveEnergy right)
+        /// <summary>Get ratio value from dividing <see cref="ReactiveEnergy{T}"/> by <see cref="ReactiveEnergy{T}"/>.</summary>
+        public static T operator /(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
-            return left.VoltampereReactiveHours / right.VoltampereReactiveHours;
+            return CompiledLambdas.Divide(left.VoltampereReactiveHours, right.VoltampereReactiveHours);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out React
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ReactiveEnergy left, ReactiveEnergy right)
+        public static bool operator <=(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ReactiveEnergy left, ReactiveEnergy right)
+        public static bool operator >=(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ReactiveEnergy left, ReactiveEnergy right)
+        public static bool operator <(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ReactiveEnergy left, ReactiveEnergy right)
+        public static bool operator >(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ReactiveEnergy left, ReactiveEnergy right)
+        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ReactiveEnergy left, ReactiveEnergy right)
+        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ReactiveEnergy<T> left, ReactiveEnergy<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out React
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ReactiveEnergy objReactiveEnergy)) throw new ArgumentException("Expected type ReactiveEnergy.", nameof(obj));
+            if(!(obj is ReactiveEnergy<T> objReactiveEnergy)) throw new ArgumentException("Expected type ReactiveEnergy.", nameof(obj));
 
             return CompareTo(objReactiveEnergy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ReactiveEnergy other)
+        public int CompareTo(ReactiveEnergy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ReactiveEnergy objReactiveEnergy))
+            if(obj is null || !(obj is ReactiveEnergy<T> objReactiveEnergy))
                 return false;
 
             return Equals(objReactiveEnergy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ReactiveEnergy other)
+        /// <remarks>Consider using <see cref="Equals(ReactiveEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ReactiveEnergy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ReactiveEnergy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ReactiveEnergy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(ReactiveEnergy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ReactiveEnergy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ReactiveEnergy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ReactiveEnergy.</returns>
+        /// <returns>A hash code for the current <see cref="ReactiveEnergy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ReactiveEnergyUnit unit)
+        public T As(ReactiveEnergyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ReactiveEnergyUnit unitAsReactiveEnergyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactiveEnergyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsReactiveEnergyUnit);
+            var asValue = As(unitAsReactiveEnergyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ReactiveEnergyUnit>.As(ReactiveEnergyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ReactiveEnergy to another ReactiveEnergy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ReactiveEnergy{T}" /> to another <see cref="ReactiveEnergy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ReactiveEnergy with the specified unit.</returns>
-        public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit)
+        /// <returns>A <see cref="ReactiveEnergy{T}" /> with the specified unit.</returns>
+        public ReactiveEnergy<T> ToUnit(ReactiveEnergyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ReactiveEnergy(convertedValue, unit);
+            return new ReactiveEnergy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ReactiveEnergy ToUnit(UnitSystem unitSystem)
+        public ReactiveEnergy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public ReactiveEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ReactiveEnergyUnit> IQuantity<ReactiveEnergyUnit>.ToUnit(ReactiveEnergyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ReactiveEnergyUnit, T> IQuantityT<ReactiveEnergyUnit, T>.ToUnit(ReactiveEnergyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ReactiveEnergyUnit> IQuantity<ReactiveEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ReactiveEnergyUnit, T> IQuantityT<ReactiveEnergyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ReactiveEnergyUnit.KilovoltampereReactiveHour: return (_value) * 1e3d;
-                case ReactiveEnergyUnit.MegavoltampereReactiveHour: return (_value) * 1e6d;
-                case ReactiveEnergyUnit.VoltampereReactiveHour: return _value;
+                case ReactiveEnergyUnit.KilovoltampereReactiveHour: return (Value) * 1e3d;
+                case ReactiveEnergyUnit.MegavoltampereReactiveHour: return (Value) * 1e6d;
+                case ReactiveEnergyUnit.VoltampereReactiveHour: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ReactiveEnergy ToBaseUnit()
+        internal ReactiveEnergy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ReactiveEnergy(baseUnitValue, BaseUnit);
+            return new ReactiveEnergy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ReactiveEnergyUnit unit)
+        private T GetValueAs(ReactiveEnergyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ReactiveEnergy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ReactiveEnergy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ReactiveEnergy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ReactiveEnergy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ReactiveEnergy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ReactiveEnergy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ReactiveEnergy))
+            if(conversionType == typeof(ReactiveEnergy<T>))
                 return this;
             else if(conversionType == typeof(ReactiveEnergyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ReactiveEnergy.QuantityType;
+                return ReactiveEnergy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ReactiveEnergy.Info;
+                return ReactiveEnergy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ReactiveEnergy.BaseDimensions;
+                return ReactiveEnergy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ReactiveEnergy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ReactiveEnergy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
index 801781f198..5573327e0d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Volt-ampere reactive (var) is a unit by which reactive power is expressed in an AC electric power system. Reactive power exists in an AC circuit when the current and voltage are not in phase.
     /// </summary>
-    public partial struct ReactivePower : IQuantity<ReactivePowerUnit>, IEquatable<ReactivePower>, IComparable, IComparable<ReactivePower>, IConvertible, IFormattable
+    public partial struct ReactivePower<T> : IQuantityT<ReactivePowerUnit, T>, IEquatable<ReactivePower<T>>, IComparable, IComparable<ReactivePower<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static ReactivePower()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ReactivePower(double value, ReactivePowerUnit unit)
+        public ReactivePower(T value, ReactivePowerUnit unit)
         {
             if(unit == ReactivePowerUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public ReactivePower(double value, ReactivePowerUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ReactivePower(double value, UnitSystem unitSystem)
+        public ReactivePower(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public ReactivePower(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ReactivePower, which is VoltampereReactive. All conversions go via this value.
+        ///     The base unit of <see cref="ReactivePower{T}" />, which is VoltampereReactive. All conversions go via this value.
         /// </summary>
         public static ReactivePowerUnit BaseUnit { get; } = ReactivePowerUnit.VoltampereReactive;
 
         /// <summary>
-        /// Represents the largest possible value of ReactivePower
+        /// Represents the largest possible value of <see cref="ReactivePower{T}" />
         /// </summary>
-        public static ReactivePower MaxValue { get; } = new ReactivePower(double.MaxValue, BaseUnit);
+        public static ReactivePower<T> MaxValue { get; } = new ReactivePower<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ReactivePower
+        /// Represents the smallest possible value of <see cref="ReactivePower{T}" />
         /// </summary>
-        public static ReactivePower MinValue { get; } = new ReactivePower(double.MinValue, BaseUnit);
+        public static ReactivePower<T> MinValue { get; } = new ReactivePower<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public ReactivePower(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ReactivePower;
 
         /// <summary>
-        ///     All units of measurement for the ReactivePower quantity.
+        ///     All units of measurement for the <see cref="ReactivePower{T}" /> quantity.
         /// </summary>
         public static ReactivePowerUnit[] Units { get; } = Enum.GetValues(typeof(ReactivePowerUnit)).Cast<ReactivePowerUnit>().Except(new ReactivePowerUnit[]{ ReactivePowerUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit VoltampereReactive.
         /// </summary>
-        public static ReactivePower Zero { get; } = new ReactivePower(0, BaseUnit);
+        public static ReactivePower<T> Zero { get; } = new ReactivePower<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public ReactivePower(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,36 +156,36 @@ public ReactivePower(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ReactivePower.QuantityType;
+        public QuantityType Type => ReactivePower<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ReactivePower.BaseDimensions;
+        public BaseDimensions Dimensions => ReactivePower<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ReactivePower in GigavoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> in GigavoltamperesReactive.
         /// </summary>
-        public double GigavoltamperesReactive => As(ReactivePowerUnit.GigavoltampereReactive);
+        public T GigavoltamperesReactive => As(ReactivePowerUnit.GigavoltampereReactive);
 
         /// <summary>
-        ///     Get ReactivePower in KilovoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> in KilovoltamperesReactive.
         /// </summary>
-        public double KilovoltamperesReactive => As(ReactivePowerUnit.KilovoltampereReactive);
+        public T KilovoltamperesReactive => As(ReactivePowerUnit.KilovoltampereReactive);
 
         /// <summary>
-        ///     Get ReactivePower in MegavoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> in MegavoltamperesReactive.
         /// </summary>
-        public double MegavoltamperesReactive => As(ReactivePowerUnit.MegavoltampereReactive);
+        public T MegavoltamperesReactive => As(ReactivePowerUnit.MegavoltampereReactive);
 
         /// <summary>
-        ///     Get ReactivePower in VoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> in VoltamperesReactive.
         /// </summary>
-        public double VoltamperesReactive => As(ReactivePowerUnit.VoltampereReactive);
+        public T VoltamperesReactive => As(ReactivePowerUnit.VoltampereReactive);
 
         #endregion
 
@@ -219,51 +217,47 @@ public static string GetAbbreviation(ReactivePowerUnit unit, IFormatProvider? pr
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ReactivePower from GigavoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> from GigavoltamperesReactive.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromGigavoltamperesReactive(QuantityValue gigavoltamperesreactive)
+        public static ReactivePower<T> FromGigavoltamperesReactive(T gigavoltamperesreactive)
         {
-            double value = (double) gigavoltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.GigavoltampereReactive);
+            return new ReactivePower<T>(gigavoltamperesreactive, ReactivePowerUnit.GigavoltampereReactive);
         }
         /// <summary>
-        ///     Get ReactivePower from KilovoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> from KilovoltamperesReactive.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromKilovoltamperesReactive(QuantityValue kilovoltamperesreactive)
+        public static ReactivePower<T> FromKilovoltamperesReactive(T kilovoltamperesreactive)
         {
-            double value = (double) kilovoltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.KilovoltampereReactive);
+            return new ReactivePower<T>(kilovoltamperesreactive, ReactivePowerUnit.KilovoltampereReactive);
         }
         /// <summary>
-        ///     Get ReactivePower from MegavoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> from MegavoltamperesReactive.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromMegavoltamperesReactive(QuantityValue megavoltamperesreactive)
+        public static ReactivePower<T> FromMegavoltamperesReactive(T megavoltamperesreactive)
         {
-            double value = (double) megavoltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.MegavoltampereReactive);
+            return new ReactivePower<T>(megavoltamperesreactive, ReactivePowerUnit.MegavoltampereReactive);
         }
         /// <summary>
-        ///     Get ReactivePower from VoltamperesReactive.
+        ///     Get <see cref="ReactivePower{T}" /> from VoltamperesReactive.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromVoltamperesReactive(QuantityValue voltamperesreactive)
+        public static ReactivePower<T> FromVoltamperesReactive(T voltamperesreactive)
         {
-            double value = (double) voltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.VoltampereReactive);
+            return new ReactivePower<T>(voltamperesreactive, ReactivePowerUnit.VoltampereReactive);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ReactivePowerUnit" /> to <see cref="ReactivePower" />.
+        ///     Dynamically convert from value and unit enum <see cref="ReactivePowerUnit" /> to <see cref="ReactivePower{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ReactivePower unit value.</returns>
-        public static ReactivePower From(QuantityValue value, ReactivePowerUnit fromUnit)
+        /// <returns><see cref="ReactivePower{T}" /> unit value.</returns>
+        public static ReactivePower<T> From(T value, ReactivePowerUnit fromUnit)
         {
-            return new ReactivePower((double)value, fromUnit);
+            return new ReactivePower<T>(value, fromUnit);
         }
 
         #endregion
@@ -292,7 +286,7 @@ public static ReactivePower From(QuantityValue value, ReactivePowerUnit fromUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ReactivePower Parse(string str)
+        public static ReactivePower<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -320,9 +314,9 @@ public static ReactivePower Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ReactivePower Parse(string str, IFormatProvider? provider)
+        public static ReactivePower<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ReactivePower, ReactivePowerUnit>(
+            return QuantityParser.Default.Parse<T, ReactivePower<T>, ReactivePowerUnit>(
                 str,
                 provider,
                 From);
@@ -336,7 +330,7 @@ public static ReactivePower Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ReactivePower result)
+        public static bool TryParse(string? str, out ReactivePower<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -351,9 +345,9 @@ public static bool TryParse(string? str, out ReactivePower result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ReactivePower result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ReactivePower<T> result)
         {
-            return QuantityParser.Default.TryParse<ReactivePower, ReactivePowerUnit>(
+            return QuantityParser.Default.TryParse<T, ReactivePower<T>, ReactivePowerUnit>(
                 str,
                 provider,
                 From,
@@ -415,45 +409,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out React
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ReactivePower operator -(ReactivePower right)
+        public static ReactivePower<T> operator -(ReactivePower<T> right)
         {
-            return new ReactivePower(-right.Value, right.Unit);
+            return new ReactivePower<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ReactivePower"/> from adding two <see cref="ReactivePower"/>.</summary>
-        public static ReactivePower operator +(ReactivePower left, ReactivePower right)
+        /// <summary>Get <see cref="ReactivePower{T}"/> from adding two <see cref="ReactivePower{T}"/>.</summary>
+        public static ReactivePower<T> operator +(ReactivePower<T> left, ReactivePower<T> right)
         {
-            return new ReactivePower(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ReactivePower<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ReactivePower"/> from subtracting two <see cref="ReactivePower"/>.</summary>
-        public static ReactivePower operator -(ReactivePower left, ReactivePower right)
+        /// <summary>Get <see cref="ReactivePower{T}"/> from subtracting two <see cref="ReactivePower{T}"/>.</summary>
+        public static ReactivePower<T> operator -(ReactivePower<T> left, ReactivePower<T> right)
         {
-            return new ReactivePower(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ReactivePower<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ReactivePower"/> from multiplying value and <see cref="ReactivePower"/>.</summary>
-        public static ReactivePower operator *(double left, ReactivePower right)
+        /// <summary>Get <see cref="ReactivePower{T}"/> from multiplying value and <see cref="ReactivePower{T}"/>.</summary>
+        public static ReactivePower<T> operator *(T left, ReactivePower<T> right)
         {
-            return new ReactivePower(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ReactivePower<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ReactivePower"/> from multiplying value and <see cref="ReactivePower"/>.</summary>
-        public static ReactivePower operator *(ReactivePower left, double right)
+        /// <summary>Get <see cref="ReactivePower{T}"/> from multiplying value and <see cref="ReactivePower{T}"/>.</summary>
+        public static ReactivePower<T> operator *(ReactivePower<T> left, T right)
         {
-            return new ReactivePower(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ReactivePower<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ReactivePower"/> from dividing <see cref="ReactivePower"/> by value.</summary>
-        public static ReactivePower operator /(ReactivePower left, double right)
+        /// <summary>Get <see cref="ReactivePower{T}"/> from dividing <see cref="ReactivePower{T}"/> by value.</summary>
+        public static ReactivePower<T> operator /(ReactivePower<T> left, T right)
         {
-            return new ReactivePower(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ReactivePower<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ReactivePower"/> by <see cref="ReactivePower"/>.</summary>
-        public static double operator /(ReactivePower left, ReactivePower right)
+        /// <summary>Get ratio value from dividing <see cref="ReactivePower{T}"/> by <see cref="ReactivePower{T}"/>.</summary>
+        public static T operator /(ReactivePower<T> left, ReactivePower<T> right)
         {
-            return left.VoltamperesReactive / right.VoltamperesReactive;
+            return CompiledLambdas.Divide(left.VoltamperesReactive, right.VoltamperesReactive);
         }
 
         #endregion
@@ -461,39 +460,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out React
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ReactivePower left, ReactivePower right)
+        public static bool operator <=(ReactivePower<T> left, ReactivePower<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ReactivePower left, ReactivePower right)
+        public static bool operator >=(ReactivePower<T> left, ReactivePower<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ReactivePower left, ReactivePower right)
+        public static bool operator <(ReactivePower<T> left, ReactivePower<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ReactivePower left, ReactivePower right)
+        public static bool operator >(ReactivePower<T> left, ReactivePower<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ReactivePower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ReactivePower left, ReactivePower right)
+        /// <remarks>Consider using <see cref="Equals(ReactivePower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ReactivePower<T> left, ReactivePower<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ReactivePower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ReactivePower left, ReactivePower right)
+        /// <remarks>Consider using <see cref="Equals(ReactivePower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ReactivePower<T> left, ReactivePower<T> right)
         {
             return !(left == right);
         }
@@ -502,37 +501,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out React
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ReactivePower objReactivePower)) throw new ArgumentException("Expected type ReactivePower.", nameof(obj));
+            if(!(obj is ReactivePower<T> objReactivePower)) throw new ArgumentException("Expected type ReactivePower.", nameof(obj));
 
             return CompareTo(objReactivePower);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ReactivePower other)
+        public int CompareTo(ReactivePower<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ReactivePower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ReactivePower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ReactivePower objReactivePower))
+            if(obj is null || !(obj is ReactivePower<T> objReactivePower))
                 return false;
 
             return Equals(objReactivePower);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ReactivePower, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ReactivePower other)
+        /// <remarks>Consider using <see cref="Equals(ReactivePower{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ReactivePower<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ReactivePower within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ReactivePower{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -570,21 +569,19 @@ public bool Equals(ReactivePower other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ReactivePower other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ReactivePower<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ReactivePower.</returns>
+        /// <returns>A hash code for the current <see cref="ReactivePower{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -598,17 +595,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ReactivePowerUnit unit)
+        public T As(ReactivePowerUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -628,17 +625,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ReactivePowerUnit unitAsReactivePowerUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactivePowerUnit)} is supported.", nameof(unit));
 
-            return As(unitAsReactivePowerUnit);
+            var asValue = As(unitAsReactivePowerUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ReactivePowerUnit>.As(ReactivePowerUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ReactivePower to another ReactivePower with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ReactivePower{T}" /> to another <see cref="ReactivePower{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ReactivePower with the specified unit.</returns>
-        public ReactivePower ToUnit(ReactivePowerUnit unit)
+        /// <returns>A <see cref="ReactivePower{T}" /> with the specified unit.</returns>
+        public ReactivePower<T> ToUnit(ReactivePowerUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ReactivePower(convertedValue, unit);
+            return new ReactivePower<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -651,7 +653,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ReactivePower ToUnit(UnitSystem unitSystem)
+        public ReactivePower<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -671,22 +673,28 @@ public ReactivePower ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ReactivePowerUnit> IQuantity<ReactivePowerUnit>.ToUnit(ReactivePowerUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ReactivePowerUnit, T> IQuantityT<ReactivePowerUnit, T>.ToUnit(ReactivePowerUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ReactivePowerUnit> IQuantity<ReactivePowerUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ReactivePowerUnit, T> IQuantityT<ReactivePowerUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ReactivePowerUnit.GigavoltampereReactive: return (_value) * 1e9d;
-                case ReactivePowerUnit.KilovoltampereReactive: return (_value) * 1e3d;
-                case ReactivePowerUnit.MegavoltampereReactive: return (_value) * 1e6d;
-                case ReactivePowerUnit.VoltampereReactive: return _value;
+                case ReactivePowerUnit.GigavoltampereReactive: return (Value) * 1e9d;
+                case ReactivePowerUnit.KilovoltampereReactive: return (Value) * 1e3d;
+                case ReactivePowerUnit.MegavoltampereReactive: return (Value) * 1e6d;
+                case ReactivePowerUnit.VoltampereReactive: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -697,16 +705,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ReactivePower ToBaseUnit()
+        internal ReactivePower<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ReactivePower(baseUnitValue, BaseUnit);
+            return new ReactivePower<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ReactivePowerUnit unit)
+        private T GetValueAs(ReactivePowerUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -812,57 +820,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ReactivePower)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ReactivePower<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ReactivePower)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ReactivePower<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ReactivePower)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ReactivePower<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -872,33 +880,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ReactivePower))
+            if(conversionType == typeof(ReactivePower<T>))
                 return this;
             else if(conversionType == typeof(ReactivePowerUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ReactivePower.QuantityType;
+                return ReactivePower<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ReactivePower.Info;
+                return ReactivePower<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ReactivePower.BaseDimensions;
+                return ReactivePower<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ReactivePower)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ReactivePower<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
index ff5f946ed7..cc1c117418 100644
--- a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Relative humidity is a ratio of the actual water vapor present in the air to the maximum water vapor in the air at the given temperature.
     /// </summary>
-    public partial struct RelativeHumidity : IQuantity<RelativeHumidityUnit>, IEquatable<RelativeHumidity>, IComparable, IComparable<RelativeHumidity>, IConvertible, IFormattable
+    public partial struct RelativeHumidity<T> : IQuantityT<RelativeHumidityUnit, T>, IEquatable<RelativeHumidity<T>>, IComparable, IComparable<RelativeHumidity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -63,12 +59,12 @@ static RelativeHumidity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public RelativeHumidity(double value, RelativeHumidityUnit unit)
+        public RelativeHumidity(T value, RelativeHumidityUnit unit)
         {
             if(unit == RelativeHumidityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -80,14 +76,14 @@ public RelativeHumidity(double value, RelativeHumidityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RelativeHumidity(double value, UnitSystem unitSystem)
+        public RelativeHumidity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -102,19 +98,19 @@ public RelativeHumidity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of RelativeHumidity, which is Percent. All conversions go via this value.
+        ///     The base unit of <see cref="RelativeHumidity{T}" />, which is Percent. All conversions go via this value.
         /// </summary>
         public static RelativeHumidityUnit BaseUnit { get; } = RelativeHumidityUnit.Percent;
 
         /// <summary>
-        /// Represents the largest possible value of RelativeHumidity
+        /// Represents the largest possible value of <see cref="RelativeHumidity{T}" />
         /// </summary>
-        public static RelativeHumidity MaxValue { get; } = new RelativeHumidity(double.MaxValue, BaseUnit);
+        public static RelativeHumidity<T> MaxValue { get; } = new RelativeHumidity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of RelativeHumidity
+        /// Represents the smallest possible value of <see cref="RelativeHumidity{T}" />
         /// </summary>
-        public static RelativeHumidity MinValue { get; } = new RelativeHumidity(double.MinValue, BaseUnit);
+        public static RelativeHumidity<T> MinValue { get; } = new RelativeHumidity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -123,14 +119,14 @@ public RelativeHumidity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.RelativeHumidity;
 
         /// <summary>
-        ///     All units of measurement for the RelativeHumidity quantity.
+        ///     All units of measurement for the <see cref="RelativeHumidity{T}" /> quantity.
         /// </summary>
         public static RelativeHumidityUnit[] Units { get; } = Enum.GetValues(typeof(RelativeHumidityUnit)).Cast<RelativeHumidityUnit>().Except(new RelativeHumidityUnit[]{ RelativeHumidityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Percent.
         /// </summary>
-        public static RelativeHumidity Zero { get; } = new RelativeHumidity(0, BaseUnit);
+        public static RelativeHumidity<T> Zero { get; } = new RelativeHumidity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -139,7 +135,9 @@ public RelativeHumidity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -155,21 +153,21 @@ public RelativeHumidity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => RelativeHumidity.QuantityType;
+        public QuantityType Type => RelativeHumidity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => RelativeHumidity.BaseDimensions;
+        public BaseDimensions Dimensions => RelativeHumidity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get RelativeHumidity in Percent.
+        ///     Get <see cref="RelativeHumidity{T}" /> in Percent.
         /// </summary>
-        public double Percent => As(RelativeHumidityUnit.Percent);
+        public T Percent => As(RelativeHumidityUnit.Percent);
 
         #endregion
 
@@ -201,24 +199,23 @@ public static string GetAbbreviation(RelativeHumidityUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get RelativeHumidity from Percent.
+        ///     Get <see cref="RelativeHumidity{T}" /> from Percent.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RelativeHumidity FromPercent(QuantityValue percent)
+        public static RelativeHumidity<T> FromPercent(T percent)
         {
-            double value = (double) percent;
-            return new RelativeHumidity(value, RelativeHumidityUnit.Percent);
+            return new RelativeHumidity<T>(percent, RelativeHumidityUnit.Percent);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RelativeHumidityUnit" /> to <see cref="RelativeHumidity" />.
+        ///     Dynamically convert from value and unit enum <see cref="RelativeHumidityUnit" /> to <see cref="RelativeHumidity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RelativeHumidity unit value.</returns>
-        public static RelativeHumidity From(QuantityValue value, RelativeHumidityUnit fromUnit)
+        /// <returns><see cref="RelativeHumidity{T}" /> unit value.</returns>
+        public static RelativeHumidity<T> From(T value, RelativeHumidityUnit fromUnit)
         {
-            return new RelativeHumidity((double)value, fromUnit);
+            return new RelativeHumidity<T>(value, fromUnit);
         }
 
         #endregion
@@ -247,7 +244,7 @@ public static RelativeHumidity From(QuantityValue value, RelativeHumidityUnit fr
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static RelativeHumidity Parse(string str)
+        public static RelativeHumidity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -275,9 +272,9 @@ public static RelativeHumidity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static RelativeHumidity Parse(string str, IFormatProvider? provider)
+        public static RelativeHumidity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<RelativeHumidity, RelativeHumidityUnit>(
+            return QuantityParser.Default.Parse<T, RelativeHumidity<T>, RelativeHumidityUnit>(
                 str,
                 provider,
                 From);
@@ -291,7 +288,7 @@ public static RelativeHumidity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out RelativeHumidity result)
+        public static bool TryParse(string? str, out RelativeHumidity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -306,9 +303,9 @@ public static bool TryParse(string? str, out RelativeHumidity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out RelativeHumidity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out RelativeHumidity<T> result)
         {
-            return QuantityParser.Default.TryParse<RelativeHumidity, RelativeHumidityUnit>(
+            return QuantityParser.Default.TryParse<T, RelativeHumidity<T>, RelativeHumidityUnit>(
                 str,
                 provider,
                 From,
@@ -370,45 +367,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Relat
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static RelativeHumidity operator -(RelativeHumidity right)
+        public static RelativeHumidity<T> operator -(RelativeHumidity<T> right)
         {
-            return new RelativeHumidity(-right.Value, right.Unit);
+            return new RelativeHumidity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="RelativeHumidity"/> from adding two <see cref="RelativeHumidity"/>.</summary>
-        public static RelativeHumidity operator +(RelativeHumidity left, RelativeHumidity right)
+        /// <summary>Get <see cref="RelativeHumidity{T}"/> from adding two <see cref="RelativeHumidity{T}"/>.</summary>
+        public static RelativeHumidity<T> operator +(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
-            return new RelativeHumidity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new RelativeHumidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RelativeHumidity"/> from subtracting two <see cref="RelativeHumidity"/>.</summary>
-        public static RelativeHumidity operator -(RelativeHumidity left, RelativeHumidity right)
+        /// <summary>Get <see cref="RelativeHumidity{T}"/> from subtracting two <see cref="RelativeHumidity{T}"/>.</summary>
+        public static RelativeHumidity<T> operator -(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
-            return new RelativeHumidity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new RelativeHumidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RelativeHumidity"/> from multiplying value and <see cref="RelativeHumidity"/>.</summary>
-        public static RelativeHumidity operator *(double left, RelativeHumidity right)
+        /// <summary>Get <see cref="RelativeHumidity{T}"/> from multiplying value and <see cref="RelativeHumidity{T}"/>.</summary>
+        public static RelativeHumidity<T> operator *(T left, RelativeHumidity<T> right)
         {
-            return new RelativeHumidity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new RelativeHumidity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="RelativeHumidity"/> from multiplying value and <see cref="RelativeHumidity"/>.</summary>
-        public static RelativeHumidity operator *(RelativeHumidity left, double right)
+        /// <summary>Get <see cref="RelativeHumidity{T}"/> from multiplying value and <see cref="RelativeHumidity{T}"/>.</summary>
+        public static RelativeHumidity<T> operator *(RelativeHumidity<T> left, T right)
         {
-            return new RelativeHumidity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new RelativeHumidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RelativeHumidity"/> from dividing <see cref="RelativeHumidity"/> by value.</summary>
-        public static RelativeHumidity operator /(RelativeHumidity left, double right)
+        /// <summary>Get <see cref="RelativeHumidity{T}"/> from dividing <see cref="RelativeHumidity{T}"/> by value.</summary>
+        public static RelativeHumidity<T> operator /(RelativeHumidity<T> left, T right)
         {
-            return new RelativeHumidity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new RelativeHumidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="RelativeHumidity"/> by <see cref="RelativeHumidity"/>.</summary>
-        public static double operator /(RelativeHumidity left, RelativeHumidity right)
+        /// <summary>Get ratio value from dividing <see cref="RelativeHumidity{T}"/> by <see cref="RelativeHumidity{T}"/>.</summary>
+        public static T operator /(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
-            return left.Percent / right.Percent;
+            return CompiledLambdas.Divide(left.Percent, right.Percent);
         }
 
         #endregion
@@ -416,39 +418,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Relat
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(RelativeHumidity left, RelativeHumidity right)
+        public static bool operator <=(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(RelativeHumidity left, RelativeHumidity right)
+        public static bool operator >=(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(RelativeHumidity left, RelativeHumidity right)
+        public static bool operator <(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(RelativeHumidity left, RelativeHumidity right)
+        public static bool operator >(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RelativeHumidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(RelativeHumidity left, RelativeHumidity right)
+        /// <remarks>Consider using <see cref="Equals(RelativeHumidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RelativeHumidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(RelativeHumidity left, RelativeHumidity right)
+        /// <remarks>Consider using <see cref="Equals(RelativeHumidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(RelativeHumidity<T> left, RelativeHumidity<T> right)
         {
             return !(left == right);
         }
@@ -457,37 +459,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Relat
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is RelativeHumidity objRelativeHumidity)) throw new ArgumentException("Expected type RelativeHumidity.", nameof(obj));
+            if(!(obj is RelativeHumidity<T> objRelativeHumidity)) throw new ArgumentException("Expected type RelativeHumidity.", nameof(obj));
 
             return CompareTo(objRelativeHumidity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(RelativeHumidity other)
+        public int CompareTo(RelativeHumidity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RelativeHumidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(RelativeHumidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is RelativeHumidity objRelativeHumidity))
+            if(obj is null || !(obj is RelativeHumidity<T> objRelativeHumidity))
                 return false;
 
             return Equals(objRelativeHumidity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RelativeHumidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(RelativeHumidity other)
+        /// <remarks>Consider using <see cref="Equals(RelativeHumidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(RelativeHumidity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another RelativeHumidity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="RelativeHumidity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -525,21 +527,19 @@ public bool Equals(RelativeHumidity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(RelativeHumidity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(RelativeHumidity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current RelativeHumidity.</returns>
+        /// <returns>A hash code for the current <see cref="RelativeHumidity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -553,17 +553,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(RelativeHumidityUnit unit)
+        public T As(RelativeHumidityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -583,17 +583,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is RelativeHumidityUnit unitAsRelativeHumidityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RelativeHumidityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsRelativeHumidityUnit);
+            var asValue = As(unitAsRelativeHumidityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<RelativeHumidityUnit>.As(RelativeHumidityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this RelativeHumidity to another RelativeHumidity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="RelativeHumidity{T}" /> to another <see cref="RelativeHumidity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A RelativeHumidity with the specified unit.</returns>
-        public RelativeHumidity ToUnit(RelativeHumidityUnit unit)
+        /// <returns>A <see cref="RelativeHumidity{T}" /> with the specified unit.</returns>
+        public RelativeHumidity<T> ToUnit(RelativeHumidityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new RelativeHumidity(convertedValue, unit);
+            return new RelativeHumidity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -606,7 +611,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public RelativeHumidity ToUnit(UnitSystem unitSystem)
+        public RelativeHumidity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -626,19 +631,25 @@ public RelativeHumidity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RelativeHumidityUnit> IQuantity<RelativeHumidityUnit>.ToUnit(RelativeHumidityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<RelativeHumidityUnit, T> IQuantityT<RelativeHumidityUnit, T>.ToUnit(RelativeHumidityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<RelativeHumidityUnit> IQuantity<RelativeHumidityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<RelativeHumidityUnit, T> IQuantityT<RelativeHumidityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case RelativeHumidityUnit.Percent: return _value;
+                case RelativeHumidityUnit.Percent: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -649,16 +660,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal RelativeHumidity ToBaseUnit()
+        internal RelativeHumidity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new RelativeHumidity(baseUnitValue, BaseUnit);
+            return new RelativeHumidity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(RelativeHumidityUnit unit)
+        private T GetValueAs(RelativeHumidityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -761,57 +772,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RelativeHumidity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RelativeHumidity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RelativeHumidity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RelativeHumidity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RelativeHumidity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RelativeHumidity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -821,33 +832,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(RelativeHumidity))
+            if(conversionType == typeof(RelativeHumidity<T>))
                 return this;
             else if(conversionType == typeof(RelativeHumidityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return RelativeHumidity.QuantityType;
+                return RelativeHumidity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return RelativeHumidity.Info;
+                return RelativeHumidity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return RelativeHumidity.BaseDimensions;
+                return RelativeHumidity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(RelativeHumidity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(RelativeHumidity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
index dc18da238f..0e0ea855af 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Angular acceleration is the rate of change of rotational speed.
     /// </summary>
-    public partial struct RotationalAcceleration : IQuantity<RotationalAccelerationUnit>, IEquatable<RotationalAcceleration>, IComparable, IComparable<RotationalAcceleration>, IConvertible, IFormattable
+    public partial struct RotationalAcceleration<T> : IQuantityT<RotationalAccelerationUnit, T>, IEquatable<RotationalAcceleration<T>>, IComparable, IComparable<RotationalAcceleration<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static RotationalAcceleration()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public RotationalAcceleration(double value, RotationalAccelerationUnit unit)
+        public RotationalAcceleration(T value, RotationalAccelerationUnit unit)
         {
             if(unit == RotationalAccelerationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public RotationalAcceleration(double value, RotationalAccelerationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalAcceleration(double value, UnitSystem unitSystem)
+        public RotationalAcceleration(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of RotationalAcceleration, which is RadianPerSecondSquared. All conversions go via this value.
+        ///     The base unit of <see cref="RotationalAcceleration{T}" />, which is RadianPerSecondSquared. All conversions go via this value.
         /// </summary>
         public static RotationalAccelerationUnit BaseUnit { get; } = RotationalAccelerationUnit.RadianPerSecondSquared;
 
         /// <summary>
-        /// Represents the largest possible value of RotationalAcceleration
+        /// Represents the largest possible value of <see cref="RotationalAcceleration{T}" />
         /// </summary>
-        public static RotationalAcceleration MaxValue { get; } = new RotationalAcceleration(double.MaxValue, BaseUnit);
+        public static RotationalAcceleration<T> MaxValue { get; } = new RotationalAcceleration<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of RotationalAcceleration
+        /// Represents the smallest possible value of <see cref="RotationalAcceleration{T}" />
         /// </summary>
-        public static RotationalAcceleration MinValue { get; } = new RotationalAcceleration(double.MinValue, BaseUnit);
+        public static RotationalAcceleration<T> MinValue { get; } = new RotationalAcceleration<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.RotationalAcceleration;
 
         /// <summary>
-        ///     All units of measurement for the RotationalAcceleration quantity.
+        ///     All units of measurement for the <see cref="RotationalAcceleration{T}" /> quantity.
         /// </summary>
         public static RotationalAccelerationUnit[] Units { get; } = Enum.GetValues(typeof(RotationalAccelerationUnit)).Cast<RotationalAccelerationUnit>().Except(new RotationalAccelerationUnit[]{ RotationalAccelerationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit RadianPerSecondSquared.
         /// </summary>
-        public static RotationalAcceleration Zero { get; } = new RotationalAcceleration(0, BaseUnit);
+        public static RotationalAcceleration<T> Zero { get; } = new RotationalAcceleration<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,36 +156,36 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => RotationalAcceleration.QuantityType;
+        public QuantityType Type => RotationalAcceleration<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => RotationalAcceleration.BaseDimensions;
+        public BaseDimensions Dimensions => RotationalAcceleration<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get RotationalAcceleration in DegreesPerSecondSquared.
+        ///     Get <see cref="RotationalAcceleration{T}" /> in DegreesPerSecondSquared.
         /// </summary>
-        public double DegreesPerSecondSquared => As(RotationalAccelerationUnit.DegreePerSecondSquared);
+        public T DegreesPerSecondSquared => As(RotationalAccelerationUnit.DegreePerSecondSquared);
 
         /// <summary>
-        ///     Get RotationalAcceleration in RadiansPerSecondSquared.
+        ///     Get <see cref="RotationalAcceleration{T}" /> in RadiansPerSecondSquared.
         /// </summary>
-        public double RadiansPerSecondSquared => As(RotationalAccelerationUnit.RadianPerSecondSquared);
+        public T RadiansPerSecondSquared => As(RotationalAccelerationUnit.RadianPerSecondSquared);
 
         /// <summary>
-        ///     Get RotationalAcceleration in RevolutionsPerMinutePerSecond.
+        ///     Get <see cref="RotationalAcceleration{T}" /> in RevolutionsPerMinutePerSecond.
         /// </summary>
-        public double RevolutionsPerMinutePerSecond => As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
+        public T RevolutionsPerMinutePerSecond => As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
 
         /// <summary>
-        ///     Get RotationalAcceleration in RevolutionsPerSecondSquared.
+        ///     Get <see cref="RotationalAcceleration{T}" /> in RevolutionsPerSecondSquared.
         /// </summary>
-        public double RevolutionsPerSecondSquared => As(RotationalAccelerationUnit.RevolutionPerSecondSquared);
+        public T RevolutionsPerSecondSquared => As(RotationalAccelerationUnit.RevolutionPerSecondSquared);
 
         #endregion
 
@@ -219,51 +217,47 @@ public static string GetAbbreviation(RotationalAccelerationUnit unit, IFormatPro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get RotationalAcceleration from DegreesPerSecondSquared.
+        ///     Get <see cref="RotationalAcceleration{T}" /> from DegreesPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromDegreesPerSecondSquared(QuantityValue degreespersecondsquared)
+        public static RotationalAcceleration<T> FromDegreesPerSecondSquared(T degreespersecondsquared)
         {
-            double value = (double) degreespersecondsquared;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared);
+            return new RotationalAcceleration<T>(degreespersecondsquared, RotationalAccelerationUnit.DegreePerSecondSquared);
         }
         /// <summary>
-        ///     Get RotationalAcceleration from RadiansPerSecondSquared.
+        ///     Get <see cref="RotationalAcceleration{T}" /> from RadiansPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRadiansPerSecondSquared(QuantityValue radianspersecondsquared)
+        public static RotationalAcceleration<T> FromRadiansPerSecondSquared(T radianspersecondsquared)
         {
-            double value = (double) radianspersecondsquared;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared);
+            return new RotationalAcceleration<T>(radianspersecondsquared, RotationalAccelerationUnit.RadianPerSecondSquared);
         }
         /// <summary>
-        ///     Get RotationalAcceleration from RevolutionsPerMinutePerSecond.
+        ///     Get <see cref="RotationalAcceleration{T}" /> from RevolutionsPerMinutePerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(QuantityValue revolutionsperminutepersecond)
+        public static RotationalAcceleration<T> FromRevolutionsPerMinutePerSecond(T revolutionsperminutepersecond)
         {
-            double value = (double) revolutionsperminutepersecond;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
+            return new RotationalAcceleration<T>(revolutionsperminutepersecond, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
         }
         /// <summary>
-        ///     Get RotationalAcceleration from RevolutionsPerSecondSquared.
+        ///     Get <see cref="RotationalAcceleration{T}" /> from RevolutionsPerSecondSquared.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRevolutionsPerSecondSquared(QuantityValue revolutionspersecondsquared)
+        public static RotationalAcceleration<T> FromRevolutionsPerSecondSquared(T revolutionspersecondsquared)
         {
-            double value = (double) revolutionspersecondsquared;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared);
+            return new RotationalAcceleration<T>(revolutionspersecondsquared, RotationalAccelerationUnit.RevolutionPerSecondSquared);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalAccelerationUnit" /> to <see cref="RotationalAcceleration" />.
+        ///     Dynamically convert from value and unit enum <see cref="RotationalAccelerationUnit" /> to <see cref="RotationalAcceleration{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalAcceleration unit value.</returns>
-        public static RotationalAcceleration From(QuantityValue value, RotationalAccelerationUnit fromUnit)
+        /// <returns><see cref="RotationalAcceleration{T}" /> unit value.</returns>
+        public static RotationalAcceleration<T> From(T value, RotationalAccelerationUnit fromUnit)
         {
-            return new RotationalAcceleration((double)value, fromUnit);
+            return new RotationalAcceleration<T>(value, fromUnit);
         }
 
         #endregion
@@ -292,7 +286,7 @@ public static RotationalAcceleration From(QuantityValue value, RotationalAcceler
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static RotationalAcceleration Parse(string str)
+        public static RotationalAcceleration<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -320,9 +314,9 @@ public static RotationalAcceleration Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static RotationalAcceleration Parse(string str, IFormatProvider? provider)
+        public static RotationalAcceleration<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<RotationalAcceleration, RotationalAccelerationUnit>(
+            return QuantityParser.Default.Parse<T, RotationalAcceleration<T>, RotationalAccelerationUnit>(
                 str,
                 provider,
                 From);
@@ -336,7 +330,7 @@ public static RotationalAcceleration Parse(string str, IFormatProvider? provider
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out RotationalAcceleration result)
+        public static bool TryParse(string? str, out RotationalAcceleration<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -351,9 +345,9 @@ public static bool TryParse(string? str, out RotationalAcceleration result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalAcceleration result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalAcceleration<T> result)
         {
-            return QuantityParser.Default.TryParse<RotationalAcceleration, RotationalAccelerationUnit>(
+            return QuantityParser.Default.TryParse<T, RotationalAcceleration<T>, RotationalAccelerationUnit>(
                 str,
                 provider,
                 From,
@@ -415,45 +409,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static RotationalAcceleration operator -(RotationalAcceleration right)
+        public static RotationalAcceleration<T> operator -(RotationalAcceleration<T> right)
         {
-            return new RotationalAcceleration(-right.Value, right.Unit);
+            return new RotationalAcceleration<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalAcceleration"/> from adding two <see cref="RotationalAcceleration"/>.</summary>
-        public static RotationalAcceleration operator +(RotationalAcceleration left, RotationalAcceleration right)
+        /// <summary>Get <see cref="RotationalAcceleration{T}"/> from adding two <see cref="RotationalAcceleration{T}"/>.</summary>
+        public static RotationalAcceleration<T> operator +(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
-            return new RotationalAcceleration(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalAcceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalAcceleration"/> from subtracting two <see cref="RotationalAcceleration"/>.</summary>
-        public static RotationalAcceleration operator -(RotationalAcceleration left, RotationalAcceleration right)
+        /// <summary>Get <see cref="RotationalAcceleration{T}"/> from subtracting two <see cref="RotationalAcceleration{T}"/>.</summary>
+        public static RotationalAcceleration<T> operator -(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
-            return new RotationalAcceleration(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalAcceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalAcceleration"/> from multiplying value and <see cref="RotationalAcceleration"/>.</summary>
-        public static RotationalAcceleration operator *(double left, RotationalAcceleration right)
+        /// <summary>Get <see cref="RotationalAcceleration{T}"/> from multiplying value and <see cref="RotationalAcceleration{T}"/>.</summary>
+        public static RotationalAcceleration<T> operator *(T left, RotationalAcceleration<T> right)
         {
-            return new RotationalAcceleration(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new RotationalAcceleration<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalAcceleration"/> from multiplying value and <see cref="RotationalAcceleration"/>.</summary>
-        public static RotationalAcceleration operator *(RotationalAcceleration left, double right)
+        /// <summary>Get <see cref="RotationalAcceleration{T}"/> from multiplying value and <see cref="RotationalAcceleration{T}"/>.</summary>
+        public static RotationalAcceleration<T> operator *(RotationalAcceleration<T> left, T right)
         {
-            return new RotationalAcceleration(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new RotationalAcceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalAcceleration"/> from dividing <see cref="RotationalAcceleration"/> by value.</summary>
-        public static RotationalAcceleration operator /(RotationalAcceleration left, double right)
+        /// <summary>Get <see cref="RotationalAcceleration{T}"/> from dividing <see cref="RotationalAcceleration{T}"/> by value.</summary>
+        public static RotationalAcceleration<T> operator /(RotationalAcceleration<T> left, T right)
         {
-            return new RotationalAcceleration(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new RotationalAcceleration<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="RotationalAcceleration"/> by <see cref="RotationalAcceleration"/>.</summary>
-        public static double operator /(RotationalAcceleration left, RotationalAcceleration right)
+        /// <summary>Get ratio value from dividing <see cref="RotationalAcceleration{T}"/> by <see cref="RotationalAcceleration{T}"/>.</summary>
+        public static T operator /(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
-            return left.RadiansPerSecondSquared / right.RadiansPerSecondSquared;
+            return CompiledLambdas.Divide(left.RadiansPerSecondSquared, right.RadiansPerSecondSquared);
         }
 
         #endregion
@@ -461,39 +460,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(RotationalAcceleration left, RotationalAcceleration right)
+        public static bool operator <=(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(RotationalAcceleration left, RotationalAcceleration right)
+        public static bool operator >=(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(RotationalAcceleration left, RotationalAcceleration right)
+        public static bool operator <(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(RotationalAcceleration left, RotationalAcceleration right)
+        public static bool operator >(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(RotationalAcceleration left, RotationalAcceleration right)
+        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(RotationalAcceleration left, RotationalAcceleration right)
+        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(RotationalAcceleration<T> left, RotationalAcceleration<T> right)
         {
             return !(left == right);
         }
@@ -502,37 +501,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is RotationalAcceleration objRotationalAcceleration)) throw new ArgumentException("Expected type RotationalAcceleration.", nameof(obj));
+            if(!(obj is RotationalAcceleration<T> objRotationalAcceleration)) throw new ArgumentException("Expected type RotationalAcceleration.", nameof(obj));
 
             return CompareTo(objRotationalAcceleration);
         }
 
         /// <inheritdoc />
-        public int CompareTo(RotationalAcceleration other)
+        public int CompareTo(RotationalAcceleration<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is RotationalAcceleration objRotationalAcceleration))
+            if(obj is null || !(obj is RotationalAcceleration<T> objRotationalAcceleration))
                 return false;
 
             return Equals(objRotationalAcceleration);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(RotationalAcceleration other)
+        /// <remarks>Consider using <see cref="Equals(RotationalAcceleration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(RotationalAcceleration<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another RotationalAcceleration within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="RotationalAcceleration{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -570,21 +569,19 @@ public bool Equals(RotationalAcceleration other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(RotationalAcceleration other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(RotationalAcceleration<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current RotationalAcceleration.</returns>
+        /// <returns>A hash code for the current <see cref="RotationalAcceleration{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -598,17 +595,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalAccelerationUnit unit)
+        public T As(RotationalAccelerationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -628,17 +625,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is RotationalAccelerationUnit unitAsRotationalAccelerationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalAccelerationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsRotationalAccelerationUnit);
+            var asValue = As(unitAsRotationalAccelerationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<RotationalAccelerationUnit>.As(RotationalAccelerationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this RotationalAcceleration to another RotationalAcceleration with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="RotationalAcceleration{T}" /> to another <see cref="RotationalAcceleration{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A RotationalAcceleration with the specified unit.</returns>
-        public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit)
+        /// <returns>A <see cref="RotationalAcceleration{T}" /> with the specified unit.</returns>
+        public RotationalAcceleration<T> ToUnit(RotationalAccelerationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new RotationalAcceleration(convertedValue, unit);
+            return new RotationalAcceleration<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -651,7 +653,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public RotationalAcceleration ToUnit(UnitSystem unitSystem)
+        public RotationalAcceleration<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -671,22 +673,28 @@ public RotationalAcceleration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalAccelerationUnit> IQuantity<RotationalAccelerationUnit>.ToUnit(RotationalAccelerationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalAccelerationUnit, T> IQuantityT<RotationalAccelerationUnit, T>.ToUnit(RotationalAccelerationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<RotationalAccelerationUnit> IQuantity<RotationalAccelerationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalAccelerationUnit, T> IQuantityT<RotationalAccelerationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case RotationalAccelerationUnit.DegreePerSecondSquared: return (Math.PI/180)*_value;
-                case RotationalAccelerationUnit.RadianPerSecondSquared: return _value;
-                case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: return ((2*Math.PI)/60)*_value;
-                case RotationalAccelerationUnit.RevolutionPerSecondSquared: return (2*Math.PI)*_value;
+                case RotationalAccelerationUnit.DegreePerSecondSquared: return (Math.PI/180)*Value;
+                case RotationalAccelerationUnit.RadianPerSecondSquared: return Value;
+                case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: return ((2*Math.PI)/60)*Value;
+                case RotationalAccelerationUnit.RevolutionPerSecondSquared: return (2*Math.PI)*Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -697,16 +705,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal RotationalAcceleration ToBaseUnit()
+        internal RotationalAcceleration<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new RotationalAcceleration(baseUnitValue, BaseUnit);
+            return new RotationalAcceleration<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(RotationalAccelerationUnit unit)
+        private T GetValueAs(RotationalAccelerationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -812,57 +820,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalAcceleration)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalAcceleration<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalAcceleration)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalAcceleration<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalAcceleration)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalAcceleration<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -872,33 +880,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(RotationalAcceleration))
+            if(conversionType == typeof(RotationalAcceleration<T>))
                 return this;
             else if(conversionType == typeof(RotationalAccelerationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return RotationalAcceleration.QuantityType;
+                return RotationalAcceleration<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return RotationalAcceleration.Info;
+                return RotationalAcceleration<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return RotationalAcceleration.BaseDimensions;
+                return RotationalAcceleration<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(RotationalAcceleration)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(RotationalAcceleration<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
index b0c98ccbbd..86649765de 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Rotational speed (sometimes called speed of revolution) is the number of complete rotations, revolutions, cycles, or turns per time unit. Rotational speed is a cyclic frequency, measured in radians per second or in hertz in the SI System by scientists, or in revolutions per minute (rpm or min-1) or revolutions per second in everyday life. The symbol for rotational speed is ω (the Greek lowercase letter "omega").
     /// </summary>
-    public partial struct RotationalSpeed : IQuantity<RotationalSpeedUnit>, IEquatable<RotationalSpeed>, IComparable, IComparable<RotationalSpeed>, IConvertible, IFormattable
+    public partial struct RotationalSpeed<T> : IQuantityT<RotationalSpeedUnit, T>, IEquatable<RotationalSpeed<T>>, IComparable, IComparable<RotationalSpeed<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -75,12 +71,12 @@ static RotationalSpeed()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public RotationalSpeed(double value, RotationalSpeedUnit unit)
+        public RotationalSpeed(T value, RotationalSpeedUnit unit)
         {
             if(unit == RotationalSpeedUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -92,14 +88,14 @@ public RotationalSpeed(double value, RotationalSpeedUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalSpeed(double value, UnitSystem unitSystem)
+        public RotationalSpeed(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -114,19 +110,19 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of RotationalSpeed, which is RadianPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="RotationalSpeed{T}" />, which is RadianPerSecond. All conversions go via this value.
         /// </summary>
         public static RotationalSpeedUnit BaseUnit { get; } = RotationalSpeedUnit.RadianPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of RotationalSpeed
+        /// Represents the largest possible value of <see cref="RotationalSpeed{T}" />
         /// </summary>
-        public static RotationalSpeed MaxValue { get; } = new RotationalSpeed(double.MaxValue, BaseUnit);
+        public static RotationalSpeed<T> MaxValue { get; } = new RotationalSpeed<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of RotationalSpeed
+        /// Represents the smallest possible value of <see cref="RotationalSpeed{T}" />
         /// </summary>
-        public static RotationalSpeed MinValue { get; } = new RotationalSpeed(double.MinValue, BaseUnit);
+        public static RotationalSpeed<T> MinValue { get; } = new RotationalSpeed<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -135,14 +131,14 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.RotationalSpeed;
 
         /// <summary>
-        ///     All units of measurement for the RotationalSpeed quantity.
+        ///     All units of measurement for the <see cref="RotationalSpeed{T}" /> quantity.
         /// </summary>
         public static RotationalSpeedUnit[] Units { get; } = Enum.GetValues(typeof(RotationalSpeedUnit)).Cast<RotationalSpeedUnit>().Except(new RotationalSpeedUnit[]{ RotationalSpeedUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit RadianPerSecond.
         /// </summary>
-        public static RotationalSpeed Zero { get; } = new RotationalSpeed(0, BaseUnit);
+        public static RotationalSpeed<T> Zero { get; } = new RotationalSpeed<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -151,7 +147,9 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -167,81 +165,81 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => RotationalSpeed.QuantityType;
+        public QuantityType Type => RotationalSpeed<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => RotationalSpeed.BaseDimensions;
+        public BaseDimensions Dimensions => RotationalSpeed<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get RotationalSpeed in CentiradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in CentiradiansPerSecond.
         /// </summary>
-        public double CentiradiansPerSecond => As(RotationalSpeedUnit.CentiradianPerSecond);
+        public T CentiradiansPerSecond => As(RotationalSpeedUnit.CentiradianPerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in DeciradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in DeciradiansPerSecond.
         /// </summary>
-        public double DeciradiansPerSecond => As(RotationalSpeedUnit.DeciradianPerSecond);
+        public T DeciradiansPerSecond => As(RotationalSpeedUnit.DeciradianPerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in DegreesPerMinute.
+        ///     Get <see cref="RotationalSpeed{T}" /> in DegreesPerMinute.
         /// </summary>
-        public double DegreesPerMinute => As(RotationalSpeedUnit.DegreePerMinute);
+        public T DegreesPerMinute => As(RotationalSpeedUnit.DegreePerMinute);
 
         /// <summary>
-        ///     Get RotationalSpeed in DegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in DegreesPerSecond.
         /// </summary>
-        public double DegreesPerSecond => As(RotationalSpeedUnit.DegreePerSecond);
+        public T DegreesPerSecond => As(RotationalSpeedUnit.DegreePerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in MicrodegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in MicrodegreesPerSecond.
         /// </summary>
-        public double MicrodegreesPerSecond => As(RotationalSpeedUnit.MicrodegreePerSecond);
+        public T MicrodegreesPerSecond => As(RotationalSpeedUnit.MicrodegreePerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in MicroradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in MicroradiansPerSecond.
         /// </summary>
-        public double MicroradiansPerSecond => As(RotationalSpeedUnit.MicroradianPerSecond);
+        public T MicroradiansPerSecond => As(RotationalSpeedUnit.MicroradianPerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in MillidegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in MillidegreesPerSecond.
         /// </summary>
-        public double MillidegreesPerSecond => As(RotationalSpeedUnit.MillidegreePerSecond);
+        public T MillidegreesPerSecond => As(RotationalSpeedUnit.MillidegreePerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in MilliradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in MilliradiansPerSecond.
         /// </summary>
-        public double MilliradiansPerSecond => As(RotationalSpeedUnit.MilliradianPerSecond);
+        public T MilliradiansPerSecond => As(RotationalSpeedUnit.MilliradianPerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in NanodegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in NanodegreesPerSecond.
         /// </summary>
-        public double NanodegreesPerSecond => As(RotationalSpeedUnit.NanodegreePerSecond);
+        public T NanodegreesPerSecond => As(RotationalSpeedUnit.NanodegreePerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in NanoradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in NanoradiansPerSecond.
         /// </summary>
-        public double NanoradiansPerSecond => As(RotationalSpeedUnit.NanoradianPerSecond);
+        public T NanoradiansPerSecond => As(RotationalSpeedUnit.NanoradianPerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in RadiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in RadiansPerSecond.
         /// </summary>
-        public double RadiansPerSecond => As(RotationalSpeedUnit.RadianPerSecond);
+        public T RadiansPerSecond => As(RotationalSpeedUnit.RadianPerSecond);
 
         /// <summary>
-        ///     Get RotationalSpeed in RevolutionsPerMinute.
+        ///     Get <see cref="RotationalSpeed{T}" /> in RevolutionsPerMinute.
         /// </summary>
-        public double RevolutionsPerMinute => As(RotationalSpeedUnit.RevolutionPerMinute);
+        public T RevolutionsPerMinute => As(RotationalSpeedUnit.RevolutionPerMinute);
 
         /// <summary>
-        ///     Get RotationalSpeed in RevolutionsPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> in RevolutionsPerSecond.
         /// </summary>
-        public double RevolutionsPerSecond => As(RotationalSpeedUnit.RevolutionPerSecond);
+        public T RevolutionsPerSecond => As(RotationalSpeedUnit.RevolutionPerSecond);
 
         #endregion
 
@@ -273,132 +271,119 @@ public static string GetAbbreviation(RotationalSpeedUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get RotationalSpeed from CentiradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from CentiradiansPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromCentiradiansPerSecond(QuantityValue centiradianspersecond)
+        public static RotationalSpeed<T> FromCentiradiansPerSecond(T centiradianspersecond)
         {
-            double value = (double) centiradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond);
+            return new RotationalSpeed<T>(centiradianspersecond, RotationalSpeedUnit.CentiradianPerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from DeciradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from DeciradiansPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDeciradiansPerSecond(QuantityValue deciradianspersecond)
+        public static RotationalSpeed<T> FromDeciradiansPerSecond(T deciradianspersecond)
         {
-            double value = (double) deciradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond);
+            return new RotationalSpeed<T>(deciradianspersecond, RotationalSpeedUnit.DeciradianPerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from DegreesPerMinute.
+        ///     Get <see cref="RotationalSpeed{T}" /> from DegreesPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDegreesPerMinute(QuantityValue degreesperminute)
+        public static RotationalSpeed<T> FromDegreesPerMinute(T degreesperminute)
         {
-            double value = (double) degreesperminute;
-            return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute);
+            return new RotationalSpeed<T>(degreesperminute, RotationalSpeedUnit.DegreePerMinute);
         }
         /// <summary>
-        ///     Get RotationalSpeed from DegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from DegreesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDegreesPerSecond(QuantityValue degreespersecond)
+        public static RotationalSpeed<T> FromDegreesPerSecond(T degreespersecond)
         {
-            double value = (double) degreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond);
+            return new RotationalSpeed<T>(degreespersecond, RotationalSpeedUnit.DegreePerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from MicrodegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from MicrodegreesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMicrodegreesPerSecond(QuantityValue microdegreespersecond)
+        public static RotationalSpeed<T> FromMicrodegreesPerSecond(T microdegreespersecond)
         {
-            double value = (double) microdegreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond);
+            return new RotationalSpeed<T>(microdegreespersecond, RotationalSpeedUnit.MicrodegreePerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from MicroradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from MicroradiansPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMicroradiansPerSecond(QuantityValue microradianspersecond)
+        public static RotationalSpeed<T> FromMicroradiansPerSecond(T microradianspersecond)
         {
-            double value = (double) microradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond);
+            return new RotationalSpeed<T>(microradianspersecond, RotationalSpeedUnit.MicroradianPerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from MillidegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from MillidegreesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMillidegreesPerSecond(QuantityValue millidegreespersecond)
+        public static RotationalSpeed<T> FromMillidegreesPerSecond(T millidegreespersecond)
         {
-            double value = (double) millidegreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond);
+            return new RotationalSpeed<T>(millidegreespersecond, RotationalSpeedUnit.MillidegreePerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from MilliradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from MilliradiansPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMilliradiansPerSecond(QuantityValue milliradianspersecond)
+        public static RotationalSpeed<T> FromMilliradiansPerSecond(T milliradianspersecond)
         {
-            double value = (double) milliradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond);
+            return new RotationalSpeed<T>(milliradianspersecond, RotationalSpeedUnit.MilliradianPerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from NanodegreesPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from NanodegreesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromNanodegreesPerSecond(QuantityValue nanodegreespersecond)
+        public static RotationalSpeed<T> FromNanodegreesPerSecond(T nanodegreespersecond)
         {
-            double value = (double) nanodegreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond);
+            return new RotationalSpeed<T>(nanodegreespersecond, RotationalSpeedUnit.NanodegreePerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from NanoradiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from NanoradiansPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromNanoradiansPerSecond(QuantityValue nanoradianspersecond)
+        public static RotationalSpeed<T> FromNanoradiansPerSecond(T nanoradianspersecond)
         {
-            double value = (double) nanoradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond);
+            return new RotationalSpeed<T>(nanoradianspersecond, RotationalSpeedUnit.NanoradianPerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from RadiansPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from RadiansPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRadiansPerSecond(QuantityValue radianspersecond)
+        public static RotationalSpeed<T> FromRadiansPerSecond(T radianspersecond)
         {
-            double value = (double) radianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond);
+            return new RotationalSpeed<T>(radianspersecond, RotationalSpeedUnit.RadianPerSecond);
         }
         /// <summary>
-        ///     Get RotationalSpeed from RevolutionsPerMinute.
+        ///     Get <see cref="RotationalSpeed{T}" /> from RevolutionsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRevolutionsPerMinute(QuantityValue revolutionsperminute)
+        public static RotationalSpeed<T> FromRevolutionsPerMinute(T revolutionsperminute)
         {
-            double value = (double) revolutionsperminute;
-            return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute);
+            return new RotationalSpeed<T>(revolutionsperminute, RotationalSpeedUnit.RevolutionPerMinute);
         }
         /// <summary>
-        ///     Get RotationalSpeed from RevolutionsPerSecond.
+        ///     Get <see cref="RotationalSpeed{T}" /> from RevolutionsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRevolutionsPerSecond(QuantityValue revolutionspersecond)
+        public static RotationalSpeed<T> FromRevolutionsPerSecond(T revolutionspersecond)
         {
-            double value = (double) revolutionspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond);
+            return new RotationalSpeed<T>(revolutionspersecond, RotationalSpeedUnit.RevolutionPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalSpeedUnit" /> to <see cref="RotationalSpeed" />.
+        ///     Dynamically convert from value and unit enum <see cref="RotationalSpeedUnit" /> to <see cref="RotationalSpeed{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalSpeed unit value.</returns>
-        public static RotationalSpeed From(QuantityValue value, RotationalSpeedUnit fromUnit)
+        /// <returns><see cref="RotationalSpeed{T}" /> unit value.</returns>
+        public static RotationalSpeed<T> From(T value, RotationalSpeedUnit fromUnit)
         {
-            return new RotationalSpeed((double)value, fromUnit);
+            return new RotationalSpeed<T>(value, fromUnit);
         }
 
         #endregion
@@ -427,7 +412,7 @@ public static RotationalSpeed From(QuantityValue value, RotationalSpeedUnit from
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static RotationalSpeed Parse(string str)
+        public static RotationalSpeed<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -455,9 +440,9 @@ public static RotationalSpeed Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static RotationalSpeed Parse(string str, IFormatProvider? provider)
+        public static RotationalSpeed<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<RotationalSpeed, RotationalSpeedUnit>(
+            return QuantityParser.Default.Parse<T, RotationalSpeed<T>, RotationalSpeedUnit>(
                 str,
                 provider,
                 From);
@@ -471,7 +456,7 @@ public static RotationalSpeed Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out RotationalSpeed result)
+        public static bool TryParse(string? str, out RotationalSpeed<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -486,9 +471,9 @@ public static bool TryParse(string? str, out RotationalSpeed result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalSpeed result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalSpeed<T> result)
         {
-            return QuantityParser.Default.TryParse<RotationalSpeed, RotationalSpeedUnit>(
+            return QuantityParser.Default.TryParse<T, RotationalSpeed<T>, RotationalSpeedUnit>(
                 str,
                 provider,
                 From,
@@ -550,45 +535,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static RotationalSpeed operator -(RotationalSpeed right)
+        public static RotationalSpeed<T> operator -(RotationalSpeed<T> right)
         {
-            return new RotationalSpeed(-right.Value, right.Unit);
+            return new RotationalSpeed<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalSpeed"/> from adding two <see cref="RotationalSpeed"/>.</summary>
-        public static RotationalSpeed operator +(RotationalSpeed left, RotationalSpeed right)
+        /// <summary>Get <see cref="RotationalSpeed{T}"/> from adding two <see cref="RotationalSpeed{T}"/>.</summary>
+        public static RotationalSpeed<T> operator +(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
-            return new RotationalSpeed(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalSpeed<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalSpeed"/> from subtracting two <see cref="RotationalSpeed"/>.</summary>
-        public static RotationalSpeed operator -(RotationalSpeed left, RotationalSpeed right)
+        /// <summary>Get <see cref="RotationalSpeed{T}"/> from subtracting two <see cref="RotationalSpeed{T}"/>.</summary>
+        public static RotationalSpeed<T> operator -(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
-            return new RotationalSpeed(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalSpeed<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalSpeed"/> from multiplying value and <see cref="RotationalSpeed"/>.</summary>
-        public static RotationalSpeed operator *(double left, RotationalSpeed right)
+        /// <summary>Get <see cref="RotationalSpeed{T}"/> from multiplying value and <see cref="RotationalSpeed{T}"/>.</summary>
+        public static RotationalSpeed<T> operator *(T left, RotationalSpeed<T> right)
         {
-            return new RotationalSpeed(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new RotationalSpeed<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalSpeed"/> from multiplying value and <see cref="RotationalSpeed"/>.</summary>
-        public static RotationalSpeed operator *(RotationalSpeed left, double right)
+        /// <summary>Get <see cref="RotationalSpeed{T}"/> from multiplying value and <see cref="RotationalSpeed{T}"/>.</summary>
+        public static RotationalSpeed<T> operator *(RotationalSpeed<T> left, T right)
         {
-            return new RotationalSpeed(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new RotationalSpeed<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalSpeed"/> from dividing <see cref="RotationalSpeed"/> by value.</summary>
-        public static RotationalSpeed operator /(RotationalSpeed left, double right)
+        /// <summary>Get <see cref="RotationalSpeed{T}"/> from dividing <see cref="RotationalSpeed{T}"/> by value.</summary>
+        public static RotationalSpeed<T> operator /(RotationalSpeed<T> left, T right)
         {
-            return new RotationalSpeed(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new RotationalSpeed<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="RotationalSpeed"/> by <see cref="RotationalSpeed"/>.</summary>
-        public static double operator /(RotationalSpeed left, RotationalSpeed right)
+        /// <summary>Get ratio value from dividing <see cref="RotationalSpeed{T}"/> by <see cref="RotationalSpeed{T}"/>.</summary>
+        public static T operator /(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
-            return left.RadiansPerSecond / right.RadiansPerSecond;
+            return CompiledLambdas.Divide(left.RadiansPerSecond, right.RadiansPerSecond);
         }
 
         #endregion
@@ -596,39 +586,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(RotationalSpeed left, RotationalSpeed right)
+        public static bool operator <=(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(RotationalSpeed left, RotationalSpeed right)
+        public static bool operator >=(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(RotationalSpeed left, RotationalSpeed right)
+        public static bool operator <(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(RotationalSpeed left, RotationalSpeed right)
+        public static bool operator >(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalSpeed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(RotationalSpeed left, RotationalSpeed right)
+        /// <remarks>Consider using <see cref="Equals(RotationalSpeed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalSpeed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(RotationalSpeed left, RotationalSpeed right)
+        /// <remarks>Consider using <see cref="Equals(RotationalSpeed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(RotationalSpeed<T> left, RotationalSpeed<T> right)
         {
             return !(left == right);
         }
@@ -637,37 +627,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is RotationalSpeed objRotationalSpeed)) throw new ArgumentException("Expected type RotationalSpeed.", nameof(obj));
+            if(!(obj is RotationalSpeed<T> objRotationalSpeed)) throw new ArgumentException("Expected type RotationalSpeed.", nameof(obj));
 
             return CompareTo(objRotationalSpeed);
         }
 
         /// <inheritdoc />
-        public int CompareTo(RotationalSpeed other)
+        public int CompareTo(RotationalSpeed<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalSpeed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(RotationalSpeed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is RotationalSpeed objRotationalSpeed))
+            if(obj is null || !(obj is RotationalSpeed<T> objRotationalSpeed))
                 return false;
 
             return Equals(objRotationalSpeed);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalSpeed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(RotationalSpeed other)
+        /// <remarks>Consider using <see cref="Equals(RotationalSpeed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(RotationalSpeed<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another RotationalSpeed within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="RotationalSpeed{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -705,21 +695,19 @@ public bool Equals(RotationalSpeed other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(RotationalSpeed other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(RotationalSpeed<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current RotationalSpeed.</returns>
+        /// <returns>A hash code for the current <see cref="RotationalSpeed{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -733,17 +721,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalSpeedUnit unit)
+        public T As(RotationalSpeedUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -763,17 +751,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is RotationalSpeedUnit unitAsRotationalSpeedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalSpeedUnit)} is supported.", nameof(unit));
 
-            return As(unitAsRotationalSpeedUnit);
+            var asValue = As(unitAsRotationalSpeedUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<RotationalSpeedUnit>.As(RotationalSpeedUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this RotationalSpeed to another RotationalSpeed with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="RotationalSpeed{T}" /> to another <see cref="RotationalSpeed{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A RotationalSpeed with the specified unit.</returns>
-        public RotationalSpeed ToUnit(RotationalSpeedUnit unit)
+        /// <returns>A <see cref="RotationalSpeed{T}" /> with the specified unit.</returns>
+        public RotationalSpeed<T> ToUnit(RotationalSpeedUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new RotationalSpeed(convertedValue, unit);
+            return new RotationalSpeed<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -786,7 +779,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public RotationalSpeed ToUnit(UnitSystem unitSystem)
+        public RotationalSpeed<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -806,31 +799,37 @@ public RotationalSpeed ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalSpeedUnit> IQuantity<RotationalSpeedUnit>.ToUnit(RotationalSpeedUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalSpeedUnit, T> IQuantityT<RotationalSpeedUnit, T>.ToUnit(RotationalSpeedUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<RotationalSpeedUnit> IQuantity<RotationalSpeedUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalSpeedUnit, T> IQuantityT<RotationalSpeedUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case RotationalSpeedUnit.CentiradianPerSecond: return (_value) * 1e-2d;
-                case RotationalSpeedUnit.DeciradianPerSecond: return (_value) * 1e-1d;
-                case RotationalSpeedUnit.DegreePerMinute: return (Math.PI/(180*60))*_value;
-                case RotationalSpeedUnit.DegreePerSecond: return (Math.PI/180)*_value;
-                case RotationalSpeedUnit.MicrodegreePerSecond: return ((Math.PI/180)*_value) * 1e-6d;
-                case RotationalSpeedUnit.MicroradianPerSecond: return (_value) * 1e-6d;
-                case RotationalSpeedUnit.MillidegreePerSecond: return ((Math.PI/180)*_value) * 1e-3d;
-                case RotationalSpeedUnit.MilliradianPerSecond: return (_value) * 1e-3d;
-                case RotationalSpeedUnit.NanodegreePerSecond: return ((Math.PI/180)*_value) * 1e-9d;
-                case RotationalSpeedUnit.NanoradianPerSecond: return (_value) * 1e-9d;
-                case RotationalSpeedUnit.RadianPerSecond: return _value;
-                case RotationalSpeedUnit.RevolutionPerMinute: return (_value*6.2831853072)/60;
-                case RotationalSpeedUnit.RevolutionPerSecond: return _value*6.2831853072;
+                case RotationalSpeedUnit.CentiradianPerSecond: return (Value) * 1e-2d;
+                case RotationalSpeedUnit.DeciradianPerSecond: return (Value) * 1e-1d;
+                case RotationalSpeedUnit.DegreePerMinute: return (Math.PI/(180*60))*Value;
+                case RotationalSpeedUnit.DegreePerSecond: return (Math.PI/180)*Value;
+                case RotationalSpeedUnit.MicrodegreePerSecond: return ((Math.PI/180)*Value) * 1e-6d;
+                case RotationalSpeedUnit.MicroradianPerSecond: return (Value) * 1e-6d;
+                case RotationalSpeedUnit.MillidegreePerSecond: return ((Math.PI/180)*Value) * 1e-3d;
+                case RotationalSpeedUnit.MilliradianPerSecond: return (Value) * 1e-3d;
+                case RotationalSpeedUnit.NanodegreePerSecond: return ((Math.PI/180)*Value) * 1e-9d;
+                case RotationalSpeedUnit.NanoradianPerSecond: return (Value) * 1e-9d;
+                case RotationalSpeedUnit.RadianPerSecond: return Value;
+                case RotationalSpeedUnit.RevolutionPerMinute: return (Value*6.2831853072)/60;
+                case RotationalSpeedUnit.RevolutionPerSecond: return Value*6.2831853072;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -841,16 +840,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal RotationalSpeed ToBaseUnit()
+        internal RotationalSpeed<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new RotationalSpeed(baseUnitValue, BaseUnit);
+            return new RotationalSpeed<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(RotationalSpeedUnit unit)
+        private T GetValueAs(RotationalSpeedUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -965,57 +964,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalSpeed)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalSpeed<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalSpeed)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalSpeed<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalSpeed)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalSpeed<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1025,33 +1024,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(RotationalSpeed))
+            if(conversionType == typeof(RotationalSpeed<T>))
                 return this;
             else if(conversionType == typeof(RotationalSpeedUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return RotationalSpeed.QuantityType;
+                return RotationalSpeed<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return RotationalSpeed.Info;
+                return RotationalSpeed<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return RotationalSpeed.BaseDimensions;
+                return RotationalSpeed<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(RotationalSpeed)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(RotationalSpeed<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
index d8facb68b2..6e7f8fd5f7 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     https://en.wikipedia.org/wiki/Stiffness#Rotational_stiffness
     /// </summary>
-    public partial struct RotationalStiffness : IQuantity<RotationalStiffnessUnit>, IEquatable<RotationalStiffness>, IComparable, IComparable<RotationalStiffness>, IConvertible, IFormattable
+    public partial struct RotationalStiffness<T> : IQuantityT<RotationalStiffnessUnit, T>, IEquatable<RotationalStiffness<T>>, IComparable, IComparable<RotationalStiffness<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -95,12 +91,12 @@ static RotationalStiffness()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public RotationalStiffness(double value, RotationalStiffnessUnit unit)
+        public RotationalStiffness(T value, RotationalStiffnessUnit unit)
         {
             if(unit == RotationalStiffnessUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -112,14 +108,14 @@ public RotationalStiffness(double value, RotationalStiffnessUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalStiffness(double value, UnitSystem unitSystem)
+        public RotationalStiffness(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -134,19 +130,19 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of RotationalStiffness, which is NewtonMeterPerRadian. All conversions go via this value.
+        ///     The base unit of <see cref="RotationalStiffness{T}" />, which is NewtonMeterPerRadian. All conversions go via this value.
         /// </summary>
         public static RotationalStiffnessUnit BaseUnit { get; } = RotationalStiffnessUnit.NewtonMeterPerRadian;
 
         /// <summary>
-        /// Represents the largest possible value of RotationalStiffness
+        /// Represents the largest possible value of <see cref="RotationalStiffness{T}" />
         /// </summary>
-        public static RotationalStiffness MaxValue { get; } = new RotationalStiffness(double.MaxValue, BaseUnit);
+        public static RotationalStiffness<T> MaxValue { get; } = new RotationalStiffness<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of RotationalStiffness
+        /// Represents the smallest possible value of <see cref="RotationalStiffness{T}" />
         /// </summary>
-        public static RotationalStiffness MinValue { get; } = new RotationalStiffness(double.MinValue, BaseUnit);
+        public static RotationalStiffness<T> MinValue { get; } = new RotationalStiffness<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -155,14 +151,14 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.RotationalStiffness;
 
         /// <summary>
-        ///     All units of measurement for the RotationalStiffness quantity.
+        ///     All units of measurement for the <see cref="RotationalStiffness{T}" /> quantity.
         /// </summary>
         public static RotationalStiffnessUnit[] Units { get; } = Enum.GetValues(typeof(RotationalStiffnessUnit)).Cast<RotationalStiffnessUnit>().Except(new RotationalStiffnessUnit[]{ RotationalStiffnessUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonMeterPerRadian.
         /// </summary>
-        public static RotationalStiffness Zero { get; } = new RotationalStiffness(0, BaseUnit);
+        public static RotationalStiffness<T> Zero { get; } = new RotationalStiffness<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -171,7 +167,9 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -187,181 +185,181 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => RotationalStiffness.QuantityType;
+        public QuantityType Type => RotationalStiffness<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => RotationalStiffness.BaseDimensions;
+        public BaseDimensions Dimensions => RotationalStiffness<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get RotationalStiffness in CentinewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in CentinewtonMetersPerDegree.
         /// </summary>
-        public double CentinewtonMetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMeterPerDegree);
+        public T CentinewtonMetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in CentinewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in CentinewtonMillimetersPerDegree.
         /// </summary>
-        public double CentinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
+        public T CentinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in CentinewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in CentinewtonMillimetersPerRadian.
         /// </summary>
-        public double CentinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
+        public T CentinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in DecanewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in DecanewtonMetersPerDegree.
         /// </summary>
-        public double DecanewtonMetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMeterPerDegree);
+        public T DecanewtonMetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in DecanewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in DecanewtonMillimetersPerDegree.
         /// </summary>
-        public double DecanewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
+        public T DecanewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in DecanewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in DecanewtonMillimetersPerRadian.
         /// </summary>
-        public double DecanewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
+        public T DecanewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in DecinewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in DecinewtonMetersPerDegree.
         /// </summary>
-        public double DecinewtonMetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMeterPerDegree);
+        public T DecinewtonMetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in DecinewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in DecinewtonMillimetersPerDegree.
         /// </summary>
-        public double DecinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
+        public T DecinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in DecinewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in DecinewtonMillimetersPerRadian.
         /// </summary>
-        public double DecinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
+        public T DecinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in KilonewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in KilonewtonMetersPerDegree.
         /// </summary>
-        public double KilonewtonMetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMeterPerDegree);
+        public T KilonewtonMetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in KilonewtonMetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in KilonewtonMetersPerRadian.
         /// </summary>
-        public double KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
+        public T KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in KilonewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in KilonewtonMillimetersPerDegree.
         /// </summary>
-        public double KilonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
+        public T KilonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in KilonewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in KilonewtonMillimetersPerRadian.
         /// </summary>
-        public double KilonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
+        public T KilonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in KilopoundForceFeetPerDegrees.
+        ///     Get <see cref="RotationalStiffness{T}" /> in KilopoundForceFeetPerDegrees.
         /// </summary>
-        public double KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+        public T KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
 
         /// <summary>
-        ///     Get RotationalStiffness in MeganewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MeganewtonMetersPerDegree.
         /// </summary>
-        public double MeganewtonMetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMeterPerDegree);
+        public T MeganewtonMetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in MeganewtonMetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MeganewtonMetersPerRadian.
         /// </summary>
-        public double MeganewtonMetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+        public T MeganewtonMetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in MeganewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MeganewtonMillimetersPerDegree.
         /// </summary>
-        public double MeganewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
+        public T MeganewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in MeganewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MeganewtonMillimetersPerRadian.
         /// </summary>
-        public double MeganewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
+        public T MeganewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in MicronewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MicronewtonMetersPerDegree.
         /// </summary>
-        public double MicronewtonMetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMeterPerDegree);
+        public T MicronewtonMetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in MicronewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MicronewtonMillimetersPerDegree.
         /// </summary>
-        public double MicronewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
+        public T MicronewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in MicronewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MicronewtonMillimetersPerRadian.
         /// </summary>
-        public double MicronewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
+        public T MicronewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in MillinewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MillinewtonMetersPerDegree.
         /// </summary>
-        public double MillinewtonMetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMeterPerDegree);
+        public T MillinewtonMetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in MillinewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MillinewtonMillimetersPerDegree.
         /// </summary>
-        public double MillinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
+        public T MillinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in MillinewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in MillinewtonMillimetersPerRadian.
         /// </summary>
-        public double MillinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
+        public T MillinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in NanonewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in NanonewtonMetersPerDegree.
         /// </summary>
-        public double NanonewtonMetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMeterPerDegree);
+        public T NanonewtonMetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in NanonewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in NanonewtonMillimetersPerDegree.
         /// </summary>
-        public double NanonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
+        public T NanonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in NanonewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in NanonewtonMillimetersPerRadian.
         /// </summary>
-        public double NanonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
+        public T NanonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in NewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in NewtonMetersPerDegree.
         /// </summary>
-        public double NewtonMetersPerDegree => As(RotationalStiffnessUnit.NewtonMeterPerDegree);
+        public T NewtonMetersPerDegree => As(RotationalStiffnessUnit.NewtonMeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in NewtonMetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in NewtonMetersPerRadian.
         /// </summary>
-        public double NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian);
+        public T NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in NewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> in NewtonMillimetersPerDegree.
         /// </summary>
-        public double NewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NewtonMillimeterPerDegree);
+        public T NewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Get RotationalStiffness in NewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in NewtonMillimetersPerRadian.
         /// </summary>
-        public double NewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NewtonMillimeterPerRadian);
+        public T NewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in PoundForceFeetPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> in PoundForceFeetPerRadian.
         /// </summary>
-        public double PoundForceFeetPerRadian => As(RotationalStiffnessUnit.PoundForceFeetPerRadian);
+        public T PoundForceFeetPerRadian => As(RotationalStiffnessUnit.PoundForceFeetPerRadian);
 
         /// <summary>
-        ///     Get RotationalStiffness in PoundForceFeetPerDegrees.
+        ///     Get <see cref="RotationalStiffness{T}" /> in PoundForceFeetPerDegrees.
         /// </summary>
-        public double PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees);
+        public T PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees);
 
         #endregion
 
@@ -393,312 +391,279 @@ public static string GetAbbreviation(RotationalStiffnessUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get RotationalStiffness from CentinewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from CentinewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMetersPerDegree(QuantityValue centinewtonmetersperdegree)
+        public static RotationalStiffness<T> FromCentinewtonMetersPerDegree(T centinewtonmetersperdegree)
         {
-            double value = (double) centinewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
+            return new RotationalStiffness<T>(centinewtonmetersperdegree, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from CentinewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from CentinewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(QuantityValue centinewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromCentinewtonMillimetersPerDegree(T centinewtonmillimetersperdegree)
         {
-            double value = (double) centinewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(centinewtonmillimetersperdegree, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from CentinewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from CentinewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(QuantityValue centinewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromCentinewtonMillimetersPerRadian(T centinewtonmillimetersperradian)
         {
-            double value = (double) centinewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(centinewtonmillimetersperradian, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from DecanewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from DecanewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMetersPerDegree(QuantityValue decanewtonmetersperdegree)
+        public static RotationalStiffness<T> FromDecanewtonMetersPerDegree(T decanewtonmetersperdegree)
         {
-            double value = (double) decanewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
+            return new RotationalStiffness<T>(decanewtonmetersperdegree, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from DecanewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from DecanewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(QuantityValue decanewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromDecanewtonMillimetersPerDegree(T decanewtonmillimetersperdegree)
         {
-            double value = (double) decanewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(decanewtonmillimetersperdegree, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from DecanewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from DecanewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(QuantityValue decanewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromDecanewtonMillimetersPerRadian(T decanewtonmillimetersperradian)
         {
-            double value = (double) decanewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(decanewtonmillimetersperradian, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from DecinewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from DecinewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMetersPerDegree(QuantityValue decinewtonmetersperdegree)
+        public static RotationalStiffness<T> FromDecinewtonMetersPerDegree(T decinewtonmetersperdegree)
         {
-            double value = (double) decinewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
+            return new RotationalStiffness<T>(decinewtonmetersperdegree, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from DecinewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from DecinewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(QuantityValue decinewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromDecinewtonMillimetersPerDegree(T decinewtonmillimetersperdegree)
         {
-            double value = (double) decinewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(decinewtonmillimetersperdegree, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from DecinewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from DecinewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(QuantityValue decinewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromDecinewtonMillimetersPerRadian(T decinewtonmillimetersperradian)
         {
-            double value = (double) decinewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(decinewtonmillimetersperradian, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from KilonewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from KilonewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMetersPerDegree(QuantityValue kilonewtonmetersperdegree)
+        public static RotationalStiffness<T> FromKilonewtonMetersPerDegree(T kilonewtonmetersperdegree)
         {
-            double value = (double) kilonewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
+            return new RotationalStiffness<T>(kilonewtonmetersperdegree, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from KilonewtonMetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from KilonewtonMetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMetersPerRadian(QuantityValue kilonewtonmetersperradian)
+        public static RotationalStiffness<T> FromKilonewtonMetersPerRadian(T kilonewtonmetersperradian)
         {
-            double value = (double) kilonewtonmetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
+            return new RotationalStiffness<T>(kilonewtonmetersperradian, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from KilonewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from KilonewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(QuantityValue kilonewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromKilonewtonMillimetersPerDegree(T kilonewtonmillimetersperdegree)
         {
-            double value = (double) kilonewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(kilonewtonmillimetersperdegree, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from KilonewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from KilonewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(QuantityValue kilonewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromKilonewtonMillimetersPerRadian(T kilonewtonmillimetersperradian)
         {
-            double value = (double) kilonewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(kilonewtonmillimetersperradian, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from KilopoundForceFeetPerDegrees.
+        ///     Get <see cref="RotationalStiffness{T}" /> from KilopoundForceFeetPerDegrees.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(QuantityValue kilopoundforcefeetperdegrees)
+        public static RotationalStiffness<T> FromKilopoundForceFeetPerDegrees(T kilopoundforcefeetperdegrees)
         {
-            double value = (double) kilopoundforcefeetperdegrees;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+            return new RotationalStiffness<T>(kilopoundforcefeetperdegrees, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MeganewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MeganewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMetersPerDegree(QuantityValue meganewtonmetersperdegree)
+        public static RotationalStiffness<T> FromMeganewtonMetersPerDegree(T meganewtonmetersperdegree)
         {
-            double value = (double) meganewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
+            return new RotationalStiffness<T>(meganewtonmetersperdegree, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MeganewtonMetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MeganewtonMetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMetersPerRadian(QuantityValue meganewtonmetersperradian)
+        public static RotationalStiffness<T> FromMeganewtonMetersPerRadian(T meganewtonmetersperradian)
         {
-            double value = (double) meganewtonmetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+            return new RotationalStiffness<T>(meganewtonmetersperradian, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MeganewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MeganewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(QuantityValue meganewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromMeganewtonMillimetersPerDegree(T meganewtonmillimetersperdegree)
         {
-            double value = (double) meganewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(meganewtonmillimetersperdegree, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MeganewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MeganewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(QuantityValue meganewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromMeganewtonMillimetersPerRadian(T meganewtonmillimetersperradian)
         {
-            double value = (double) meganewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(meganewtonmillimetersperradian, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MicronewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MicronewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMetersPerDegree(QuantityValue micronewtonmetersperdegree)
+        public static RotationalStiffness<T> FromMicronewtonMetersPerDegree(T micronewtonmetersperdegree)
         {
-            double value = (double) micronewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
+            return new RotationalStiffness<T>(micronewtonmetersperdegree, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MicronewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MicronewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(QuantityValue micronewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromMicronewtonMillimetersPerDegree(T micronewtonmillimetersperdegree)
         {
-            double value = (double) micronewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(micronewtonmillimetersperdegree, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MicronewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MicronewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(QuantityValue micronewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromMicronewtonMillimetersPerRadian(T micronewtonmillimetersperradian)
         {
-            double value = (double) micronewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(micronewtonmillimetersperradian, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MillinewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MillinewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMetersPerDegree(QuantityValue millinewtonmetersperdegree)
+        public static RotationalStiffness<T> FromMillinewtonMetersPerDegree(T millinewtonmetersperdegree)
         {
-            double value = (double) millinewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
+            return new RotationalStiffness<T>(millinewtonmetersperdegree, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MillinewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MillinewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(QuantityValue millinewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromMillinewtonMillimetersPerDegree(T millinewtonmillimetersperdegree)
         {
-            double value = (double) millinewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(millinewtonmillimetersperdegree, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from MillinewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from MillinewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(QuantityValue millinewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromMillinewtonMillimetersPerRadian(T millinewtonmillimetersperradian)
         {
-            double value = (double) millinewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(millinewtonmillimetersperradian, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from NanonewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from NanonewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMetersPerDegree(QuantityValue nanonewtonmetersperdegree)
+        public static RotationalStiffness<T> FromNanonewtonMetersPerDegree(T nanonewtonmetersperdegree)
         {
-            double value = (double) nanonewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
+            return new RotationalStiffness<T>(nanonewtonmetersperdegree, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from NanonewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from NanonewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(QuantityValue nanonewtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromNanonewtonMillimetersPerDegree(T nanonewtonmillimetersperdegree)
         {
-            double value = (double) nanonewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(nanonewtonmillimetersperdegree, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from NanonewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from NanonewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(QuantityValue nanonewtonmillimetersperradian)
+        public static RotationalStiffness<T> FromNanonewtonMillimetersPerRadian(T nanonewtonmillimetersperradian)
         {
-            double value = (double) nanonewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(nanonewtonmillimetersperradian, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from NewtonMetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from NewtonMetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMetersPerDegree(QuantityValue newtonmetersperdegree)
+        public static RotationalStiffness<T> FromNewtonMetersPerDegree(T newtonmetersperdegree)
         {
-            double value = (double) newtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree);
+            return new RotationalStiffness<T>(newtonmetersperdegree, RotationalStiffnessUnit.NewtonMeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from NewtonMetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from NewtonMetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMetersPerRadian(QuantityValue newtonmetersperradian)
+        public static RotationalStiffness<T> FromNewtonMetersPerRadian(T newtonmetersperradian)
         {
-            double value = (double) newtonmetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian);
+            return new RotationalStiffness<T>(newtonmetersperradian, RotationalStiffnessUnit.NewtonMeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from NewtonMillimetersPerDegree.
+        ///     Get <see cref="RotationalStiffness{T}" /> from NewtonMillimetersPerDegree.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMillimetersPerDegree(QuantityValue newtonmillimetersperdegree)
+        public static RotationalStiffness<T> FromNewtonMillimetersPerDegree(T newtonmillimetersperdegree)
         {
-            double value = (double) newtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
+            return new RotationalStiffness<T>(newtonmillimetersperdegree, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
         }
         /// <summary>
-        ///     Get RotationalStiffness from NewtonMillimetersPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from NewtonMillimetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMillimetersPerRadian(QuantityValue newtonmillimetersperradian)
+        public static RotationalStiffness<T> FromNewtonMillimetersPerRadian(T newtonmillimetersperradian)
         {
-            double value = (double) newtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
+            return new RotationalStiffness<T>(newtonmillimetersperradian, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from PoundForceFeetPerRadian.
+        ///     Get <see cref="RotationalStiffness{T}" /> from PoundForceFeetPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromPoundForceFeetPerRadian(QuantityValue poundforcefeetperradian)
+        public static RotationalStiffness<T> FromPoundForceFeetPerRadian(T poundforcefeetperradian)
         {
-            double value = (double) poundforcefeetperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian);
+            return new RotationalStiffness<T>(poundforcefeetperradian, RotationalStiffnessUnit.PoundForceFeetPerRadian);
         }
         /// <summary>
-        ///     Get RotationalStiffness from PoundForceFeetPerDegrees.
+        ///     Get <see cref="RotationalStiffness{T}" /> from PoundForceFeetPerDegrees.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue poundforcefeetperdegrees)
+        public static RotationalStiffness<T> FromPoundForceFeetPerDegrees(T poundforcefeetperdegrees)
         {
-            double value = (double) poundforcefeetperdegrees;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees);
+            return new RotationalStiffness<T>(poundforcefeetperdegrees, RotationalStiffnessUnit.PoundForceFootPerDegrees);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessUnit" /> to <see cref="RotationalStiffness" />.
+        ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessUnit" /> to <see cref="RotationalStiffness{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalStiffness unit value.</returns>
-        public static RotationalStiffness From(QuantityValue value, RotationalStiffnessUnit fromUnit)
+        /// <returns><see cref="RotationalStiffness{T}" /> unit value.</returns>
+        public static RotationalStiffness<T> From(T value, RotationalStiffnessUnit fromUnit)
         {
-            return new RotationalStiffness((double)value, fromUnit);
+            return new RotationalStiffness<T>(value, fromUnit);
         }
 
         #endregion
@@ -727,7 +692,7 @@ public static RotationalStiffness From(QuantityValue value, RotationalStiffnessU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static RotationalStiffness Parse(string str)
+        public static RotationalStiffness<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -755,9 +720,9 @@ public static RotationalStiffness Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static RotationalStiffness Parse(string str, IFormatProvider? provider)
+        public static RotationalStiffness<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<RotationalStiffness, RotationalStiffnessUnit>(
+            return QuantityParser.Default.Parse<T, RotationalStiffness<T>, RotationalStiffnessUnit>(
                 str,
                 provider,
                 From);
@@ -771,7 +736,7 @@ public static RotationalStiffness Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out RotationalStiffness result)
+        public static bool TryParse(string? str, out RotationalStiffness<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -786,9 +751,9 @@ public static bool TryParse(string? str, out RotationalStiffness result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalStiffness result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalStiffness<T> result)
         {
-            return QuantityParser.Default.TryParse<RotationalStiffness, RotationalStiffnessUnit>(
+            return QuantityParser.Default.TryParse<T, RotationalStiffness<T>, RotationalStiffnessUnit>(
                 str,
                 provider,
                 From,
@@ -850,45 +815,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static RotationalStiffness operator -(RotationalStiffness right)
+        public static RotationalStiffness<T> operator -(RotationalStiffness<T> right)
         {
-            return new RotationalStiffness(-right.Value, right.Unit);
+            return new RotationalStiffness<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffness"/> from adding two <see cref="RotationalStiffness"/>.</summary>
-        public static RotationalStiffness operator +(RotationalStiffness left, RotationalStiffness right)
+        /// <summary>Get <see cref="RotationalStiffness{T}"/> from adding two <see cref="RotationalStiffness{T}"/>.</summary>
+        public static RotationalStiffness<T> operator +(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
-            return new RotationalStiffness(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalStiffness<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffness"/> from subtracting two <see cref="RotationalStiffness"/>.</summary>
-        public static RotationalStiffness operator -(RotationalStiffness left, RotationalStiffness right)
+        /// <summary>Get <see cref="RotationalStiffness{T}"/> from subtracting two <see cref="RotationalStiffness{T}"/>.</summary>
+        public static RotationalStiffness<T> operator -(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
-            return new RotationalStiffness(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalStiffness<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffness"/> from multiplying value and <see cref="RotationalStiffness"/>.</summary>
-        public static RotationalStiffness operator *(double left, RotationalStiffness right)
+        /// <summary>Get <see cref="RotationalStiffness{T}"/> from multiplying value and <see cref="RotationalStiffness{T}"/>.</summary>
+        public static RotationalStiffness<T> operator *(T left, RotationalStiffness<T> right)
         {
-            return new RotationalStiffness(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new RotationalStiffness<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffness"/> from multiplying value and <see cref="RotationalStiffness"/>.</summary>
-        public static RotationalStiffness operator *(RotationalStiffness left, double right)
+        /// <summary>Get <see cref="RotationalStiffness{T}"/> from multiplying value and <see cref="RotationalStiffness{T}"/>.</summary>
+        public static RotationalStiffness<T> operator *(RotationalStiffness<T> left, T right)
         {
-            return new RotationalStiffness(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new RotationalStiffness<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffness"/> from dividing <see cref="RotationalStiffness"/> by value.</summary>
-        public static RotationalStiffness operator /(RotationalStiffness left, double right)
+        /// <summary>Get <see cref="RotationalStiffness{T}"/> from dividing <see cref="RotationalStiffness{T}"/> by value.</summary>
+        public static RotationalStiffness<T> operator /(RotationalStiffness<T> left, T right)
         {
-            return new RotationalStiffness(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new RotationalStiffness<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="RotationalStiffness"/> by <see cref="RotationalStiffness"/>.</summary>
-        public static double operator /(RotationalStiffness left, RotationalStiffness right)
+        /// <summary>Get ratio value from dividing <see cref="RotationalStiffness{T}"/> by <see cref="RotationalStiffness{T}"/>.</summary>
+        public static T operator /(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
-            return left.NewtonMetersPerRadian / right.NewtonMetersPerRadian;
+            return CompiledLambdas.Divide(left.NewtonMetersPerRadian, right.NewtonMetersPerRadian);
         }
 
         #endregion
@@ -896,39 +866,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(RotationalStiffness left, RotationalStiffness right)
+        public static bool operator <=(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(RotationalStiffness left, RotationalStiffness right)
+        public static bool operator >=(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(RotationalStiffness left, RotationalStiffness right)
+        public static bool operator <(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(RotationalStiffness left, RotationalStiffness right)
+        public static bool operator >(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffness, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(RotationalStiffness left, RotationalStiffness right)
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffness{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffness, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(RotationalStiffness left, RotationalStiffness right)
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffness{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(RotationalStiffness<T> left, RotationalStiffness<T> right)
         {
             return !(left == right);
         }
@@ -937,37 +907,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is RotationalStiffness objRotationalStiffness)) throw new ArgumentException("Expected type RotationalStiffness.", nameof(obj));
+            if(!(obj is RotationalStiffness<T> objRotationalStiffness)) throw new ArgumentException("Expected type RotationalStiffness.", nameof(obj));
 
             return CompareTo(objRotationalStiffness);
         }
 
         /// <inheritdoc />
-        public int CompareTo(RotationalStiffness other)
+        public int CompareTo(RotationalStiffness<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffness, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffness{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is RotationalStiffness objRotationalStiffness))
+            if(obj is null || !(obj is RotationalStiffness<T> objRotationalStiffness))
                 return false;
 
             return Equals(objRotationalStiffness);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffness, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(RotationalStiffness other)
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffness{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(RotationalStiffness<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another RotationalStiffness within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="RotationalStiffness{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1005,21 +975,19 @@ public bool Equals(RotationalStiffness other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(RotationalStiffness other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(RotationalStiffness<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current RotationalStiffness.</returns>
+        /// <returns>A hash code for the current <see cref="RotationalStiffness{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1033,17 +1001,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalStiffnessUnit unit)
+        public T As(RotationalStiffnessUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1063,17 +1031,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is RotationalStiffnessUnit unitAsRotationalStiffnessUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessUnit)} is supported.", nameof(unit));
 
-            return As(unitAsRotationalStiffnessUnit);
+            var asValue = As(unitAsRotationalStiffnessUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<RotationalStiffnessUnit>.As(RotationalStiffnessUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this RotationalStiffness to another RotationalStiffness with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="RotationalStiffness{T}" /> to another <see cref="RotationalStiffness{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A RotationalStiffness with the specified unit.</returns>
-        public RotationalStiffness ToUnit(RotationalStiffnessUnit unit)
+        /// <returns>A <see cref="RotationalStiffness{T}" /> with the specified unit.</returns>
+        public RotationalStiffness<T> ToUnit(RotationalStiffnessUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new RotationalStiffness(convertedValue, unit);
+            return new RotationalStiffness<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1086,7 +1059,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public RotationalStiffness ToUnit(UnitSystem unitSystem)
+        public RotationalStiffness<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1106,51 +1079,57 @@ public RotationalStiffness ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalStiffnessUnit> IQuantity<RotationalStiffnessUnit>.ToUnit(RotationalStiffnessUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalStiffnessUnit, T> IQuantityT<RotationalStiffnessUnit, T>.ToUnit(RotationalStiffnessUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<RotationalStiffnessUnit> IQuantity<RotationalStiffnessUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalStiffnessUnit, T> IQuantityT<RotationalStiffnessUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case RotationalStiffnessUnit.CentinewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e-2d;
-                case RotationalStiffnessUnit.CentinewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e-2d;
-                case RotationalStiffnessUnit.CentinewtonMillimeterPerRadian: return (_value*0.001) * 1e-2d;
-                case RotationalStiffnessUnit.DecanewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e1d;
-                case RotationalStiffnessUnit.DecanewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e1d;
-                case RotationalStiffnessUnit.DecanewtonMillimeterPerRadian: return (_value*0.001) * 1e1d;
-                case RotationalStiffnessUnit.DecinewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e-1d;
-                case RotationalStiffnessUnit.DecinewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e-1d;
-                case RotationalStiffnessUnit.DecinewtonMillimeterPerRadian: return (_value*0.001) * 1e-1d;
-                case RotationalStiffnessUnit.KilonewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e3d;
-                case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d;
-                case RotationalStiffnessUnit.KilonewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e3d;
-                case RotationalStiffnessUnit.KilonewtonMillimeterPerRadian: return (_value*0.001) * 1e3d;
-                case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return _value*77682.6;
-                case RotationalStiffnessUnit.MeganewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e6d;
-                case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d;
-                case RotationalStiffnessUnit.MeganewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e6d;
-                case RotationalStiffnessUnit.MeganewtonMillimeterPerRadian: return (_value*0.001) * 1e6d;
-                case RotationalStiffnessUnit.MicronewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e-6d;
-                case RotationalStiffnessUnit.MicronewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e-6d;
-                case RotationalStiffnessUnit.MicronewtonMillimeterPerRadian: return (_value*0.001) * 1e-6d;
-                case RotationalStiffnessUnit.MillinewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e-3d;
-                case RotationalStiffnessUnit.MillinewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e-3d;
-                case RotationalStiffnessUnit.MillinewtonMillimeterPerRadian: return (_value*0.001) * 1e-3d;
-                case RotationalStiffnessUnit.NanonewtonMeterPerDegree: return (_value*(180/Math.PI)) * 1e-9d;
-                case RotationalStiffnessUnit.NanonewtonMillimeterPerDegree: return (_value*180/Math.PI*0.001) * 1e-9d;
-                case RotationalStiffnessUnit.NanonewtonMillimeterPerRadian: return (_value*0.001) * 1e-9d;
-                case RotationalStiffnessUnit.NewtonMeterPerDegree: return _value*(180/Math.PI);
-                case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value;
-                case RotationalStiffnessUnit.NewtonMillimeterPerDegree: return _value*180/Math.PI*0.001;
-                case RotationalStiffnessUnit.NewtonMillimeterPerRadian: return _value*0.001;
-                case RotationalStiffnessUnit.PoundForceFeetPerRadian: return _value*1.3558179483314;
-                case RotationalStiffnessUnit.PoundForceFootPerDegrees: return _value*77.6826;
+                case RotationalStiffnessUnit.CentinewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e-2d;
+                case RotationalStiffnessUnit.CentinewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e-2d;
+                case RotationalStiffnessUnit.CentinewtonMillimeterPerRadian: return (Value*0.001) * 1e-2d;
+                case RotationalStiffnessUnit.DecanewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e1d;
+                case RotationalStiffnessUnit.DecanewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e1d;
+                case RotationalStiffnessUnit.DecanewtonMillimeterPerRadian: return (Value*0.001) * 1e1d;
+                case RotationalStiffnessUnit.DecinewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e-1d;
+                case RotationalStiffnessUnit.DecinewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e-1d;
+                case RotationalStiffnessUnit.DecinewtonMillimeterPerRadian: return (Value*0.001) * 1e-1d;
+                case RotationalStiffnessUnit.KilonewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e3d;
+                case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (Value) * 1e3d;
+                case RotationalStiffnessUnit.KilonewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e3d;
+                case RotationalStiffnessUnit.KilonewtonMillimeterPerRadian: return (Value*0.001) * 1e3d;
+                case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return Value*77682.6;
+                case RotationalStiffnessUnit.MeganewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e6d;
+                case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (Value) * 1e6d;
+                case RotationalStiffnessUnit.MeganewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e6d;
+                case RotationalStiffnessUnit.MeganewtonMillimeterPerRadian: return (Value*0.001) * 1e6d;
+                case RotationalStiffnessUnit.MicronewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e-6d;
+                case RotationalStiffnessUnit.MicronewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e-6d;
+                case RotationalStiffnessUnit.MicronewtonMillimeterPerRadian: return (Value*0.001) * 1e-6d;
+                case RotationalStiffnessUnit.MillinewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e-3d;
+                case RotationalStiffnessUnit.MillinewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e-3d;
+                case RotationalStiffnessUnit.MillinewtonMillimeterPerRadian: return (Value*0.001) * 1e-3d;
+                case RotationalStiffnessUnit.NanonewtonMeterPerDegree: return (Value*(180/Math.PI)) * 1e-9d;
+                case RotationalStiffnessUnit.NanonewtonMillimeterPerDegree: return (Value*180/Math.PI*0.001) * 1e-9d;
+                case RotationalStiffnessUnit.NanonewtonMillimeterPerRadian: return (Value*0.001) * 1e-9d;
+                case RotationalStiffnessUnit.NewtonMeterPerDegree: return Value*(180/Math.PI);
+                case RotationalStiffnessUnit.NewtonMeterPerRadian: return Value;
+                case RotationalStiffnessUnit.NewtonMillimeterPerDegree: return Value*180/Math.PI*0.001;
+                case RotationalStiffnessUnit.NewtonMillimeterPerRadian: return Value*0.001;
+                case RotationalStiffnessUnit.PoundForceFeetPerRadian: return Value*1.3558179483314;
+                case RotationalStiffnessUnit.PoundForceFootPerDegrees: return Value*77.6826;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1161,16 +1140,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal RotationalStiffness ToBaseUnit()
+        internal RotationalStiffness<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new RotationalStiffness(baseUnitValue, BaseUnit);
+            return new RotationalStiffness<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(RotationalStiffnessUnit unit)
+        private T GetValueAs(RotationalStiffnessUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1305,57 +1284,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalStiffness)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalStiffness<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalStiffness)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalStiffness<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalStiffness)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalStiffness<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1365,33 +1344,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(RotationalStiffness))
+            if(conversionType == typeof(RotationalStiffness<T>))
                 return this;
             else if(conversionType == typeof(RotationalStiffnessUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return RotationalStiffness.QuantityType;
+                return RotationalStiffness<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return RotationalStiffness.Info;
+                return RotationalStiffness<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return RotationalStiffness.BaseDimensions;
+                return RotationalStiffness<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(RotationalStiffness)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(RotationalStiffness<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
index 2fcf8b0a76..337b0304c4 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     https://en.wikipedia.org/wiki/Stiffness#Rotational_stiffness
     /// </summary>
-    public partial struct RotationalStiffnessPerLength : IQuantity<RotationalStiffnessPerLengthUnit>, IEquatable<RotationalStiffnessPerLength>, IComparable, IComparable<RotationalStiffnessPerLength>, IConvertible, IFormattable
+    public partial struct RotationalStiffnessPerLength<T> : IQuantityT<RotationalStiffnessPerLengthUnit, T>, IEquatable<RotationalStiffnessPerLength<T>>, IComparable, IComparable<RotationalStiffnessPerLength<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -67,12 +63,12 @@ static RotationalStiffnessPerLength()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public RotationalStiffnessPerLength(double value, RotationalStiffnessPerLengthUnit unit)
+        public RotationalStiffnessPerLength(T value, RotationalStiffnessPerLengthUnit unit)
         {
             if(unit == RotationalStiffnessPerLengthUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -84,14 +80,14 @@ public RotationalStiffnessPerLength(double value, RotationalStiffnessPerLengthUn
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
+        public RotationalStiffnessPerLength(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -106,19 +102,19 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of RotationalStiffnessPerLength, which is NewtonMeterPerRadianPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="RotationalStiffnessPerLength{T}" />, which is NewtonMeterPerRadianPerMeter. All conversions go via this value.
         /// </summary>
         public static RotationalStiffnessPerLengthUnit BaseUnit { get; } = RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of RotationalStiffnessPerLength
+        /// Represents the largest possible value of <see cref="RotationalStiffnessPerLength{T}" />
         /// </summary>
-        public static RotationalStiffnessPerLength MaxValue { get; } = new RotationalStiffnessPerLength(double.MaxValue, BaseUnit);
+        public static RotationalStiffnessPerLength<T> MaxValue { get; } = new RotationalStiffnessPerLength<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of RotationalStiffnessPerLength
+        /// Represents the smallest possible value of <see cref="RotationalStiffnessPerLength{T}" />
         /// </summary>
-        public static RotationalStiffnessPerLength MinValue { get; } = new RotationalStiffnessPerLength(double.MinValue, BaseUnit);
+        public static RotationalStiffnessPerLength<T> MinValue { get; } = new RotationalStiffnessPerLength<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -127,14 +123,14 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.RotationalStiffnessPerLength;
 
         /// <summary>
-        ///     All units of measurement for the RotationalStiffnessPerLength quantity.
+        ///     All units of measurement for the <see cref="RotationalStiffnessPerLength{T}" /> quantity.
         /// </summary>
         public static RotationalStiffnessPerLengthUnit[] Units { get; } = Enum.GetValues(typeof(RotationalStiffnessPerLengthUnit)).Cast<RotationalStiffnessPerLengthUnit>().Except(new RotationalStiffnessPerLengthUnit[]{ RotationalStiffnessPerLengthUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonMeterPerRadianPerMeter.
         /// </summary>
-        public static RotationalStiffnessPerLength Zero { get; } = new RotationalStiffnessPerLength(0, BaseUnit);
+        public static RotationalStiffnessPerLength<T> Zero { get; } = new RotationalStiffnessPerLength<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -143,7 +139,9 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -159,41 +157,41 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => RotationalStiffnessPerLength.QuantityType;
+        public QuantityType Type => RotationalStiffnessPerLength<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => RotationalStiffnessPerLength.BaseDimensions;
+        public BaseDimensions Dimensions => RotationalStiffnessPerLength<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get RotationalStiffnessPerLength in KilonewtonMetersPerRadianPerMeter.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> in KilonewtonMetersPerRadianPerMeter.
         /// </summary>
-        public double KilonewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
+        public T KilonewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
 
         /// <summary>
-        ///     Get RotationalStiffnessPerLength in KilopoundForceFeetPerDegreesPerFeet.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> in KilopoundForceFeetPerDegreesPerFeet.
         /// </summary>
-        public double KilopoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
+        public T KilopoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
 
         /// <summary>
-        ///     Get RotationalStiffnessPerLength in MeganewtonMetersPerRadianPerMeter.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> in MeganewtonMetersPerRadianPerMeter.
         /// </summary>
-        public double MeganewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
+        public T MeganewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
 
         /// <summary>
-        ///     Get RotationalStiffnessPerLength in NewtonMetersPerRadianPerMeter.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> in NewtonMetersPerRadianPerMeter.
         /// </summary>
-        public double NewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
+        public T NewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
 
         /// <summary>
-        ///     Get RotationalStiffnessPerLength in PoundForceFeetPerDegreesPerFeet.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> in PoundForceFeetPerDegreesPerFeet.
         /// </summary>
-        public double PoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
+        public T PoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
 
         #endregion
 
@@ -225,60 +223,55 @@ public static string GetAbbreviation(RotationalStiffnessPerLengthUnit unit, IFor
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get RotationalStiffnessPerLength from KilonewtonMetersPerRadianPerMeter.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> from KilonewtonMetersPerRadianPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(QuantityValue kilonewtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength<T> FromKilonewtonMetersPerRadianPerMeter(T kilonewtonmetersperradianpermeter)
         {
-            double value = (double) kilonewtonmetersperradianpermeter;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength<T>(kilonewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
         }
         /// <summary>
-        ///     Get RotationalStiffnessPerLength from KilopoundForceFeetPerDegreesPerFeet.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> from KilopoundForceFeetPerDegreesPerFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(QuantityValue kilopoundforcefeetperdegreesperfeet)
+        public static RotationalStiffnessPerLength<T> FromKilopoundForceFeetPerDegreesPerFeet(T kilopoundforcefeetperdegreesperfeet)
         {
-            double value = (double) kilopoundforcefeetperdegreesperfeet;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
+            return new RotationalStiffnessPerLength<T>(kilopoundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
         }
         /// <summary>
-        ///     Get RotationalStiffnessPerLength from MeganewtonMetersPerRadianPerMeter.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> from MeganewtonMetersPerRadianPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(QuantityValue meganewtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength<T> FromMeganewtonMetersPerRadianPerMeter(T meganewtonmetersperradianpermeter)
         {
-            double value = (double) meganewtonmetersperradianpermeter;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength<T>(meganewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
         }
         /// <summary>
-        ///     Get RotationalStiffnessPerLength from NewtonMetersPerRadianPerMeter.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> from NewtonMetersPerRadianPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(QuantityValue newtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength<T> FromNewtonMetersPerRadianPerMeter(T newtonmetersperradianpermeter)
         {
-            double value = (double) newtonmetersperradianpermeter;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength<T>(newtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
         }
         /// <summary>
-        ///     Get RotationalStiffnessPerLength from PoundForceFeetPerDegreesPerFeet.
+        ///     Get <see cref="RotationalStiffnessPerLength{T}" /> from PoundForceFeetPerDegreesPerFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(QuantityValue poundforcefeetperdegreesperfeet)
+        public static RotationalStiffnessPerLength<T> FromPoundForceFeetPerDegreesPerFeet(T poundforcefeetperdegreesperfeet)
         {
-            double value = (double) poundforcefeetperdegreesperfeet;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
+            return new RotationalStiffnessPerLength<T>(poundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessPerLengthUnit" /> to <see cref="RotationalStiffnessPerLength" />.
+        ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessPerLengthUnit" /> to <see cref="RotationalStiffnessPerLength{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalStiffnessPerLength unit value.</returns>
-        public static RotationalStiffnessPerLength From(QuantityValue value, RotationalStiffnessPerLengthUnit fromUnit)
+        /// <returns><see cref="RotationalStiffnessPerLength{T}" /> unit value.</returns>
+        public static RotationalStiffnessPerLength<T> From(T value, RotationalStiffnessPerLengthUnit fromUnit)
         {
-            return new RotationalStiffnessPerLength((double)value, fromUnit);
+            return new RotationalStiffnessPerLength<T>(value, fromUnit);
         }
 
         #endregion
@@ -307,7 +300,7 @@ public static RotationalStiffnessPerLength From(QuantityValue value, RotationalS
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static RotationalStiffnessPerLength Parse(string str)
+        public static RotationalStiffnessPerLength<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -335,9 +328,9 @@ public static RotationalStiffnessPerLength Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static RotationalStiffnessPerLength Parse(string str, IFormatProvider? provider)
+        public static RotationalStiffnessPerLength<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>(
+            return QuantityParser.Default.Parse<T, RotationalStiffnessPerLength<T>, RotationalStiffnessPerLengthUnit>(
                 str,
                 provider,
                 From);
@@ -351,7 +344,7 @@ public static RotationalStiffnessPerLength Parse(string str, IFormatProvider? pr
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out RotationalStiffnessPerLength result)
+        public static bool TryParse(string? str, out RotationalStiffnessPerLength<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -366,9 +359,9 @@ public static bool TryParse(string? str, out RotationalStiffnessPerLength result
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalStiffnessPerLength result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out RotationalStiffnessPerLength<T> result)
         {
-            return QuantityParser.Default.TryParse<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>(
+            return QuantityParser.Default.TryParse<T, RotationalStiffnessPerLength<T>, RotationalStiffnessPerLengthUnit>(
                 str,
                 provider,
                 From,
@@ -430,45 +423,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static RotationalStiffnessPerLength operator -(RotationalStiffnessPerLength right)
+        public static RotationalStiffnessPerLength<T> operator -(RotationalStiffnessPerLength<T> right)
         {
-            return new RotationalStiffnessPerLength(-right.Value, right.Unit);
+            return new RotationalStiffnessPerLength<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from adding two <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static RotationalStiffnessPerLength operator +(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        /// <summary>Get <see cref="RotationalStiffnessPerLength{T}"/> from adding two <see cref="RotationalStiffnessPerLength{T}"/>.</summary>
+        public static RotationalStiffnessPerLength<T> operator +(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
-            return new RotationalStiffnessPerLength(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalStiffnessPerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from subtracting two <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static RotationalStiffnessPerLength operator -(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        /// <summary>Get <see cref="RotationalStiffnessPerLength{T}"/> from subtracting two <see cref="RotationalStiffnessPerLength{T}"/>.</summary>
+        public static RotationalStiffnessPerLength<T> operator -(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
-            return new RotationalStiffnessPerLength(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new RotationalStiffnessPerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from multiplying value and <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static RotationalStiffnessPerLength operator *(double left, RotationalStiffnessPerLength right)
+        /// <summary>Get <see cref="RotationalStiffnessPerLength{T}"/> from multiplying value and <see cref="RotationalStiffnessPerLength{T}"/>.</summary>
+        public static RotationalStiffnessPerLength<T> operator *(T left, RotationalStiffnessPerLength<T> right)
         {
-            return new RotationalStiffnessPerLength(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new RotationalStiffnessPerLength<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from multiplying value and <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static RotationalStiffnessPerLength operator *(RotationalStiffnessPerLength left, double right)
+        /// <summary>Get <see cref="RotationalStiffnessPerLength{T}"/> from multiplying value and <see cref="RotationalStiffnessPerLength{T}"/>.</summary>
+        public static RotationalStiffnessPerLength<T> operator *(RotationalStiffnessPerLength<T> left, T right)
         {
-            return new RotationalStiffnessPerLength(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new RotationalStiffnessPerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from dividing <see cref="RotationalStiffnessPerLength"/> by value.</summary>
-        public static RotationalStiffnessPerLength operator /(RotationalStiffnessPerLength left, double right)
+        /// <summary>Get <see cref="RotationalStiffnessPerLength{T}"/> from dividing <see cref="RotationalStiffnessPerLength{T}"/> by value.</summary>
+        public static RotationalStiffnessPerLength<T> operator /(RotationalStiffnessPerLength<T> left, T right)
         {
-            return new RotationalStiffnessPerLength(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new RotationalStiffnessPerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="RotationalStiffnessPerLength"/> by <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static double operator /(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        /// <summary>Get ratio value from dividing <see cref="RotationalStiffnessPerLength{T}"/> by <see cref="RotationalStiffnessPerLength{T}"/>.</summary>
+        public static T operator /(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
-            return left.NewtonMetersPerRadianPerMeter / right.NewtonMetersPerRadianPerMeter;
+            return CompiledLambdas.Divide(left.NewtonMetersPerRadianPerMeter, right.NewtonMetersPerRadianPerMeter);
         }
 
         #endregion
@@ -476,39 +474,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        public static bool operator <=(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        public static bool operator >=(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        public static bool operator <(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        public static bool operator >(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(RotationalStiffnessPerLength<T> left, RotationalStiffnessPerLength<T> right)
         {
             return !(left == right);
         }
@@ -517,37 +515,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Rotat
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is RotationalStiffnessPerLength objRotationalStiffnessPerLength)) throw new ArgumentException("Expected type RotationalStiffnessPerLength.", nameof(obj));
+            if(!(obj is RotationalStiffnessPerLength<T> objRotationalStiffnessPerLength)) throw new ArgumentException("Expected type RotationalStiffnessPerLength.", nameof(obj));
 
             return CompareTo(objRotationalStiffnessPerLength);
         }
 
         /// <inheritdoc />
-        public int CompareTo(RotationalStiffnessPerLength other)
+        public int CompareTo(RotationalStiffnessPerLength<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is RotationalStiffnessPerLength objRotationalStiffnessPerLength))
+            if(obj is null || !(obj is RotationalStiffnessPerLength<T> objRotationalStiffnessPerLength))
                 return false;
 
             return Equals(objRotationalStiffnessPerLength);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(RotationalStiffnessPerLength other)
+        /// <remarks>Consider using <see cref="Equals(RotationalStiffnessPerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(RotationalStiffnessPerLength<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another RotationalStiffnessPerLength within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="RotationalStiffnessPerLength{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -585,21 +583,19 @@ public bool Equals(RotationalStiffnessPerLength other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(RotationalStiffnessPerLength other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(RotationalStiffnessPerLength<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current RotationalStiffnessPerLength.</returns>
+        /// <returns>A hash code for the current <see cref="RotationalStiffnessPerLength{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -613,17 +609,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalStiffnessPerLengthUnit unit)
+        public T As(RotationalStiffnessPerLengthUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -643,17 +639,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is RotationalStiffnessPerLengthUnit unitAsRotationalStiffnessPerLengthUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessPerLengthUnit)} is supported.", nameof(unit));
 
-            return As(unitAsRotationalStiffnessPerLengthUnit);
+            var asValue = As(unitAsRotationalStiffnessPerLengthUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<RotationalStiffnessPerLengthUnit>.As(RotationalStiffnessPerLengthUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this RotationalStiffnessPerLength to another RotationalStiffnessPerLength with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="RotationalStiffnessPerLength{T}" /> to another <see cref="RotationalStiffnessPerLength{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A RotationalStiffnessPerLength with the specified unit.</returns>
-        public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit)
+        /// <returns>A <see cref="RotationalStiffnessPerLength{T}" /> with the specified unit.</returns>
+        public RotationalStiffnessPerLength<T> ToUnit(RotationalStiffnessPerLengthUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new RotationalStiffnessPerLength(convertedValue, unit);
+            return new RotationalStiffnessPerLength<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -666,7 +667,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public RotationalStiffnessPerLength ToUnit(UnitSystem unitSystem)
+        public RotationalStiffnessPerLength<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -686,23 +687,29 @@ public RotationalStiffnessPerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalStiffnessPerLengthUnit> IQuantity<RotationalStiffnessPerLengthUnit>.ToUnit(RotationalStiffnessPerLengthUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalStiffnessPerLengthUnit, T> IQuantityT<RotationalStiffnessPerLengthUnit, T>.ToUnit(RotationalStiffnessPerLengthUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<RotationalStiffnessPerLengthUnit> IQuantity<RotationalStiffnessPerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<RotationalStiffnessPerLengthUnit, T> IQuantityT<RotationalStiffnessPerLengthUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: return (_value) * 1e3d;
-                case RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot: return _value*254864.324570;
-                case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: return (_value) * 1e6d;
-                case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: return _value;
-                case RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot: return _value*254.864324570;
+                case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: return (Value) * 1e3d;
+                case RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot: return Value*254864.324570;
+                case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: return (Value) * 1e6d;
+                case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: return Value;
+                case RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot: return Value*254.864324570;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -713,16 +720,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal RotationalStiffnessPerLength ToBaseUnit()
+        internal RotationalStiffnessPerLength<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new RotationalStiffnessPerLength(baseUnitValue, BaseUnit);
+            return new RotationalStiffnessPerLength<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(RotationalStiffnessPerLengthUnit unit)
+        private T GetValueAs(RotationalStiffnessPerLengthUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -829,57 +836,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -889,33 +896,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(RotationalStiffnessPerLength))
+            if(conversionType == typeof(RotationalStiffnessPerLength<T>))
                 return this;
             else if(conversionType == typeof(RotationalStiffnessPerLengthUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return RotationalStiffnessPerLength.QuantityType;
+                return RotationalStiffnessPerLength<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return RotationalStiffnessPerLength.Info;
+                return RotationalStiffnessPerLength<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return RotationalStiffnessPerLength.BaseDimensions;
+                return RotationalStiffnessPerLength<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(RotationalStiffnessPerLength<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
index 6146e2814c..ce84d1bb2a 100644
--- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Solid_angle
     /// </remarks>
-    public partial struct SolidAngle : IQuantity<SolidAngleUnit>, IEquatable<SolidAngle>, IComparable, IComparable<SolidAngle>, IConvertible, IFormattable
+    public partial struct SolidAngle<T> : IQuantityT<SolidAngleUnit, T>, IEquatable<SolidAngle<T>>, IComparable, IComparable<SolidAngle<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static SolidAngle()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public SolidAngle(double value, SolidAngleUnit unit)
+        public SolidAngle(T value, SolidAngleUnit unit)
         {
             if(unit == SolidAngleUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public SolidAngle(double value, SolidAngleUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SolidAngle(double value, UnitSystem unitSystem)
+        public SolidAngle(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public SolidAngle(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of SolidAngle, which is Steradian. All conversions go via this value.
+        ///     The base unit of <see cref="SolidAngle{T}" />, which is Steradian. All conversions go via this value.
         /// </summary>
         public static SolidAngleUnit BaseUnit { get; } = SolidAngleUnit.Steradian;
 
         /// <summary>
-        /// Represents the largest possible value of SolidAngle
+        /// Represents the largest possible value of <see cref="SolidAngle{T}" />
         /// </summary>
-        public static SolidAngle MaxValue { get; } = new SolidAngle(double.MaxValue, BaseUnit);
+        public static SolidAngle<T> MaxValue { get; } = new SolidAngle<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of SolidAngle
+        /// Represents the smallest possible value of <see cref="SolidAngle{T}" />
         /// </summary>
-        public static SolidAngle MinValue { get; } = new SolidAngle(double.MinValue, BaseUnit);
+        public static SolidAngle<T> MinValue { get; } = new SolidAngle<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public SolidAngle(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.SolidAngle;
 
         /// <summary>
-        ///     All units of measurement for the SolidAngle quantity.
+        ///     All units of measurement for the <see cref="SolidAngle{T}" /> quantity.
         /// </summary>
         public static SolidAngleUnit[] Units { get; } = Enum.GetValues(typeof(SolidAngleUnit)).Cast<SolidAngleUnit>().Except(new SolidAngleUnit[]{ SolidAngleUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Steradian.
         /// </summary>
-        public static SolidAngle Zero { get; } = new SolidAngle(0, BaseUnit);
+        public static SolidAngle<T> Zero { get; } = new SolidAngle<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public SolidAngle(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public SolidAngle(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => SolidAngle.QuantityType;
+        public QuantityType Type => SolidAngle<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => SolidAngle.BaseDimensions;
+        public BaseDimensions Dimensions => SolidAngle<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get SolidAngle in Steradians.
+        ///     Get <see cref="SolidAngle{T}" /> in Steradians.
         /// </summary>
-        public double Steradians => As(SolidAngleUnit.Steradian);
+        public T Steradians => As(SolidAngleUnit.Steradian);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(SolidAngleUnit unit, IFormatProvider? provi
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get SolidAngle from Steradians.
+        ///     Get <see cref="SolidAngle{T}" /> from Steradians.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SolidAngle FromSteradians(QuantityValue steradians)
+        public static SolidAngle<T> FromSteradians(T steradians)
         {
-            double value = (double) steradians;
-            return new SolidAngle(value, SolidAngleUnit.Steradian);
+            return new SolidAngle<T>(steradians, SolidAngleUnit.Steradian);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SolidAngleUnit" /> to <see cref="SolidAngle" />.
+        ///     Dynamically convert from value and unit enum <see cref="SolidAngleUnit" /> to <see cref="SolidAngle{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SolidAngle unit value.</returns>
-        public static SolidAngle From(QuantityValue value, SolidAngleUnit fromUnit)
+        /// <returns><see cref="SolidAngle{T}" /> unit value.</returns>
+        public static SolidAngle<T> From(T value, SolidAngleUnit fromUnit)
         {
-            return new SolidAngle((double)value, fromUnit);
+            return new SolidAngle<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static SolidAngle From(QuantityValue value, SolidAngleUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static SolidAngle Parse(string str)
+        public static SolidAngle<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static SolidAngle Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static SolidAngle Parse(string str, IFormatProvider? provider)
+        public static SolidAngle<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<SolidAngle, SolidAngleUnit>(
+            return QuantityParser.Default.Parse<T, SolidAngle<T>, SolidAngleUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static SolidAngle Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out SolidAngle result)
+        public static bool TryParse(string? str, out SolidAngle<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out SolidAngle result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out SolidAngle result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out SolidAngle<T> result)
         {
-            return QuantityParser.Default.TryParse<SolidAngle, SolidAngleUnit>(
+            return QuantityParser.Default.TryParse<T, SolidAngle<T>, SolidAngleUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Solid
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static SolidAngle operator -(SolidAngle right)
+        public static SolidAngle<T> operator -(SolidAngle<T> right)
         {
-            return new SolidAngle(-right.Value, right.Unit);
+            return new SolidAngle<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="SolidAngle"/> from adding two <see cref="SolidAngle"/>.</summary>
-        public static SolidAngle operator +(SolidAngle left, SolidAngle right)
+        /// <summary>Get <see cref="SolidAngle{T}"/> from adding two <see cref="SolidAngle{T}"/>.</summary>
+        public static SolidAngle<T> operator +(SolidAngle<T> left, SolidAngle<T> right)
         {
-            return new SolidAngle(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new SolidAngle<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SolidAngle"/> from subtracting two <see cref="SolidAngle"/>.</summary>
-        public static SolidAngle operator -(SolidAngle left, SolidAngle right)
+        /// <summary>Get <see cref="SolidAngle{T}"/> from subtracting two <see cref="SolidAngle{T}"/>.</summary>
+        public static SolidAngle<T> operator -(SolidAngle<T> left, SolidAngle<T> right)
         {
-            return new SolidAngle(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new SolidAngle<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SolidAngle"/> from multiplying value and <see cref="SolidAngle"/>.</summary>
-        public static SolidAngle operator *(double left, SolidAngle right)
+        /// <summary>Get <see cref="SolidAngle{T}"/> from multiplying value and <see cref="SolidAngle{T}"/>.</summary>
+        public static SolidAngle<T> operator *(T left, SolidAngle<T> right)
         {
-            return new SolidAngle(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new SolidAngle<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="SolidAngle"/> from multiplying value and <see cref="SolidAngle"/>.</summary>
-        public static SolidAngle operator *(SolidAngle left, double right)
+        /// <summary>Get <see cref="SolidAngle{T}"/> from multiplying value and <see cref="SolidAngle{T}"/>.</summary>
+        public static SolidAngle<T> operator *(SolidAngle<T> left, T right)
         {
-            return new SolidAngle(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new SolidAngle<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SolidAngle"/> from dividing <see cref="SolidAngle"/> by value.</summary>
-        public static SolidAngle operator /(SolidAngle left, double right)
+        /// <summary>Get <see cref="SolidAngle{T}"/> from dividing <see cref="SolidAngle{T}"/> by value.</summary>
+        public static SolidAngle<T> operator /(SolidAngle<T> left, T right)
         {
-            return new SolidAngle(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new SolidAngle<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="SolidAngle"/> by <see cref="SolidAngle"/>.</summary>
-        public static double operator /(SolidAngle left, SolidAngle right)
+        /// <summary>Get ratio value from dividing <see cref="SolidAngle{T}"/> by <see cref="SolidAngle{T}"/>.</summary>
+        public static T operator /(SolidAngle<T> left, SolidAngle<T> right)
         {
-            return left.Steradians / right.Steradians;
+            return CompiledLambdas.Divide(left.Steradians, right.Steradians);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Solid
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(SolidAngle left, SolidAngle right)
+        public static bool operator <=(SolidAngle<T> left, SolidAngle<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(SolidAngle left, SolidAngle right)
+        public static bool operator >=(SolidAngle<T> left, SolidAngle<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(SolidAngle left, SolidAngle right)
+        public static bool operator <(SolidAngle<T> left, SolidAngle<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(SolidAngle left, SolidAngle right)
+        public static bool operator >(SolidAngle<T> left, SolidAngle<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SolidAngle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(SolidAngle left, SolidAngle right)
+        /// <remarks>Consider using <see cref="Equals(SolidAngle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(SolidAngle<T> left, SolidAngle<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SolidAngle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(SolidAngle left, SolidAngle right)
+        /// <remarks>Consider using <see cref="Equals(SolidAngle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(SolidAngle<T> left, SolidAngle<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Solid
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is SolidAngle objSolidAngle)) throw new ArgumentException("Expected type SolidAngle.", nameof(obj));
+            if(!(obj is SolidAngle<T> objSolidAngle)) throw new ArgumentException("Expected type SolidAngle.", nameof(obj));
 
             return CompareTo(objSolidAngle);
         }
 
         /// <inheritdoc />
-        public int CompareTo(SolidAngle other)
+        public int CompareTo(SolidAngle<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SolidAngle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(SolidAngle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is SolidAngle objSolidAngle))
+            if(obj is null || !(obj is SolidAngle<T> objSolidAngle))
                 return false;
 
             return Equals(objSolidAngle);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SolidAngle, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(SolidAngle other)
+        /// <remarks>Consider using <see cref="Equals(SolidAngle{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(SolidAngle<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another SolidAngle within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="SolidAngle{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(SolidAngle other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(SolidAngle other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(SolidAngle<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current SolidAngle.</returns>
+        /// <returns>A hash code for the current <see cref="SolidAngle{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(SolidAngleUnit unit)
+        public T As(SolidAngleUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is SolidAngleUnit unitAsSolidAngleUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SolidAngleUnit)} is supported.", nameof(unit));
 
-            return As(unitAsSolidAngleUnit);
+            var asValue = As(unitAsSolidAngleUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<SolidAngleUnit>.As(SolidAngleUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this SolidAngle to another SolidAngle with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="SolidAngle{T}" /> to another <see cref="SolidAngle{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A SolidAngle with the specified unit.</returns>
-        public SolidAngle ToUnit(SolidAngleUnit unit)
+        /// <returns>A <see cref="SolidAngle{T}" /> with the specified unit.</returns>
+        public SolidAngle<T> ToUnit(SolidAngleUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new SolidAngle(convertedValue, unit);
+            return new SolidAngle<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public SolidAngle ToUnit(UnitSystem unitSystem)
+        public SolidAngle<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public SolidAngle ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SolidAngleUnit> IQuantity<SolidAngleUnit>.ToUnit(SolidAngleUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<SolidAngleUnit, T> IQuantityT<SolidAngleUnit, T>.ToUnit(SolidAngleUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<SolidAngleUnit> IQuantity<SolidAngleUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<SolidAngleUnit, T> IQuantityT<SolidAngleUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case SolidAngleUnit.Steradian: return _value;
+                case SolidAngleUnit.Steradian: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal SolidAngle ToBaseUnit()
+        internal SolidAngle<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new SolidAngle(baseUnitValue, BaseUnit);
+            return new SolidAngle<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(SolidAngleUnit unit)
+        private T GetValueAs(SolidAngleUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SolidAngle)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SolidAngle<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SolidAngle)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SolidAngle<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SolidAngle)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SolidAngle<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(SolidAngle))
+            if(conversionType == typeof(SolidAngle<T>))
                 return this;
             else if(conversionType == typeof(SolidAngleUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return SolidAngle.QuantityType;
+                return SolidAngle<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return SolidAngle.Info;
+                return SolidAngle<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return SolidAngle.BaseDimensions;
+                return SolidAngle<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(SolidAngle)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(SolidAngle<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
index c48f405406..01876baa4a 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Specific_energy
     /// </remarks>
-    public partial struct SpecificEnergy : IQuantity<SpecificEnergyUnit>, IEquatable<SpecificEnergy>, IComparable, IComparable<SpecificEnergy>, IConvertible, IFormattable
+    public partial struct SpecificEnergy<T> : IQuantityT<SpecificEnergyUnit, T>, IEquatable<SpecificEnergy<T>>, IComparable, IComparable<SpecificEnergy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -90,12 +86,12 @@ static SpecificEnergy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public SpecificEnergy(double value, SpecificEnergyUnit unit)
+        public SpecificEnergy(T value, SpecificEnergyUnit unit)
         {
             if(unit == SpecificEnergyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -107,14 +103,14 @@ public SpecificEnergy(double value, SpecificEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificEnergy(double value, UnitSystem unitSystem)
+        public SpecificEnergy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -129,19 +125,19 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of SpecificEnergy, which is JoulePerKilogram. All conversions go via this value.
+        ///     The base unit of <see cref="SpecificEnergy{T}" />, which is JoulePerKilogram. All conversions go via this value.
         /// </summary>
         public static SpecificEnergyUnit BaseUnit { get; } = SpecificEnergyUnit.JoulePerKilogram;
 
         /// <summary>
-        /// Represents the largest possible value of SpecificEnergy
+        /// Represents the largest possible value of <see cref="SpecificEnergy{T}" />
         /// </summary>
-        public static SpecificEnergy MaxValue { get; } = new SpecificEnergy(double.MaxValue, BaseUnit);
+        public static SpecificEnergy<T> MaxValue { get; } = new SpecificEnergy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of SpecificEnergy
+        /// Represents the smallest possible value of <see cref="SpecificEnergy{T}" />
         /// </summary>
-        public static SpecificEnergy MinValue { get; } = new SpecificEnergy(double.MinValue, BaseUnit);
+        public static SpecificEnergy<T> MinValue { get; } = new SpecificEnergy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -150,14 +146,14 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.SpecificEnergy;
 
         /// <summary>
-        ///     All units of measurement for the SpecificEnergy quantity.
+        ///     All units of measurement for the <see cref="SpecificEnergy{T}" /> quantity.
         /// </summary>
         public static SpecificEnergyUnit[] Units { get; } = Enum.GetValues(typeof(SpecificEnergyUnit)).Cast<SpecificEnergyUnit>().Except(new SpecificEnergyUnit[]{ SpecificEnergyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit JoulePerKilogram.
         /// </summary>
-        public static SpecificEnergy Zero { get; } = new SpecificEnergy(0, BaseUnit);
+        public static SpecificEnergy<T> Zero { get; } = new SpecificEnergy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -166,7 +162,9 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -182,141 +180,141 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => SpecificEnergy.QuantityType;
+        public QuantityType Type => SpecificEnergy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => SpecificEnergy.BaseDimensions;
+        public BaseDimensions Dimensions => SpecificEnergy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get SpecificEnergy in BtuPerPound.
+        ///     Get <see cref="SpecificEnergy{T}" /> in BtuPerPound.
         /// </summary>
-        public double BtuPerPound => As(SpecificEnergyUnit.BtuPerPound);
+        public T BtuPerPound => As(SpecificEnergyUnit.BtuPerPound);
 
         /// <summary>
-        ///     Get SpecificEnergy in CaloriesPerGram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in CaloriesPerGram.
         /// </summary>
-        public double CaloriesPerGram => As(SpecificEnergyUnit.CaloriePerGram);
+        public T CaloriesPerGram => As(SpecificEnergyUnit.CaloriePerGram);
 
         /// <summary>
-        ///     Get SpecificEnergy in GigawattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in GigawattDaysPerKilogram.
         /// </summary>
-        public double GigawattDaysPerKilogram => As(SpecificEnergyUnit.GigawattDayPerKilogram);
+        public T GigawattDaysPerKilogram => As(SpecificEnergyUnit.GigawattDayPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in GigawattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> in GigawattDaysPerShortTon.
         /// </summary>
-        public double GigawattDaysPerShortTon => As(SpecificEnergyUnit.GigawattDayPerShortTon);
+        public T GigawattDaysPerShortTon => As(SpecificEnergyUnit.GigawattDayPerShortTon);
 
         /// <summary>
-        ///     Get SpecificEnergy in GigawattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> in GigawattDaysPerTonne.
         /// </summary>
-        public double GigawattDaysPerTonne => As(SpecificEnergyUnit.GigawattDayPerTonne);
+        public T GigawattDaysPerTonne => As(SpecificEnergyUnit.GigawattDayPerTonne);
 
         /// <summary>
-        ///     Get SpecificEnergy in GigawattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in GigawattHoursPerKilogram.
         /// </summary>
-        public double GigawattHoursPerKilogram => As(SpecificEnergyUnit.GigawattHourPerKilogram);
+        public T GigawattHoursPerKilogram => As(SpecificEnergyUnit.GigawattHourPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in JoulesPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in JoulesPerKilogram.
         /// </summary>
-        public double JoulesPerKilogram => As(SpecificEnergyUnit.JoulePerKilogram);
+        public T JoulesPerKilogram => As(SpecificEnergyUnit.JoulePerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in KilocaloriesPerGram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in KilocaloriesPerGram.
         /// </summary>
-        public double KilocaloriesPerGram => As(SpecificEnergyUnit.KilocaloriePerGram);
+        public T KilocaloriesPerGram => As(SpecificEnergyUnit.KilocaloriePerGram);
 
         /// <summary>
-        ///     Get SpecificEnergy in KilojoulesPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in KilojoulesPerKilogram.
         /// </summary>
-        public double KilojoulesPerKilogram => As(SpecificEnergyUnit.KilojoulePerKilogram);
+        public T KilojoulesPerKilogram => As(SpecificEnergyUnit.KilojoulePerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in KilowattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in KilowattDaysPerKilogram.
         /// </summary>
-        public double KilowattDaysPerKilogram => As(SpecificEnergyUnit.KilowattDayPerKilogram);
+        public T KilowattDaysPerKilogram => As(SpecificEnergyUnit.KilowattDayPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in KilowattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> in KilowattDaysPerShortTon.
         /// </summary>
-        public double KilowattDaysPerShortTon => As(SpecificEnergyUnit.KilowattDayPerShortTon);
+        public T KilowattDaysPerShortTon => As(SpecificEnergyUnit.KilowattDayPerShortTon);
 
         /// <summary>
-        ///     Get SpecificEnergy in KilowattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> in KilowattDaysPerTonne.
         /// </summary>
-        public double KilowattDaysPerTonne => As(SpecificEnergyUnit.KilowattDayPerTonne);
+        public T KilowattDaysPerTonne => As(SpecificEnergyUnit.KilowattDayPerTonne);
 
         /// <summary>
-        ///     Get SpecificEnergy in KilowattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in KilowattHoursPerKilogram.
         /// </summary>
-        public double KilowattHoursPerKilogram => As(SpecificEnergyUnit.KilowattHourPerKilogram);
+        public T KilowattHoursPerKilogram => As(SpecificEnergyUnit.KilowattHourPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in MegajoulesPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in MegajoulesPerKilogram.
         /// </summary>
-        public double MegajoulesPerKilogram => As(SpecificEnergyUnit.MegajoulePerKilogram);
+        public T MegajoulesPerKilogram => As(SpecificEnergyUnit.MegajoulePerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in MegawattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in MegawattDaysPerKilogram.
         /// </summary>
-        public double MegawattDaysPerKilogram => As(SpecificEnergyUnit.MegawattDayPerKilogram);
+        public T MegawattDaysPerKilogram => As(SpecificEnergyUnit.MegawattDayPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in MegawattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> in MegawattDaysPerShortTon.
         /// </summary>
-        public double MegawattDaysPerShortTon => As(SpecificEnergyUnit.MegawattDayPerShortTon);
+        public T MegawattDaysPerShortTon => As(SpecificEnergyUnit.MegawattDayPerShortTon);
 
         /// <summary>
-        ///     Get SpecificEnergy in MegawattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> in MegawattDaysPerTonne.
         /// </summary>
-        public double MegawattDaysPerTonne => As(SpecificEnergyUnit.MegawattDayPerTonne);
+        public T MegawattDaysPerTonne => As(SpecificEnergyUnit.MegawattDayPerTonne);
 
         /// <summary>
-        ///     Get SpecificEnergy in MegawattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in MegawattHoursPerKilogram.
         /// </summary>
-        public double MegawattHoursPerKilogram => As(SpecificEnergyUnit.MegawattHourPerKilogram);
+        public T MegawattHoursPerKilogram => As(SpecificEnergyUnit.MegawattHourPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in TerawattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in TerawattDaysPerKilogram.
         /// </summary>
-        public double TerawattDaysPerKilogram => As(SpecificEnergyUnit.TerawattDayPerKilogram);
+        public T TerawattDaysPerKilogram => As(SpecificEnergyUnit.TerawattDayPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in TerawattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> in TerawattDaysPerShortTon.
         /// </summary>
-        public double TerawattDaysPerShortTon => As(SpecificEnergyUnit.TerawattDayPerShortTon);
+        public T TerawattDaysPerShortTon => As(SpecificEnergyUnit.TerawattDayPerShortTon);
 
         /// <summary>
-        ///     Get SpecificEnergy in TerawattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> in TerawattDaysPerTonne.
         /// </summary>
-        public double TerawattDaysPerTonne => As(SpecificEnergyUnit.TerawattDayPerTonne);
+        public T TerawattDaysPerTonne => As(SpecificEnergyUnit.TerawattDayPerTonne);
 
         /// <summary>
-        ///     Get SpecificEnergy in WattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in WattDaysPerKilogram.
         /// </summary>
-        public double WattDaysPerKilogram => As(SpecificEnergyUnit.WattDayPerKilogram);
+        public T WattDaysPerKilogram => As(SpecificEnergyUnit.WattDayPerKilogram);
 
         /// <summary>
-        ///     Get SpecificEnergy in WattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> in WattDaysPerShortTon.
         /// </summary>
-        public double WattDaysPerShortTon => As(SpecificEnergyUnit.WattDayPerShortTon);
+        public T WattDaysPerShortTon => As(SpecificEnergyUnit.WattDayPerShortTon);
 
         /// <summary>
-        ///     Get SpecificEnergy in WattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> in WattDaysPerTonne.
         /// </summary>
-        public double WattDaysPerTonne => As(SpecificEnergyUnit.WattDayPerTonne);
+        public T WattDaysPerTonne => As(SpecificEnergyUnit.WattDayPerTonne);
 
         /// <summary>
-        ///     Get SpecificEnergy in WattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> in WattHoursPerKilogram.
         /// </summary>
-        public double WattHoursPerKilogram => As(SpecificEnergyUnit.WattHourPerKilogram);
+        public T WattHoursPerKilogram => As(SpecificEnergyUnit.WattHourPerKilogram);
 
         #endregion
 
@@ -348,240 +346,215 @@ public static string GetAbbreviation(SpecificEnergyUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get SpecificEnergy from BtuPerPound.
+        ///     Get <see cref="SpecificEnergy{T}" /> from BtuPerPound.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromBtuPerPound(QuantityValue btuperpound)
+        public static SpecificEnergy<T> FromBtuPerPound(T btuperpound)
         {
-            double value = (double) btuperpound;
-            return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound);
+            return new SpecificEnergy<T>(btuperpound, SpecificEnergyUnit.BtuPerPound);
         }
         /// <summary>
-        ///     Get SpecificEnergy from CaloriesPerGram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from CaloriesPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromCaloriesPerGram(QuantityValue caloriespergram)
+        public static SpecificEnergy<T> FromCaloriesPerGram(T caloriespergram)
         {
-            double value = (double) caloriespergram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram);
+            return new SpecificEnergy<T>(caloriespergram, SpecificEnergyUnit.CaloriePerGram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from GigawattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from GigawattDaysPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerKilogram(QuantityValue gigawattdaysperkilogram)
+        public static SpecificEnergy<T> FromGigawattDaysPerKilogram(T gigawattdaysperkilogram)
         {
-            double value = (double) gigawattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram);
+            return new SpecificEnergy<T>(gigawattdaysperkilogram, SpecificEnergyUnit.GigawattDayPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from GigawattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> from GigawattDaysPerShortTon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerShortTon(QuantityValue gigawattdayspershortton)
+        public static SpecificEnergy<T> FromGigawattDaysPerShortTon(T gigawattdayspershortton)
         {
-            double value = (double) gigawattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon);
+            return new SpecificEnergy<T>(gigawattdayspershortton, SpecificEnergyUnit.GigawattDayPerShortTon);
         }
         /// <summary>
-        ///     Get SpecificEnergy from GigawattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> from GigawattDaysPerTonne.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerTonne(QuantityValue gigawattdayspertonne)
+        public static SpecificEnergy<T> FromGigawattDaysPerTonne(T gigawattdayspertonne)
         {
-            double value = (double) gigawattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne);
+            return new SpecificEnergy<T>(gigawattdayspertonne, SpecificEnergyUnit.GigawattDayPerTonne);
         }
         /// <summary>
-        ///     Get SpecificEnergy from GigawattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from GigawattHoursPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattHoursPerKilogram(QuantityValue gigawatthoursperkilogram)
+        public static SpecificEnergy<T> FromGigawattHoursPerKilogram(T gigawatthoursperkilogram)
         {
-            double value = (double) gigawatthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram);
+            return new SpecificEnergy<T>(gigawatthoursperkilogram, SpecificEnergyUnit.GigawattHourPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from JoulesPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from JoulesPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromJoulesPerKilogram(QuantityValue joulesperkilogram)
+        public static SpecificEnergy<T> FromJoulesPerKilogram(T joulesperkilogram)
         {
-            double value = (double) joulesperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram);
+            return new SpecificEnergy<T>(joulesperkilogram, SpecificEnergyUnit.JoulePerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from KilocaloriesPerGram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from KilocaloriesPerGram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilocaloriesPerGram(QuantityValue kilocaloriespergram)
+        public static SpecificEnergy<T> FromKilocaloriesPerGram(T kilocaloriespergram)
         {
-            double value = (double) kilocaloriespergram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram);
+            return new SpecificEnergy<T>(kilocaloriespergram, SpecificEnergyUnit.KilocaloriePerGram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from KilojoulesPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from KilojoulesPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilojoulesPerKilogram(QuantityValue kilojoulesperkilogram)
+        public static SpecificEnergy<T> FromKilojoulesPerKilogram(T kilojoulesperkilogram)
         {
-            double value = (double) kilojoulesperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram);
+            return new SpecificEnergy<T>(kilojoulesperkilogram, SpecificEnergyUnit.KilojoulePerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from KilowattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from KilowattDaysPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerKilogram(QuantityValue kilowattdaysperkilogram)
+        public static SpecificEnergy<T> FromKilowattDaysPerKilogram(T kilowattdaysperkilogram)
         {
-            double value = (double) kilowattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram);
+            return new SpecificEnergy<T>(kilowattdaysperkilogram, SpecificEnergyUnit.KilowattDayPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from KilowattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> from KilowattDaysPerShortTon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerShortTon(QuantityValue kilowattdayspershortton)
+        public static SpecificEnergy<T> FromKilowattDaysPerShortTon(T kilowattdayspershortton)
         {
-            double value = (double) kilowattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon);
+            return new SpecificEnergy<T>(kilowattdayspershortton, SpecificEnergyUnit.KilowattDayPerShortTon);
         }
         /// <summary>
-        ///     Get SpecificEnergy from KilowattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> from KilowattDaysPerTonne.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerTonne(QuantityValue kilowattdayspertonne)
+        public static SpecificEnergy<T> FromKilowattDaysPerTonne(T kilowattdayspertonne)
         {
-            double value = (double) kilowattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne);
+            return new SpecificEnergy<T>(kilowattdayspertonne, SpecificEnergyUnit.KilowattDayPerTonne);
         }
         /// <summary>
-        ///     Get SpecificEnergy from KilowattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from KilowattHoursPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattHoursPerKilogram(QuantityValue kilowatthoursperkilogram)
+        public static SpecificEnergy<T> FromKilowattHoursPerKilogram(T kilowatthoursperkilogram)
         {
-            double value = (double) kilowatthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram);
+            return new SpecificEnergy<T>(kilowatthoursperkilogram, SpecificEnergyUnit.KilowattHourPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from MegajoulesPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from MegajoulesPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegajoulesPerKilogram(QuantityValue megajoulesperkilogram)
+        public static SpecificEnergy<T> FromMegajoulesPerKilogram(T megajoulesperkilogram)
         {
-            double value = (double) megajoulesperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram);
+            return new SpecificEnergy<T>(megajoulesperkilogram, SpecificEnergyUnit.MegajoulePerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from MegawattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from MegawattDaysPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerKilogram(QuantityValue megawattdaysperkilogram)
+        public static SpecificEnergy<T> FromMegawattDaysPerKilogram(T megawattdaysperkilogram)
         {
-            double value = (double) megawattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram);
+            return new SpecificEnergy<T>(megawattdaysperkilogram, SpecificEnergyUnit.MegawattDayPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from MegawattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> from MegawattDaysPerShortTon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerShortTon(QuantityValue megawattdayspershortton)
+        public static SpecificEnergy<T> FromMegawattDaysPerShortTon(T megawattdayspershortton)
         {
-            double value = (double) megawattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon);
+            return new SpecificEnergy<T>(megawattdayspershortton, SpecificEnergyUnit.MegawattDayPerShortTon);
         }
         /// <summary>
-        ///     Get SpecificEnergy from MegawattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> from MegawattDaysPerTonne.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerTonne(QuantityValue megawattdayspertonne)
+        public static SpecificEnergy<T> FromMegawattDaysPerTonne(T megawattdayspertonne)
         {
-            double value = (double) megawattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne);
+            return new SpecificEnergy<T>(megawattdayspertonne, SpecificEnergyUnit.MegawattDayPerTonne);
         }
         /// <summary>
-        ///     Get SpecificEnergy from MegawattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from MegawattHoursPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattHoursPerKilogram(QuantityValue megawatthoursperkilogram)
+        public static SpecificEnergy<T> FromMegawattHoursPerKilogram(T megawatthoursperkilogram)
         {
-            double value = (double) megawatthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram);
+            return new SpecificEnergy<T>(megawatthoursperkilogram, SpecificEnergyUnit.MegawattHourPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from TerawattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from TerawattDaysPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerKilogram(QuantityValue terawattdaysperkilogram)
+        public static SpecificEnergy<T> FromTerawattDaysPerKilogram(T terawattdaysperkilogram)
         {
-            double value = (double) terawattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram);
+            return new SpecificEnergy<T>(terawattdaysperkilogram, SpecificEnergyUnit.TerawattDayPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from TerawattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> from TerawattDaysPerShortTon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerShortTon(QuantityValue terawattdayspershortton)
+        public static SpecificEnergy<T> FromTerawattDaysPerShortTon(T terawattdayspershortton)
         {
-            double value = (double) terawattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon);
+            return new SpecificEnergy<T>(terawattdayspershortton, SpecificEnergyUnit.TerawattDayPerShortTon);
         }
         /// <summary>
-        ///     Get SpecificEnergy from TerawattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> from TerawattDaysPerTonne.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerTonne(QuantityValue terawattdayspertonne)
+        public static SpecificEnergy<T> FromTerawattDaysPerTonne(T terawattdayspertonne)
         {
-            double value = (double) terawattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne);
+            return new SpecificEnergy<T>(terawattdayspertonne, SpecificEnergyUnit.TerawattDayPerTonne);
         }
         /// <summary>
-        ///     Get SpecificEnergy from WattDaysPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from WattDaysPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerKilogram(QuantityValue wattdaysperkilogram)
+        public static SpecificEnergy<T> FromWattDaysPerKilogram(T wattdaysperkilogram)
         {
-            double value = (double) wattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram);
+            return new SpecificEnergy<T>(wattdaysperkilogram, SpecificEnergyUnit.WattDayPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificEnergy from WattDaysPerShortTon.
+        ///     Get <see cref="SpecificEnergy{T}" /> from WattDaysPerShortTon.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerShortTon(QuantityValue wattdayspershortton)
+        public static SpecificEnergy<T> FromWattDaysPerShortTon(T wattdayspershortton)
         {
-            double value = (double) wattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon);
+            return new SpecificEnergy<T>(wattdayspershortton, SpecificEnergyUnit.WattDayPerShortTon);
         }
         /// <summary>
-        ///     Get SpecificEnergy from WattDaysPerTonne.
+        ///     Get <see cref="SpecificEnergy{T}" /> from WattDaysPerTonne.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerTonne(QuantityValue wattdayspertonne)
+        public static SpecificEnergy<T> FromWattDaysPerTonne(T wattdayspertonne)
         {
-            double value = (double) wattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne);
+            return new SpecificEnergy<T>(wattdayspertonne, SpecificEnergyUnit.WattDayPerTonne);
         }
         /// <summary>
-        ///     Get SpecificEnergy from WattHoursPerKilogram.
+        ///     Get <see cref="SpecificEnergy{T}" /> from WattHoursPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattHoursPerKilogram(QuantityValue watthoursperkilogram)
+        public static SpecificEnergy<T> FromWattHoursPerKilogram(T watthoursperkilogram)
         {
-            double value = (double) watthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram);
+            return new SpecificEnergy<T>(watthoursperkilogram, SpecificEnergyUnit.WattHourPerKilogram);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificEnergyUnit" /> to <see cref="SpecificEnergy" />.
+        ///     Dynamically convert from value and unit enum <see cref="SpecificEnergyUnit" /> to <see cref="SpecificEnergy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificEnergy unit value.</returns>
-        public static SpecificEnergy From(QuantityValue value, SpecificEnergyUnit fromUnit)
+        /// <returns><see cref="SpecificEnergy{T}" /> unit value.</returns>
+        public static SpecificEnergy<T> From(T value, SpecificEnergyUnit fromUnit)
         {
-            return new SpecificEnergy((double)value, fromUnit);
+            return new SpecificEnergy<T>(value, fromUnit);
         }
 
         #endregion
@@ -610,7 +583,7 @@ public static SpecificEnergy From(QuantityValue value, SpecificEnergyUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static SpecificEnergy Parse(string str)
+        public static SpecificEnergy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -638,9 +611,9 @@ public static SpecificEnergy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static SpecificEnergy Parse(string str, IFormatProvider? provider)
+        public static SpecificEnergy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<SpecificEnergy, SpecificEnergyUnit>(
+            return QuantityParser.Default.Parse<T, SpecificEnergy<T>, SpecificEnergyUnit>(
                 str,
                 provider,
                 From);
@@ -654,7 +627,7 @@ public static SpecificEnergy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out SpecificEnergy result)
+        public static bool TryParse(string? str, out SpecificEnergy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -669,9 +642,9 @@ public static bool TryParse(string? str, out SpecificEnergy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificEnergy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificEnergy<T> result)
         {
-            return QuantityParser.Default.TryParse<SpecificEnergy, SpecificEnergyUnit>(
+            return QuantityParser.Default.TryParse<T, SpecificEnergy<T>, SpecificEnergyUnit>(
                 str,
                 provider,
                 From,
@@ -733,45 +706,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static SpecificEnergy operator -(SpecificEnergy right)
+        public static SpecificEnergy<T> operator -(SpecificEnergy<T> right)
         {
-            return new SpecificEnergy(-right.Value, right.Unit);
+            return new SpecificEnergy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from adding two <see cref="SpecificEnergy"/>.</summary>
-        public static SpecificEnergy operator +(SpecificEnergy left, SpecificEnergy right)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from adding two <see cref="SpecificEnergy{T}"/>.</summary>
+        public static SpecificEnergy<T> operator +(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
-            return new SpecificEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from subtracting two <see cref="SpecificEnergy"/>.</summary>
-        public static SpecificEnergy operator -(SpecificEnergy left, SpecificEnergy right)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from subtracting two <see cref="SpecificEnergy{T}"/>.</summary>
+        public static SpecificEnergy<T> operator -(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
-            return new SpecificEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from multiplying value and <see cref="SpecificEnergy"/>.</summary>
-        public static SpecificEnergy operator *(double left, SpecificEnergy right)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from multiplying value and <see cref="SpecificEnergy{T}"/>.</summary>
+        public static SpecificEnergy<T> operator *(T left, SpecificEnergy<T> right)
         {
-            return new SpecificEnergy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new SpecificEnergy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from multiplying value and <see cref="SpecificEnergy"/>.</summary>
-        public static SpecificEnergy operator *(SpecificEnergy left, double right)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from multiplying value and <see cref="SpecificEnergy{T}"/>.</summary>
+        public static SpecificEnergy<T> operator *(SpecificEnergy<T> left, T right)
         {
-            return new SpecificEnergy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new SpecificEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from dividing <see cref="SpecificEnergy"/> by value.</summary>
-        public static SpecificEnergy operator /(SpecificEnergy left, double right)
+        /// <summary>Get <see cref="SpecificEnergy{T}"/> from dividing <see cref="SpecificEnergy{T}"/> by value.</summary>
+        public static SpecificEnergy<T> operator /(SpecificEnergy<T> left, T right)
         {
-            return new SpecificEnergy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new SpecificEnergy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="SpecificEnergy"/> by <see cref="SpecificEnergy"/>.</summary>
-        public static double operator /(SpecificEnergy left, SpecificEnergy right)
+        /// <summary>Get ratio value from dividing <see cref="SpecificEnergy{T}"/> by <see cref="SpecificEnergy{T}"/>.</summary>
+        public static T operator /(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
-            return left.JoulesPerKilogram / right.JoulesPerKilogram;
+            return CompiledLambdas.Divide(left.JoulesPerKilogram, right.JoulesPerKilogram);
         }
 
         #endregion
@@ -779,39 +757,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(SpecificEnergy left, SpecificEnergy right)
+        public static bool operator <=(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(SpecificEnergy left, SpecificEnergy right)
+        public static bool operator >=(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(SpecificEnergy left, SpecificEnergy right)
+        public static bool operator <(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(SpecificEnergy left, SpecificEnergy right)
+        public static bool operator >(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(SpecificEnergy left, SpecificEnergy right)
+        /// <remarks>Consider using <see cref="Equals(SpecificEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(SpecificEnergy left, SpecificEnergy right)
+        /// <remarks>Consider using <see cref="Equals(SpecificEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(SpecificEnergy<T> left, SpecificEnergy<T> right)
         {
             return !(left == right);
         }
@@ -820,37 +798,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is SpecificEnergy objSpecificEnergy)) throw new ArgumentException("Expected type SpecificEnergy.", nameof(obj));
+            if(!(obj is SpecificEnergy<T> objSpecificEnergy)) throw new ArgumentException("Expected type SpecificEnergy.", nameof(obj));
 
             return CompareTo(objSpecificEnergy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(SpecificEnergy other)
+        public int CompareTo(SpecificEnergy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(SpecificEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is SpecificEnergy objSpecificEnergy))
+            if(obj is null || !(obj is SpecificEnergy<T> objSpecificEnergy))
                 return false;
 
             return Equals(objSpecificEnergy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificEnergy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(SpecificEnergy other)
+        /// <remarks>Consider using <see cref="Equals(SpecificEnergy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(SpecificEnergy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another SpecificEnergy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="SpecificEnergy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -888,21 +866,19 @@ public bool Equals(SpecificEnergy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(SpecificEnergy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(SpecificEnergy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current SpecificEnergy.</returns>
+        /// <returns>A hash code for the current <see cref="SpecificEnergy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -916,17 +892,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificEnergyUnit unit)
+        public T As(SpecificEnergyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -946,17 +922,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is SpecificEnergyUnit unitAsSpecificEnergyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEnergyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsSpecificEnergyUnit);
+            var asValue = As(unitAsSpecificEnergyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<SpecificEnergyUnit>.As(SpecificEnergyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this SpecificEnergy to another SpecificEnergy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="SpecificEnergy{T}" /> to another <see cref="SpecificEnergy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A SpecificEnergy with the specified unit.</returns>
-        public SpecificEnergy ToUnit(SpecificEnergyUnit unit)
+        /// <returns>A <see cref="SpecificEnergy{T}" /> with the specified unit.</returns>
+        public SpecificEnergy<T> ToUnit(SpecificEnergyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new SpecificEnergy(convertedValue, unit);
+            return new SpecificEnergy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -969,7 +950,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public SpecificEnergy ToUnit(UnitSystem unitSystem)
+        public SpecificEnergy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -989,43 +970,49 @@ public SpecificEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificEnergyUnit> IQuantity<SpecificEnergyUnit>.ToUnit(SpecificEnergyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificEnergyUnit, T> IQuantityT<SpecificEnergyUnit, T>.ToUnit(SpecificEnergyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<SpecificEnergyUnit> IQuantity<SpecificEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificEnergyUnit, T> IQuantityT<SpecificEnergyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case SpecificEnergyUnit.BtuPerPound: return _value*2326.000075362;
-                case SpecificEnergyUnit.CaloriePerGram: return _value*4.184e3;
-                case SpecificEnergyUnit.GigawattDayPerKilogram: return (_value*(24*3.6e3)) * 1e9d;
-                case SpecificEnergyUnit.GigawattDayPerShortTon: return (_value*((24*3.6e3)/9.0718474e2)) * 1e9d;
-                case SpecificEnergyUnit.GigawattDayPerTonne: return (_value*((24*3.6e3)/1e3)) * 1e9d;
-                case SpecificEnergyUnit.GigawattHourPerKilogram: return (_value*3.6e3) * 1e9d;
-                case SpecificEnergyUnit.JoulePerKilogram: return _value;
-                case SpecificEnergyUnit.KilocaloriePerGram: return (_value*4.184e3) * 1e3d;
-                case SpecificEnergyUnit.KilojoulePerKilogram: return (_value) * 1e3d;
-                case SpecificEnergyUnit.KilowattDayPerKilogram: return (_value*(24*3.6e3)) * 1e3d;
-                case SpecificEnergyUnit.KilowattDayPerShortTon: return (_value*((24*3.6e3)/9.0718474e2)) * 1e3d;
-                case SpecificEnergyUnit.KilowattDayPerTonne: return (_value*((24*3.6e3)/1e3)) * 1e3d;
-                case SpecificEnergyUnit.KilowattHourPerKilogram: return (_value*3.6e3) * 1e3d;
-                case SpecificEnergyUnit.MegajoulePerKilogram: return (_value) * 1e6d;
-                case SpecificEnergyUnit.MegawattDayPerKilogram: return (_value*(24*3.6e3)) * 1e6d;
-                case SpecificEnergyUnit.MegawattDayPerShortTon: return (_value*((24*3.6e3)/9.0718474e2)) * 1e6d;
-                case SpecificEnergyUnit.MegawattDayPerTonne: return (_value*((24*3.6e3)/1e3)) * 1e6d;
-                case SpecificEnergyUnit.MegawattHourPerKilogram: return (_value*3.6e3) * 1e6d;
-                case SpecificEnergyUnit.TerawattDayPerKilogram: return (_value*(24*3.6e3)) * 1e12d;
-                case SpecificEnergyUnit.TerawattDayPerShortTon: return (_value*((24*3.6e3)/9.0718474e2)) * 1e12d;
-                case SpecificEnergyUnit.TerawattDayPerTonne: return (_value*((24*3.6e3)/1e3)) * 1e12d;
-                case SpecificEnergyUnit.WattDayPerKilogram: return _value*(24*3.6e3);
-                case SpecificEnergyUnit.WattDayPerShortTon: return _value*((24*3.6e3)/9.0718474e2);
-                case SpecificEnergyUnit.WattDayPerTonne: return _value*((24*3.6e3)/1e3);
-                case SpecificEnergyUnit.WattHourPerKilogram: return _value*3.6e3;
+                case SpecificEnergyUnit.BtuPerPound: return Value*2326.000075362;
+                case SpecificEnergyUnit.CaloriePerGram: return Value*4.184e3;
+                case SpecificEnergyUnit.GigawattDayPerKilogram: return (Value*(24*3.6e3)) * 1e9d;
+                case SpecificEnergyUnit.GigawattDayPerShortTon: return (Value*((24*3.6e3)/9.0718474e2)) * 1e9d;
+                case SpecificEnergyUnit.GigawattDayPerTonne: return (Value*((24*3.6e3)/1e3)) * 1e9d;
+                case SpecificEnergyUnit.GigawattHourPerKilogram: return (Value*3.6e3) * 1e9d;
+                case SpecificEnergyUnit.JoulePerKilogram: return Value;
+                case SpecificEnergyUnit.KilocaloriePerGram: return (Value*4.184e3) * 1e3d;
+                case SpecificEnergyUnit.KilojoulePerKilogram: return (Value) * 1e3d;
+                case SpecificEnergyUnit.KilowattDayPerKilogram: return (Value*(24*3.6e3)) * 1e3d;
+                case SpecificEnergyUnit.KilowattDayPerShortTon: return (Value*((24*3.6e3)/9.0718474e2)) * 1e3d;
+                case SpecificEnergyUnit.KilowattDayPerTonne: return (Value*((24*3.6e3)/1e3)) * 1e3d;
+                case SpecificEnergyUnit.KilowattHourPerKilogram: return (Value*3.6e3) * 1e3d;
+                case SpecificEnergyUnit.MegajoulePerKilogram: return (Value) * 1e6d;
+                case SpecificEnergyUnit.MegawattDayPerKilogram: return (Value*(24*3.6e3)) * 1e6d;
+                case SpecificEnergyUnit.MegawattDayPerShortTon: return (Value*((24*3.6e3)/9.0718474e2)) * 1e6d;
+                case SpecificEnergyUnit.MegawattDayPerTonne: return (Value*((24*3.6e3)/1e3)) * 1e6d;
+                case SpecificEnergyUnit.MegawattHourPerKilogram: return (Value*3.6e3) * 1e6d;
+                case SpecificEnergyUnit.TerawattDayPerKilogram: return (Value*(24*3.6e3)) * 1e12d;
+                case SpecificEnergyUnit.TerawattDayPerShortTon: return (Value*((24*3.6e3)/9.0718474e2)) * 1e12d;
+                case SpecificEnergyUnit.TerawattDayPerTonne: return (Value*((24*3.6e3)/1e3)) * 1e12d;
+                case SpecificEnergyUnit.WattDayPerKilogram: return Value*(24*3.6e3);
+                case SpecificEnergyUnit.WattDayPerShortTon: return Value*((24*3.6e3)/9.0718474e2);
+                case SpecificEnergyUnit.WattDayPerTonne: return Value*((24*3.6e3)/1e3);
+                case SpecificEnergyUnit.WattHourPerKilogram: return Value*3.6e3;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1036,16 +1023,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal SpecificEnergy ToBaseUnit()
+        internal SpecificEnergy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new SpecificEnergy(baseUnitValue, BaseUnit);
+            return new SpecificEnergy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(SpecificEnergyUnit unit)
+        private T GetValueAs(SpecificEnergyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1172,57 +1159,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificEnergy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificEnergy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificEnergy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificEnergy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificEnergy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificEnergy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1232,33 +1219,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(SpecificEnergy))
+            if(conversionType == typeof(SpecificEnergy<T>))
                 return this;
             else if(conversionType == typeof(SpecificEnergyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return SpecificEnergy.QuantityType;
+                return SpecificEnergy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return SpecificEnergy.Info;
+                return SpecificEnergy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return SpecificEnergy.BaseDimensions;
+                return SpecificEnergy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(SpecificEnergy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(SpecificEnergy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
index 446b443485..21977f9260 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Specific entropy is an amount of energy required to raise temperature of a substance by 1 Kelvin per unit mass.
     /// </summary>
-    public partial struct SpecificEntropy : IQuantity<SpecificEntropyUnit>, IEquatable<SpecificEntropy>, IComparable, IComparable<SpecificEntropy>, IConvertible, IFormattable
+    public partial struct SpecificEntropy<T> : IQuantityT<SpecificEntropyUnit, T>, IEquatable<SpecificEntropy<T>>, IComparable, IComparable<SpecificEntropy<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -71,12 +67,12 @@ static SpecificEntropy()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public SpecificEntropy(double value, SpecificEntropyUnit unit)
+        public SpecificEntropy(T value, SpecificEntropyUnit unit)
         {
             if(unit == SpecificEntropyUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -88,14 +84,14 @@ public SpecificEntropy(double value, SpecificEntropyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificEntropy(double value, UnitSystem unitSystem)
+        public SpecificEntropy(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -110,19 +106,19 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of SpecificEntropy, which is JoulePerKilogramKelvin. All conversions go via this value.
+        ///     The base unit of <see cref="SpecificEntropy{T}" />, which is JoulePerKilogramKelvin. All conversions go via this value.
         /// </summary>
         public static SpecificEntropyUnit BaseUnit { get; } = SpecificEntropyUnit.JoulePerKilogramKelvin;
 
         /// <summary>
-        /// Represents the largest possible value of SpecificEntropy
+        /// Represents the largest possible value of <see cref="SpecificEntropy{T}" />
         /// </summary>
-        public static SpecificEntropy MaxValue { get; } = new SpecificEntropy(double.MaxValue, BaseUnit);
+        public static SpecificEntropy<T> MaxValue { get; } = new SpecificEntropy<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of SpecificEntropy
+        /// Represents the smallest possible value of <see cref="SpecificEntropy{T}" />
         /// </summary>
-        public static SpecificEntropy MinValue { get; } = new SpecificEntropy(double.MinValue, BaseUnit);
+        public static SpecificEntropy<T> MinValue { get; } = new SpecificEntropy<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -131,14 +127,14 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.SpecificEntropy;
 
         /// <summary>
-        ///     All units of measurement for the SpecificEntropy quantity.
+        ///     All units of measurement for the <see cref="SpecificEntropy{T}" /> quantity.
         /// </summary>
         public static SpecificEntropyUnit[] Units { get; } = Enum.GetValues(typeof(SpecificEntropyUnit)).Cast<SpecificEntropyUnit>().Except(new SpecificEntropyUnit[]{ SpecificEntropyUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit JoulePerKilogramKelvin.
         /// </summary>
-        public static SpecificEntropy Zero { get; } = new SpecificEntropy(0, BaseUnit);
+        public static SpecificEntropy<T> Zero { get; } = new SpecificEntropy<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -147,7 +143,9 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -163,61 +161,61 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => SpecificEntropy.QuantityType;
+        public QuantityType Type => SpecificEntropy<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => SpecificEntropy.BaseDimensions;
+        public BaseDimensions Dimensions => SpecificEntropy<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get SpecificEntropy in BtusPerPoundFahrenheit.
+        ///     Get <see cref="SpecificEntropy{T}" /> in BtusPerPoundFahrenheit.
         /// </summary>
-        public double BtusPerPoundFahrenheit => As(SpecificEntropyUnit.BtuPerPoundFahrenheit);
+        public T BtusPerPoundFahrenheit => As(SpecificEntropyUnit.BtuPerPoundFahrenheit);
 
         /// <summary>
-        ///     Get SpecificEntropy in CaloriesPerGramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> in CaloriesPerGramKelvin.
         /// </summary>
-        public double CaloriesPerGramKelvin => As(SpecificEntropyUnit.CaloriePerGramKelvin);
+        public T CaloriesPerGramKelvin => As(SpecificEntropyUnit.CaloriePerGramKelvin);
 
         /// <summary>
-        ///     Get SpecificEntropy in JoulesPerKilogramDegreeCelsius.
+        ///     Get <see cref="SpecificEntropy{T}" /> in JoulesPerKilogramDegreeCelsius.
         /// </summary>
-        public double JoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
+        public T JoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
 
         /// <summary>
-        ///     Get SpecificEntropy in JoulesPerKilogramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> in JoulesPerKilogramKelvin.
         /// </summary>
-        public double JoulesPerKilogramKelvin => As(SpecificEntropyUnit.JoulePerKilogramKelvin);
+        public T JoulesPerKilogramKelvin => As(SpecificEntropyUnit.JoulePerKilogramKelvin);
 
         /// <summary>
-        ///     Get SpecificEntropy in KilocaloriesPerGramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> in KilocaloriesPerGramKelvin.
         /// </summary>
-        public double KilocaloriesPerGramKelvin => As(SpecificEntropyUnit.KilocaloriePerGramKelvin);
+        public T KilocaloriesPerGramKelvin => As(SpecificEntropyUnit.KilocaloriePerGramKelvin);
 
         /// <summary>
-        ///     Get SpecificEntropy in KilojoulesPerKilogramDegreeCelsius.
+        ///     Get <see cref="SpecificEntropy{T}" /> in KilojoulesPerKilogramDegreeCelsius.
         /// </summary>
-        public double KilojoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
+        public T KilojoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
 
         /// <summary>
-        ///     Get SpecificEntropy in KilojoulesPerKilogramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> in KilojoulesPerKilogramKelvin.
         /// </summary>
-        public double KilojoulesPerKilogramKelvin => As(SpecificEntropyUnit.KilojoulePerKilogramKelvin);
+        public T KilojoulesPerKilogramKelvin => As(SpecificEntropyUnit.KilojoulePerKilogramKelvin);
 
         /// <summary>
-        ///     Get SpecificEntropy in MegajoulesPerKilogramDegreeCelsius.
+        ///     Get <see cref="SpecificEntropy{T}" /> in MegajoulesPerKilogramDegreeCelsius.
         /// </summary>
-        public double MegajoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
+        public T MegajoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
 
         /// <summary>
-        ///     Get SpecificEntropy in MegajoulesPerKilogramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> in MegajoulesPerKilogramKelvin.
         /// </summary>
-        public double MegajoulesPerKilogramKelvin => As(SpecificEntropyUnit.MegajoulePerKilogramKelvin);
+        public T MegajoulesPerKilogramKelvin => As(SpecificEntropyUnit.MegajoulePerKilogramKelvin);
 
         #endregion
 
@@ -249,96 +247,87 @@ public static string GetAbbreviation(SpecificEntropyUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get SpecificEntropy from BtusPerPoundFahrenheit.
+        ///     Get <see cref="SpecificEntropy{T}" /> from BtusPerPoundFahrenheit.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromBtusPerPoundFahrenheit(QuantityValue btusperpoundfahrenheit)
+        public static SpecificEntropy<T> FromBtusPerPoundFahrenheit(T btusperpoundfahrenheit)
         {
-            double value = (double) btusperpoundfahrenheit;
-            return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit);
+            return new SpecificEntropy<T>(btusperpoundfahrenheit, SpecificEntropyUnit.BtuPerPoundFahrenheit);
         }
         /// <summary>
-        ///     Get SpecificEntropy from CaloriesPerGramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> from CaloriesPerGramKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromCaloriesPerGramKelvin(QuantityValue caloriespergramkelvin)
+        public static SpecificEntropy<T> FromCaloriesPerGramKelvin(T caloriespergramkelvin)
         {
-            double value = (double) caloriespergramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin);
+            return new SpecificEntropy<T>(caloriespergramkelvin, SpecificEntropyUnit.CaloriePerGramKelvin);
         }
         /// <summary>
-        ///     Get SpecificEntropy from JoulesPerKilogramDegreeCelsius.
+        ///     Get <see cref="SpecificEntropy{T}" /> from JoulesPerKilogramDegreeCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(QuantityValue joulesperkilogramdegreecelsius)
+        public static SpecificEntropy<T> FromJoulesPerKilogramDegreeCelsius(T joulesperkilogramdegreecelsius)
         {
-            double value = (double) joulesperkilogramdegreecelsius;
-            return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy<T>(joulesperkilogramdegreecelsius, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
         }
         /// <summary>
-        ///     Get SpecificEntropy from JoulesPerKilogramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> from JoulesPerKilogramKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromJoulesPerKilogramKelvin(QuantityValue joulesperkilogramkelvin)
+        public static SpecificEntropy<T> FromJoulesPerKilogramKelvin(T joulesperkilogramkelvin)
         {
-            double value = (double) joulesperkilogramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin);
+            return new SpecificEntropy<T>(joulesperkilogramkelvin, SpecificEntropyUnit.JoulePerKilogramKelvin);
         }
         /// <summary>
-        ///     Get SpecificEntropy from KilocaloriesPerGramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> from KilocaloriesPerGramKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilocaloriesPerGramKelvin(QuantityValue kilocaloriespergramkelvin)
+        public static SpecificEntropy<T> FromKilocaloriesPerGramKelvin(T kilocaloriespergramkelvin)
         {
-            double value = (double) kilocaloriespergramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin);
+            return new SpecificEntropy<T>(kilocaloriespergramkelvin, SpecificEntropyUnit.KilocaloriePerGramKelvin);
         }
         /// <summary>
-        ///     Get SpecificEntropy from KilojoulesPerKilogramDegreeCelsius.
+        ///     Get <see cref="SpecificEntropy{T}" /> from KilojoulesPerKilogramDegreeCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(QuantityValue kilojoulesperkilogramdegreecelsius)
+        public static SpecificEntropy<T> FromKilojoulesPerKilogramDegreeCelsius(T kilojoulesperkilogramdegreecelsius)
         {
-            double value = (double) kilojoulesperkilogramdegreecelsius;
-            return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy<T>(kilojoulesperkilogramdegreecelsius, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
         }
         /// <summary>
-        ///     Get SpecificEntropy from KilojoulesPerKilogramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> from KilojoulesPerKilogramKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(QuantityValue kilojoulesperkilogramkelvin)
+        public static SpecificEntropy<T> FromKilojoulesPerKilogramKelvin(T kilojoulesperkilogramkelvin)
         {
-            double value = (double) kilojoulesperkilogramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
+            return new SpecificEntropy<T>(kilojoulesperkilogramkelvin, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
         }
         /// <summary>
-        ///     Get SpecificEntropy from MegajoulesPerKilogramDegreeCelsius.
+        ///     Get <see cref="SpecificEntropy{T}" /> from MegajoulesPerKilogramDegreeCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(QuantityValue megajoulesperkilogramdegreecelsius)
+        public static SpecificEntropy<T> FromMegajoulesPerKilogramDegreeCelsius(T megajoulesperkilogramdegreecelsius)
         {
-            double value = (double) megajoulesperkilogramdegreecelsius;
-            return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy<T>(megajoulesperkilogramdegreecelsius, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
         }
         /// <summary>
-        ///     Get SpecificEntropy from MegajoulesPerKilogramKelvin.
+        ///     Get <see cref="SpecificEntropy{T}" /> from MegajoulesPerKilogramKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(QuantityValue megajoulesperkilogramkelvin)
+        public static SpecificEntropy<T> FromMegajoulesPerKilogramKelvin(T megajoulesperkilogramkelvin)
         {
-            double value = (double) megajoulesperkilogramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
+            return new SpecificEntropy<T>(megajoulesperkilogramkelvin, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificEntropyUnit" /> to <see cref="SpecificEntropy" />.
+        ///     Dynamically convert from value and unit enum <see cref="SpecificEntropyUnit" /> to <see cref="SpecificEntropy{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificEntropy unit value.</returns>
-        public static SpecificEntropy From(QuantityValue value, SpecificEntropyUnit fromUnit)
+        /// <returns><see cref="SpecificEntropy{T}" /> unit value.</returns>
+        public static SpecificEntropy<T> From(T value, SpecificEntropyUnit fromUnit)
         {
-            return new SpecificEntropy((double)value, fromUnit);
+            return new SpecificEntropy<T>(value, fromUnit);
         }
 
         #endregion
@@ -367,7 +356,7 @@ public static SpecificEntropy From(QuantityValue value, SpecificEntropyUnit from
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static SpecificEntropy Parse(string str)
+        public static SpecificEntropy<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -395,9 +384,9 @@ public static SpecificEntropy Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static SpecificEntropy Parse(string str, IFormatProvider? provider)
+        public static SpecificEntropy<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<SpecificEntropy, SpecificEntropyUnit>(
+            return QuantityParser.Default.Parse<T, SpecificEntropy<T>, SpecificEntropyUnit>(
                 str,
                 provider,
                 From);
@@ -411,7 +400,7 @@ public static SpecificEntropy Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out SpecificEntropy result)
+        public static bool TryParse(string? str, out SpecificEntropy<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -426,9 +415,9 @@ public static bool TryParse(string? str, out SpecificEntropy result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificEntropy result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificEntropy<T> result)
         {
-            return QuantityParser.Default.TryParse<SpecificEntropy, SpecificEntropyUnit>(
+            return QuantityParser.Default.TryParse<T, SpecificEntropy<T>, SpecificEntropyUnit>(
                 str,
                 provider,
                 From,
@@ -490,45 +479,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static SpecificEntropy operator -(SpecificEntropy right)
+        public static SpecificEntropy<T> operator -(SpecificEntropy<T> right)
         {
-            return new SpecificEntropy(-right.Value, right.Unit);
+            return new SpecificEntropy<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEntropy"/> from adding two <see cref="SpecificEntropy"/>.</summary>
-        public static SpecificEntropy operator +(SpecificEntropy left, SpecificEntropy right)
+        /// <summary>Get <see cref="SpecificEntropy{T}"/> from adding two <see cref="SpecificEntropy{T}"/>.</summary>
+        public static SpecificEntropy<T> operator +(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
-            return new SpecificEntropy(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEntropy"/> from subtracting two <see cref="SpecificEntropy"/>.</summary>
-        public static SpecificEntropy operator -(SpecificEntropy left, SpecificEntropy right)
+        /// <summary>Get <see cref="SpecificEntropy{T}"/> from subtracting two <see cref="SpecificEntropy{T}"/>.</summary>
+        public static SpecificEntropy<T> operator -(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
-            return new SpecificEntropy(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEntropy"/> from multiplying value and <see cref="SpecificEntropy"/>.</summary>
-        public static SpecificEntropy operator *(double left, SpecificEntropy right)
+        /// <summary>Get <see cref="SpecificEntropy{T}"/> from multiplying value and <see cref="SpecificEntropy{T}"/>.</summary>
+        public static SpecificEntropy<T> operator *(T left, SpecificEntropy<T> right)
         {
-            return new SpecificEntropy(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new SpecificEntropy<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEntropy"/> from multiplying value and <see cref="SpecificEntropy"/>.</summary>
-        public static SpecificEntropy operator *(SpecificEntropy left, double right)
+        /// <summary>Get <see cref="SpecificEntropy{T}"/> from multiplying value and <see cref="SpecificEntropy{T}"/>.</summary>
+        public static SpecificEntropy<T> operator *(SpecificEntropy<T> left, T right)
         {
-            return new SpecificEntropy(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new SpecificEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificEntropy"/> from dividing <see cref="SpecificEntropy"/> by value.</summary>
-        public static SpecificEntropy operator /(SpecificEntropy left, double right)
+        /// <summary>Get <see cref="SpecificEntropy{T}"/> from dividing <see cref="SpecificEntropy{T}"/> by value.</summary>
+        public static SpecificEntropy<T> operator /(SpecificEntropy<T> left, T right)
         {
-            return new SpecificEntropy(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new SpecificEntropy<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="SpecificEntropy"/> by <see cref="SpecificEntropy"/>.</summary>
-        public static double operator /(SpecificEntropy left, SpecificEntropy right)
+        /// <summary>Get ratio value from dividing <see cref="SpecificEntropy{T}"/> by <see cref="SpecificEntropy{T}"/>.</summary>
+        public static T operator /(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
-            return left.JoulesPerKilogramKelvin / right.JoulesPerKilogramKelvin;
+            return CompiledLambdas.Divide(left.JoulesPerKilogramKelvin, right.JoulesPerKilogramKelvin);
         }
 
         #endregion
@@ -536,39 +530,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(SpecificEntropy left, SpecificEntropy right)
+        public static bool operator <=(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(SpecificEntropy left, SpecificEntropy right)
+        public static bool operator >=(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(SpecificEntropy left, SpecificEntropy right)
+        public static bool operator <(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(SpecificEntropy left, SpecificEntropy right)
+        public static bool operator >(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(SpecificEntropy left, SpecificEntropy right)
+        /// <remarks>Consider using <see cref="Equals(SpecificEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(SpecificEntropy left, SpecificEntropy right)
+        /// <remarks>Consider using <see cref="Equals(SpecificEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(SpecificEntropy<T> left, SpecificEntropy<T> right)
         {
             return !(left == right);
         }
@@ -577,37 +571,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is SpecificEntropy objSpecificEntropy)) throw new ArgumentException("Expected type SpecificEntropy.", nameof(obj));
+            if(!(obj is SpecificEntropy<T> objSpecificEntropy)) throw new ArgumentException("Expected type SpecificEntropy.", nameof(obj));
 
             return CompareTo(objSpecificEntropy);
         }
 
         /// <inheritdoc />
-        public int CompareTo(SpecificEntropy other)
+        public int CompareTo(SpecificEntropy<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(SpecificEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is SpecificEntropy objSpecificEntropy))
+            if(obj is null || !(obj is SpecificEntropy<T> objSpecificEntropy))
                 return false;
 
             return Equals(objSpecificEntropy);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificEntropy, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(SpecificEntropy other)
+        /// <remarks>Consider using <see cref="Equals(SpecificEntropy{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(SpecificEntropy<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another SpecificEntropy within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="SpecificEntropy{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -645,21 +639,19 @@ public bool Equals(SpecificEntropy other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(SpecificEntropy other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(SpecificEntropy<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current SpecificEntropy.</returns>
+        /// <returns>A hash code for the current <see cref="SpecificEntropy{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -673,17 +665,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificEntropyUnit unit)
+        public T As(SpecificEntropyUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -703,17 +695,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is SpecificEntropyUnit unitAsSpecificEntropyUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEntropyUnit)} is supported.", nameof(unit));
 
-            return As(unitAsSpecificEntropyUnit);
+            var asValue = As(unitAsSpecificEntropyUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<SpecificEntropyUnit>.As(SpecificEntropyUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this SpecificEntropy to another SpecificEntropy with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="SpecificEntropy{T}" /> to another <see cref="SpecificEntropy{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A SpecificEntropy with the specified unit.</returns>
-        public SpecificEntropy ToUnit(SpecificEntropyUnit unit)
+        /// <returns>A <see cref="SpecificEntropy{T}" /> with the specified unit.</returns>
+        public SpecificEntropy<T> ToUnit(SpecificEntropyUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new SpecificEntropy(convertedValue, unit);
+            return new SpecificEntropy<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -726,7 +723,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public SpecificEntropy ToUnit(UnitSystem unitSystem)
+        public SpecificEntropy<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -746,27 +743,33 @@ public SpecificEntropy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificEntropyUnit> IQuantity<SpecificEntropyUnit>.ToUnit(SpecificEntropyUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificEntropyUnit, T> IQuantityT<SpecificEntropyUnit, T>.ToUnit(SpecificEntropyUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<SpecificEntropyUnit> IQuantity<SpecificEntropyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificEntropyUnit, T> IQuantityT<SpecificEntropyUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case SpecificEntropyUnit.BtuPerPoundFahrenheit: return _value * 4.1868e3;
-                case SpecificEntropyUnit.CaloriePerGramKelvin: return _value*4.184e3;
-                case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: return _value;
-                case SpecificEntropyUnit.JoulePerKilogramKelvin: return _value;
-                case SpecificEntropyUnit.KilocaloriePerGramKelvin: return (_value*4.184e3) * 1e3d;
-                case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: return (_value) * 1e3d;
-                case SpecificEntropyUnit.KilojoulePerKilogramKelvin: return (_value) * 1e3d;
-                case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: return (_value) * 1e6d;
-                case SpecificEntropyUnit.MegajoulePerKilogramKelvin: return (_value) * 1e6d;
+                case SpecificEntropyUnit.BtuPerPoundFahrenheit: return Value * 4.1868e3;
+                case SpecificEntropyUnit.CaloriePerGramKelvin: return Value*4.184e3;
+                case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: return Value;
+                case SpecificEntropyUnit.JoulePerKilogramKelvin: return Value;
+                case SpecificEntropyUnit.KilocaloriePerGramKelvin: return (Value*4.184e3) * 1e3d;
+                case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: return (Value) * 1e3d;
+                case SpecificEntropyUnit.KilojoulePerKilogramKelvin: return (Value) * 1e3d;
+                case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: return (Value) * 1e6d;
+                case SpecificEntropyUnit.MegajoulePerKilogramKelvin: return (Value) * 1e6d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -777,16 +780,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal SpecificEntropy ToBaseUnit()
+        internal SpecificEntropy<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new SpecificEntropy(baseUnitValue, BaseUnit);
+            return new SpecificEntropy<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(SpecificEntropyUnit unit)
+        private T GetValueAs(SpecificEntropyUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -897,57 +900,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificEntropy)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificEntropy<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificEntropy)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificEntropy<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificEntropy)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificEntropy<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -957,33 +960,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(SpecificEntropy))
+            if(conversionType == typeof(SpecificEntropy<T>))
                 return this;
             else if(conversionType == typeof(SpecificEntropyUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return SpecificEntropy.QuantityType;
+                return SpecificEntropy<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return SpecificEntropy.Info;
+                return SpecificEntropy<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return SpecificEntropy.BaseDimensions;
+                return SpecificEntropy<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(SpecificEntropy)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(SpecificEntropy<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
index 759a634e8c..fecf5f985c 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In thermodynamics, the specific volume of a substance is the ratio of the substance's volume to its mass. It is the reciprocal of density and an intrinsic property of matter as well.
     /// </summary>
-    public partial struct SpecificVolume : IQuantity<SpecificVolumeUnit>, IEquatable<SpecificVolume>, IComparable, IComparable<SpecificVolume>, IConvertible, IFormattable
+    public partial struct SpecificVolume<T> : IQuantityT<SpecificVolumeUnit, T>, IEquatable<SpecificVolume<T>>, IComparable, IComparable<SpecificVolume<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -65,12 +61,12 @@ static SpecificVolume()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public SpecificVolume(double value, SpecificVolumeUnit unit)
+        public SpecificVolume(T value, SpecificVolumeUnit unit)
         {
             if(unit == SpecificVolumeUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -82,14 +78,14 @@ public SpecificVolume(double value, SpecificVolumeUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificVolume(double value, UnitSystem unitSystem)
+        public SpecificVolume(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -104,19 +100,19 @@ public SpecificVolume(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of SpecificVolume, which is CubicMeterPerKilogram. All conversions go via this value.
+        ///     The base unit of <see cref="SpecificVolume{T}" />, which is CubicMeterPerKilogram. All conversions go via this value.
         /// </summary>
         public static SpecificVolumeUnit BaseUnit { get; } = SpecificVolumeUnit.CubicMeterPerKilogram;
 
         /// <summary>
-        /// Represents the largest possible value of SpecificVolume
+        /// Represents the largest possible value of <see cref="SpecificVolume{T}" />
         /// </summary>
-        public static SpecificVolume MaxValue { get; } = new SpecificVolume(double.MaxValue, BaseUnit);
+        public static SpecificVolume<T> MaxValue { get; } = new SpecificVolume<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of SpecificVolume
+        /// Represents the smallest possible value of <see cref="SpecificVolume{T}" />
         /// </summary>
-        public static SpecificVolume MinValue { get; } = new SpecificVolume(double.MinValue, BaseUnit);
+        public static SpecificVolume<T> MinValue { get; } = new SpecificVolume<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -125,14 +121,14 @@ public SpecificVolume(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.SpecificVolume;
 
         /// <summary>
-        ///     All units of measurement for the SpecificVolume quantity.
+        ///     All units of measurement for the <see cref="SpecificVolume{T}" /> quantity.
         /// </summary>
         public static SpecificVolumeUnit[] Units { get; } = Enum.GetValues(typeof(SpecificVolumeUnit)).Cast<SpecificVolumeUnit>().Except(new SpecificVolumeUnit[]{ SpecificVolumeUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit CubicMeterPerKilogram.
         /// </summary>
-        public static SpecificVolume Zero { get; } = new SpecificVolume(0, BaseUnit);
+        public static SpecificVolume<T> Zero { get; } = new SpecificVolume<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -141,7 +137,9 @@ public SpecificVolume(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -157,31 +155,31 @@ public SpecificVolume(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => SpecificVolume.QuantityType;
+        public QuantityType Type => SpecificVolume<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => SpecificVolume.BaseDimensions;
+        public BaseDimensions Dimensions => SpecificVolume<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get SpecificVolume in CubicFeetPerPound.
+        ///     Get <see cref="SpecificVolume{T}" /> in CubicFeetPerPound.
         /// </summary>
-        public double CubicFeetPerPound => As(SpecificVolumeUnit.CubicFootPerPound);
+        public T CubicFeetPerPound => As(SpecificVolumeUnit.CubicFootPerPound);
 
         /// <summary>
-        ///     Get SpecificVolume in CubicMetersPerKilogram.
+        ///     Get <see cref="SpecificVolume{T}" /> in CubicMetersPerKilogram.
         /// </summary>
-        public double CubicMetersPerKilogram => As(SpecificVolumeUnit.CubicMeterPerKilogram);
+        public T CubicMetersPerKilogram => As(SpecificVolumeUnit.CubicMeterPerKilogram);
 
         /// <summary>
-        ///     Get SpecificVolume in MillicubicMetersPerKilogram.
+        ///     Get <see cref="SpecificVolume{T}" /> in MillicubicMetersPerKilogram.
         /// </summary>
-        public double MillicubicMetersPerKilogram => As(SpecificVolumeUnit.MillicubicMeterPerKilogram);
+        public T MillicubicMetersPerKilogram => As(SpecificVolumeUnit.MillicubicMeterPerKilogram);
 
         #endregion
 
@@ -213,42 +211,39 @@ public static string GetAbbreviation(SpecificVolumeUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get SpecificVolume from CubicFeetPerPound.
+        ///     Get <see cref="SpecificVolume{T}" /> from CubicFeetPerPound.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromCubicFeetPerPound(QuantityValue cubicfeetperpound)
+        public static SpecificVolume<T> FromCubicFeetPerPound(T cubicfeetperpound)
         {
-            double value = (double) cubicfeetperpound;
-            return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound);
+            return new SpecificVolume<T>(cubicfeetperpound, SpecificVolumeUnit.CubicFootPerPound);
         }
         /// <summary>
-        ///     Get SpecificVolume from CubicMetersPerKilogram.
+        ///     Get <see cref="SpecificVolume{T}" /> from CubicMetersPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromCubicMetersPerKilogram(QuantityValue cubicmetersperkilogram)
+        public static SpecificVolume<T> FromCubicMetersPerKilogram(T cubicmetersperkilogram)
         {
-            double value = (double) cubicmetersperkilogram;
-            return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram);
+            return new SpecificVolume<T>(cubicmetersperkilogram, SpecificVolumeUnit.CubicMeterPerKilogram);
         }
         /// <summary>
-        ///     Get SpecificVolume from MillicubicMetersPerKilogram.
+        ///     Get <see cref="SpecificVolume{T}" /> from MillicubicMetersPerKilogram.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromMillicubicMetersPerKilogram(QuantityValue millicubicmetersperkilogram)
+        public static SpecificVolume<T> FromMillicubicMetersPerKilogram(T millicubicmetersperkilogram)
         {
-            double value = (double) millicubicmetersperkilogram;
-            return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram);
+            return new SpecificVolume<T>(millicubicmetersperkilogram, SpecificVolumeUnit.MillicubicMeterPerKilogram);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificVolumeUnit" /> to <see cref="SpecificVolume" />.
+        ///     Dynamically convert from value and unit enum <see cref="SpecificVolumeUnit" /> to <see cref="SpecificVolume{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificVolume unit value.</returns>
-        public static SpecificVolume From(QuantityValue value, SpecificVolumeUnit fromUnit)
+        /// <returns><see cref="SpecificVolume{T}" /> unit value.</returns>
+        public static SpecificVolume<T> From(T value, SpecificVolumeUnit fromUnit)
         {
-            return new SpecificVolume((double)value, fromUnit);
+            return new SpecificVolume<T>(value, fromUnit);
         }
 
         #endregion
@@ -277,7 +272,7 @@ public static SpecificVolume From(QuantityValue value, SpecificVolumeUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static SpecificVolume Parse(string str)
+        public static SpecificVolume<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -305,9 +300,9 @@ public static SpecificVolume Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static SpecificVolume Parse(string str, IFormatProvider? provider)
+        public static SpecificVolume<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<SpecificVolume, SpecificVolumeUnit>(
+            return QuantityParser.Default.Parse<T, SpecificVolume<T>, SpecificVolumeUnit>(
                 str,
                 provider,
                 From);
@@ -321,7 +316,7 @@ public static SpecificVolume Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out SpecificVolume result)
+        public static bool TryParse(string? str, out SpecificVolume<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -336,9 +331,9 @@ public static bool TryParse(string? str, out SpecificVolume result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificVolume result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificVolume<T> result)
         {
-            return QuantityParser.Default.TryParse<SpecificVolume, SpecificVolumeUnit>(
+            return QuantityParser.Default.TryParse<T, SpecificVolume<T>, SpecificVolumeUnit>(
                 str,
                 provider,
                 From,
@@ -400,45 +395,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static SpecificVolume operator -(SpecificVolume right)
+        public static SpecificVolume<T> operator -(SpecificVolume<T> right)
         {
-            return new SpecificVolume(-right.Value, right.Unit);
+            return new SpecificVolume<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificVolume"/> from adding two <see cref="SpecificVolume"/>.</summary>
-        public static SpecificVolume operator +(SpecificVolume left, SpecificVolume right)
+        /// <summary>Get <see cref="SpecificVolume{T}"/> from adding two <see cref="SpecificVolume{T}"/>.</summary>
+        public static SpecificVolume<T> operator +(SpecificVolume<T> left, SpecificVolume<T> right)
         {
-            return new SpecificVolume(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificVolume<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificVolume"/> from subtracting two <see cref="SpecificVolume"/>.</summary>
-        public static SpecificVolume operator -(SpecificVolume left, SpecificVolume right)
+        /// <summary>Get <see cref="SpecificVolume{T}"/> from subtracting two <see cref="SpecificVolume{T}"/>.</summary>
+        public static SpecificVolume<T> operator -(SpecificVolume<T> left, SpecificVolume<T> right)
         {
-            return new SpecificVolume(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificVolume<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificVolume"/> from multiplying value and <see cref="SpecificVolume"/>.</summary>
-        public static SpecificVolume operator *(double left, SpecificVolume right)
+        /// <summary>Get <see cref="SpecificVolume{T}"/> from multiplying value and <see cref="SpecificVolume{T}"/>.</summary>
+        public static SpecificVolume<T> operator *(T left, SpecificVolume<T> right)
         {
-            return new SpecificVolume(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new SpecificVolume<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificVolume"/> from multiplying value and <see cref="SpecificVolume"/>.</summary>
-        public static SpecificVolume operator *(SpecificVolume left, double right)
+        /// <summary>Get <see cref="SpecificVolume{T}"/> from multiplying value and <see cref="SpecificVolume{T}"/>.</summary>
+        public static SpecificVolume<T> operator *(SpecificVolume<T> left, T right)
         {
-            return new SpecificVolume(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new SpecificVolume<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificVolume"/> from dividing <see cref="SpecificVolume"/> by value.</summary>
-        public static SpecificVolume operator /(SpecificVolume left, double right)
+        /// <summary>Get <see cref="SpecificVolume{T}"/> from dividing <see cref="SpecificVolume{T}"/> by value.</summary>
+        public static SpecificVolume<T> operator /(SpecificVolume<T> left, T right)
         {
-            return new SpecificVolume(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new SpecificVolume<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="SpecificVolume"/> by <see cref="SpecificVolume"/>.</summary>
-        public static double operator /(SpecificVolume left, SpecificVolume right)
+        /// <summary>Get ratio value from dividing <see cref="SpecificVolume{T}"/> by <see cref="SpecificVolume{T}"/>.</summary>
+        public static T operator /(SpecificVolume<T> left, SpecificVolume<T> right)
         {
-            return left.CubicMetersPerKilogram / right.CubicMetersPerKilogram;
+            return CompiledLambdas.Divide(left.CubicMetersPerKilogram, right.CubicMetersPerKilogram);
         }
 
         #endregion
@@ -446,39 +446,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(SpecificVolume left, SpecificVolume right)
+        public static bool operator <=(SpecificVolume<T> left, SpecificVolume<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(SpecificVolume left, SpecificVolume right)
+        public static bool operator >=(SpecificVolume<T> left, SpecificVolume<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(SpecificVolume left, SpecificVolume right)
+        public static bool operator <(SpecificVolume<T> left, SpecificVolume<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(SpecificVolume left, SpecificVolume right)
+        public static bool operator >(SpecificVolume<T> left, SpecificVolume<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificVolume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(SpecificVolume left, SpecificVolume right)
+        /// <remarks>Consider using <see cref="Equals(SpecificVolume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(SpecificVolume<T> left, SpecificVolume<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificVolume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(SpecificVolume left, SpecificVolume right)
+        /// <remarks>Consider using <see cref="Equals(SpecificVolume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(SpecificVolume<T> left, SpecificVolume<T> right)
         {
             return !(left == right);
         }
@@ -487,37 +487,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is SpecificVolume objSpecificVolume)) throw new ArgumentException("Expected type SpecificVolume.", nameof(obj));
+            if(!(obj is SpecificVolume<T> objSpecificVolume)) throw new ArgumentException("Expected type SpecificVolume.", nameof(obj));
 
             return CompareTo(objSpecificVolume);
         }
 
         /// <inheritdoc />
-        public int CompareTo(SpecificVolume other)
+        public int CompareTo(SpecificVolume<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificVolume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(SpecificVolume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is SpecificVolume objSpecificVolume))
+            if(obj is null || !(obj is SpecificVolume<T> objSpecificVolume))
                 return false;
 
             return Equals(objSpecificVolume);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificVolume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(SpecificVolume other)
+        /// <remarks>Consider using <see cref="Equals(SpecificVolume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(SpecificVolume<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another SpecificVolume within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="SpecificVolume{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -555,21 +555,19 @@ public bool Equals(SpecificVolume other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(SpecificVolume other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(SpecificVolume<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current SpecificVolume.</returns>
+        /// <returns>A hash code for the current <see cref="SpecificVolume{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -583,17 +581,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificVolumeUnit unit)
+        public T As(SpecificVolumeUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -613,17 +611,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is SpecificVolumeUnit unitAsSpecificVolumeUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificVolumeUnit)} is supported.", nameof(unit));
 
-            return As(unitAsSpecificVolumeUnit);
+            var asValue = As(unitAsSpecificVolumeUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<SpecificVolumeUnit>.As(SpecificVolumeUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this SpecificVolume to another SpecificVolume with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="SpecificVolume{T}" /> to another <see cref="SpecificVolume{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A SpecificVolume with the specified unit.</returns>
-        public SpecificVolume ToUnit(SpecificVolumeUnit unit)
+        /// <returns>A <see cref="SpecificVolume{T}" /> with the specified unit.</returns>
+        public SpecificVolume<T> ToUnit(SpecificVolumeUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new SpecificVolume(convertedValue, unit);
+            return new SpecificVolume<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -636,7 +639,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public SpecificVolume ToUnit(UnitSystem unitSystem)
+        public SpecificVolume<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -656,21 +659,27 @@ public SpecificVolume ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificVolumeUnit> IQuantity<SpecificVolumeUnit>.ToUnit(SpecificVolumeUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificVolumeUnit, T> IQuantityT<SpecificVolumeUnit, T>.ToUnit(SpecificVolumeUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<SpecificVolumeUnit> IQuantity<SpecificVolumeUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificVolumeUnit, T> IQuantityT<SpecificVolumeUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case SpecificVolumeUnit.CubicFootPerPound: return _value/16.01846353;
-                case SpecificVolumeUnit.CubicMeterPerKilogram: return _value;
-                case SpecificVolumeUnit.MillicubicMeterPerKilogram: return (_value) * 1e-3d;
+                case SpecificVolumeUnit.CubicFootPerPound: return Value/16.01846353;
+                case SpecificVolumeUnit.CubicMeterPerKilogram: return Value;
+                case SpecificVolumeUnit.MillicubicMeterPerKilogram: return (Value) * 1e-3d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -681,16 +690,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal SpecificVolume ToBaseUnit()
+        internal SpecificVolume<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new SpecificVolume(baseUnitValue, BaseUnit);
+            return new SpecificVolume<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(SpecificVolumeUnit unit)
+        private T GetValueAs(SpecificVolumeUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -795,57 +804,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificVolume)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificVolume<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificVolume)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificVolume<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificVolume)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificVolume<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -855,33 +864,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(SpecificVolume))
+            if(conversionType == typeof(SpecificVolume<T>))
                 return this;
             else if(conversionType == typeof(SpecificVolumeUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return SpecificVolume.QuantityType;
+                return SpecificVolume<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return SpecificVolume.Info;
+                return SpecificVolume<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return SpecificVolume.BaseDimensions;
+                return SpecificVolume<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(SpecificVolume)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(SpecificVolume<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
index 5d5e5ed153..bb9113b297 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     http://en.wikipedia.org/wiki/Specificweight
     /// </remarks>
-    public partial struct SpecificWeight : IQuantity<SpecificWeightUnit>, IEquatable<SpecificWeight>, IComparable, IComparable<SpecificWeight>, IConvertible, IFormattable
+    public partial struct SpecificWeight<T> : IQuantityT<SpecificWeightUnit, T>, IEquatable<SpecificWeight<T>>, IComparable, IComparable<SpecificWeight<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -82,12 +78,12 @@ static SpecificWeight()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public SpecificWeight(double value, SpecificWeightUnit unit)
+        public SpecificWeight(T value, SpecificWeightUnit unit)
         {
             if(unit == SpecificWeightUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -99,14 +95,14 @@ public SpecificWeight(double value, SpecificWeightUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificWeight(double value, UnitSystem unitSystem)
+        public SpecificWeight(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -121,19 +117,19 @@ public SpecificWeight(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of SpecificWeight, which is NewtonPerCubicMeter. All conversions go via this value.
+        ///     The base unit of <see cref="SpecificWeight{T}" />, which is NewtonPerCubicMeter. All conversions go via this value.
         /// </summary>
         public static SpecificWeightUnit BaseUnit { get; } = SpecificWeightUnit.NewtonPerCubicMeter;
 
         /// <summary>
-        /// Represents the largest possible value of SpecificWeight
+        /// Represents the largest possible value of <see cref="SpecificWeight{T}" />
         /// </summary>
-        public static SpecificWeight MaxValue { get; } = new SpecificWeight(double.MaxValue, BaseUnit);
+        public static SpecificWeight<T> MaxValue { get; } = new SpecificWeight<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of SpecificWeight
+        /// Represents the smallest possible value of <see cref="SpecificWeight{T}" />
         /// </summary>
-        public static SpecificWeight MinValue { get; } = new SpecificWeight(double.MinValue, BaseUnit);
+        public static SpecificWeight<T> MinValue { get; } = new SpecificWeight<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -142,14 +138,14 @@ public SpecificWeight(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.SpecificWeight;
 
         /// <summary>
-        ///     All units of measurement for the SpecificWeight quantity.
+        ///     All units of measurement for the <see cref="SpecificWeight{T}" /> quantity.
         /// </summary>
         public static SpecificWeightUnit[] Units { get; } = Enum.GetValues(typeof(SpecificWeightUnit)).Cast<SpecificWeightUnit>().Except(new SpecificWeightUnit[]{ SpecificWeightUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonPerCubicMeter.
         /// </summary>
-        public static SpecificWeight Zero { get; } = new SpecificWeight(0, BaseUnit);
+        public static SpecificWeight<T> Zero { get; } = new SpecificWeight<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -158,7 +154,9 @@ public SpecificWeight(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -174,101 +172,101 @@ public SpecificWeight(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => SpecificWeight.QuantityType;
+        public QuantityType Type => SpecificWeight<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => SpecificWeight.BaseDimensions;
+        public BaseDimensions Dimensions => SpecificWeight<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get SpecificWeight in KilogramsForcePerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilogramsForcePerCubicCentimeter.
         /// </summary>
-        public double KilogramsForcePerCubicCentimeter => As(SpecificWeightUnit.KilogramForcePerCubicCentimeter);
+        public T KilogramsForcePerCubicCentimeter => As(SpecificWeightUnit.KilogramForcePerCubicCentimeter);
 
         /// <summary>
-        ///     Get SpecificWeight in KilogramsForcePerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilogramsForcePerCubicMeter.
         /// </summary>
-        public double KilogramsForcePerCubicMeter => As(SpecificWeightUnit.KilogramForcePerCubicMeter);
+        public T KilogramsForcePerCubicMeter => As(SpecificWeightUnit.KilogramForcePerCubicMeter);
 
         /// <summary>
-        ///     Get SpecificWeight in KilogramsForcePerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilogramsForcePerCubicMillimeter.
         /// </summary>
-        public double KilogramsForcePerCubicMillimeter => As(SpecificWeightUnit.KilogramForcePerCubicMillimeter);
+        public T KilogramsForcePerCubicMillimeter => As(SpecificWeightUnit.KilogramForcePerCubicMillimeter);
 
         /// <summary>
-        ///     Get SpecificWeight in KilonewtonsPerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilonewtonsPerCubicCentimeter.
         /// </summary>
-        public double KilonewtonsPerCubicCentimeter => As(SpecificWeightUnit.KilonewtonPerCubicCentimeter);
+        public T KilonewtonsPerCubicCentimeter => As(SpecificWeightUnit.KilonewtonPerCubicCentimeter);
 
         /// <summary>
-        ///     Get SpecificWeight in KilonewtonsPerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilonewtonsPerCubicMeter.
         /// </summary>
-        public double KilonewtonsPerCubicMeter => As(SpecificWeightUnit.KilonewtonPerCubicMeter);
+        public T KilonewtonsPerCubicMeter => As(SpecificWeightUnit.KilonewtonPerCubicMeter);
 
         /// <summary>
-        ///     Get SpecificWeight in KilonewtonsPerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilonewtonsPerCubicMillimeter.
         /// </summary>
-        public double KilonewtonsPerCubicMillimeter => As(SpecificWeightUnit.KilonewtonPerCubicMillimeter);
+        public T KilonewtonsPerCubicMillimeter => As(SpecificWeightUnit.KilonewtonPerCubicMillimeter);
 
         /// <summary>
-        ///     Get SpecificWeight in KilopoundsForcePerCubicFoot.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilopoundsForcePerCubicFoot.
         /// </summary>
-        public double KilopoundsForcePerCubicFoot => As(SpecificWeightUnit.KilopoundForcePerCubicFoot);
+        public T KilopoundsForcePerCubicFoot => As(SpecificWeightUnit.KilopoundForcePerCubicFoot);
 
         /// <summary>
-        ///     Get SpecificWeight in KilopoundsForcePerCubicInch.
+        ///     Get <see cref="SpecificWeight{T}" /> in KilopoundsForcePerCubicInch.
         /// </summary>
-        public double KilopoundsForcePerCubicInch => As(SpecificWeightUnit.KilopoundForcePerCubicInch);
+        public T KilopoundsForcePerCubicInch => As(SpecificWeightUnit.KilopoundForcePerCubicInch);
 
         /// <summary>
-        ///     Get SpecificWeight in MeganewtonsPerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in MeganewtonsPerCubicMeter.
         /// </summary>
-        public double MeganewtonsPerCubicMeter => As(SpecificWeightUnit.MeganewtonPerCubicMeter);
+        public T MeganewtonsPerCubicMeter => As(SpecificWeightUnit.MeganewtonPerCubicMeter);
 
         /// <summary>
-        ///     Get SpecificWeight in NewtonsPerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in NewtonsPerCubicCentimeter.
         /// </summary>
-        public double NewtonsPerCubicCentimeter => As(SpecificWeightUnit.NewtonPerCubicCentimeter);
+        public T NewtonsPerCubicCentimeter => As(SpecificWeightUnit.NewtonPerCubicCentimeter);
 
         /// <summary>
-        ///     Get SpecificWeight in NewtonsPerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in NewtonsPerCubicMeter.
         /// </summary>
-        public double NewtonsPerCubicMeter => As(SpecificWeightUnit.NewtonPerCubicMeter);
+        public T NewtonsPerCubicMeter => As(SpecificWeightUnit.NewtonPerCubicMeter);
 
         /// <summary>
-        ///     Get SpecificWeight in NewtonsPerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in NewtonsPerCubicMillimeter.
         /// </summary>
-        public double NewtonsPerCubicMillimeter => As(SpecificWeightUnit.NewtonPerCubicMillimeter);
+        public T NewtonsPerCubicMillimeter => As(SpecificWeightUnit.NewtonPerCubicMillimeter);
 
         /// <summary>
-        ///     Get SpecificWeight in PoundsForcePerCubicFoot.
+        ///     Get <see cref="SpecificWeight{T}" /> in PoundsForcePerCubicFoot.
         /// </summary>
-        public double PoundsForcePerCubicFoot => As(SpecificWeightUnit.PoundForcePerCubicFoot);
+        public T PoundsForcePerCubicFoot => As(SpecificWeightUnit.PoundForcePerCubicFoot);
 
         /// <summary>
-        ///     Get SpecificWeight in PoundsForcePerCubicInch.
+        ///     Get <see cref="SpecificWeight{T}" /> in PoundsForcePerCubicInch.
         /// </summary>
-        public double PoundsForcePerCubicInch => As(SpecificWeightUnit.PoundForcePerCubicInch);
+        public T PoundsForcePerCubicInch => As(SpecificWeightUnit.PoundForcePerCubicInch);
 
         /// <summary>
-        ///     Get SpecificWeight in TonnesForcePerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in TonnesForcePerCubicCentimeter.
         /// </summary>
-        public double TonnesForcePerCubicCentimeter => As(SpecificWeightUnit.TonneForcePerCubicCentimeter);
+        public T TonnesForcePerCubicCentimeter => As(SpecificWeightUnit.TonneForcePerCubicCentimeter);
 
         /// <summary>
-        ///     Get SpecificWeight in TonnesForcePerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in TonnesForcePerCubicMeter.
         /// </summary>
-        public double TonnesForcePerCubicMeter => As(SpecificWeightUnit.TonneForcePerCubicMeter);
+        public T TonnesForcePerCubicMeter => As(SpecificWeightUnit.TonneForcePerCubicMeter);
 
         /// <summary>
-        ///     Get SpecificWeight in TonnesForcePerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> in TonnesForcePerCubicMillimeter.
         /// </summary>
-        public double TonnesForcePerCubicMillimeter => As(SpecificWeightUnit.TonneForcePerCubicMillimeter);
+        public T TonnesForcePerCubicMillimeter => As(SpecificWeightUnit.TonneForcePerCubicMillimeter);
 
         #endregion
 
@@ -300,168 +298,151 @@ public static string GetAbbreviation(SpecificWeightUnit unit, IFormatProvider? p
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get SpecificWeight from KilogramsForcePerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilogramsForcePerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(QuantityValue kilogramsforcepercubiccentimeter)
+        public static SpecificWeight<T> FromKilogramsForcePerCubicCentimeter(T kilogramsforcepercubiccentimeter)
         {
-            double value = (double) kilogramsforcepercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
+            return new SpecificWeight<T>(kilogramsforcepercubiccentimeter, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from KilogramsForcePerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilogramsForcePerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicMeter(QuantityValue kilogramsforcepercubicmeter)
+        public static SpecificWeight<T> FromKilogramsForcePerCubicMeter(T kilogramsforcepercubicmeter)
         {
-            double value = (double) kilogramsforcepercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter);
+            return new SpecificWeight<T>(kilogramsforcepercubicmeter, SpecificWeightUnit.KilogramForcePerCubicMeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from KilogramsForcePerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilogramsForcePerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(QuantityValue kilogramsforcepercubicmillimeter)
+        public static SpecificWeight<T> FromKilogramsForcePerCubicMillimeter(T kilogramsforcepercubicmillimeter)
         {
-            double value = (double) kilogramsforcepercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
+            return new SpecificWeight<T>(kilogramsforcepercubicmillimeter, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from KilonewtonsPerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilonewtonsPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(QuantityValue kilonewtonspercubiccentimeter)
+        public static SpecificWeight<T> FromKilonewtonsPerCubicCentimeter(T kilonewtonspercubiccentimeter)
         {
-            double value = (double) kilonewtonspercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
+            return new SpecificWeight<T>(kilonewtonspercubiccentimeter, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from KilonewtonsPerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilonewtonsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicMeter(QuantityValue kilonewtonspercubicmeter)
+        public static SpecificWeight<T> FromKilonewtonsPerCubicMeter(T kilonewtonspercubicmeter)
         {
-            double value = (double) kilonewtonspercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter);
+            return new SpecificWeight<T>(kilonewtonspercubicmeter, SpecificWeightUnit.KilonewtonPerCubicMeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from KilonewtonsPerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilonewtonsPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(QuantityValue kilonewtonspercubicmillimeter)
+        public static SpecificWeight<T> FromKilonewtonsPerCubicMillimeter(T kilonewtonspercubicmillimeter)
         {
-            double value = (double) kilonewtonspercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
+            return new SpecificWeight<T>(kilonewtonspercubicmillimeter, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from KilopoundsForcePerCubicFoot.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilopoundsForcePerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilopoundsForcePerCubicFoot(QuantityValue kilopoundsforcepercubicfoot)
+        public static SpecificWeight<T> FromKilopoundsForcePerCubicFoot(T kilopoundsforcepercubicfoot)
         {
-            double value = (double) kilopoundsforcepercubicfoot;
-            return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot);
+            return new SpecificWeight<T>(kilopoundsforcepercubicfoot, SpecificWeightUnit.KilopoundForcePerCubicFoot);
         }
         /// <summary>
-        ///     Get SpecificWeight from KilopoundsForcePerCubicInch.
+        ///     Get <see cref="SpecificWeight{T}" /> from KilopoundsForcePerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilopoundsForcePerCubicInch(QuantityValue kilopoundsforcepercubicinch)
+        public static SpecificWeight<T> FromKilopoundsForcePerCubicInch(T kilopoundsforcepercubicinch)
         {
-            double value = (double) kilopoundsforcepercubicinch;
-            return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch);
+            return new SpecificWeight<T>(kilopoundsforcepercubicinch, SpecificWeightUnit.KilopoundForcePerCubicInch);
         }
         /// <summary>
-        ///     Get SpecificWeight from MeganewtonsPerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from MeganewtonsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromMeganewtonsPerCubicMeter(QuantityValue meganewtonspercubicmeter)
+        public static SpecificWeight<T> FromMeganewtonsPerCubicMeter(T meganewtonspercubicmeter)
         {
-            double value = (double) meganewtonspercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter);
+            return new SpecificWeight<T>(meganewtonspercubicmeter, SpecificWeightUnit.MeganewtonPerCubicMeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from NewtonsPerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from NewtonsPerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicCentimeter(QuantityValue newtonspercubiccentimeter)
+        public static SpecificWeight<T> FromNewtonsPerCubicCentimeter(T newtonspercubiccentimeter)
         {
-            double value = (double) newtonspercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter);
+            return new SpecificWeight<T>(newtonspercubiccentimeter, SpecificWeightUnit.NewtonPerCubicCentimeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from NewtonsPerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from NewtonsPerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicMeter(QuantityValue newtonspercubicmeter)
+        public static SpecificWeight<T> FromNewtonsPerCubicMeter(T newtonspercubicmeter)
         {
-            double value = (double) newtonspercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter);
+            return new SpecificWeight<T>(newtonspercubicmeter, SpecificWeightUnit.NewtonPerCubicMeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from NewtonsPerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from NewtonsPerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicMillimeter(QuantityValue newtonspercubicmillimeter)
+        public static SpecificWeight<T> FromNewtonsPerCubicMillimeter(T newtonspercubicmillimeter)
         {
-            double value = (double) newtonspercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter);
+            return new SpecificWeight<T>(newtonspercubicmillimeter, SpecificWeightUnit.NewtonPerCubicMillimeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from PoundsForcePerCubicFoot.
+        ///     Get <see cref="SpecificWeight{T}" /> from PoundsForcePerCubicFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromPoundsForcePerCubicFoot(QuantityValue poundsforcepercubicfoot)
+        public static SpecificWeight<T> FromPoundsForcePerCubicFoot(T poundsforcepercubicfoot)
         {
-            double value = (double) poundsforcepercubicfoot;
-            return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot);
+            return new SpecificWeight<T>(poundsforcepercubicfoot, SpecificWeightUnit.PoundForcePerCubicFoot);
         }
         /// <summary>
-        ///     Get SpecificWeight from PoundsForcePerCubicInch.
+        ///     Get <see cref="SpecificWeight{T}" /> from PoundsForcePerCubicInch.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromPoundsForcePerCubicInch(QuantityValue poundsforcepercubicinch)
+        public static SpecificWeight<T> FromPoundsForcePerCubicInch(T poundsforcepercubicinch)
         {
-            double value = (double) poundsforcepercubicinch;
-            return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch);
+            return new SpecificWeight<T>(poundsforcepercubicinch, SpecificWeightUnit.PoundForcePerCubicInch);
         }
         /// <summary>
-        ///     Get SpecificWeight from TonnesForcePerCubicCentimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from TonnesForcePerCubicCentimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicCentimeter(QuantityValue tonnesforcepercubiccentimeter)
+        public static SpecificWeight<T> FromTonnesForcePerCubicCentimeter(T tonnesforcepercubiccentimeter)
         {
-            double value = (double) tonnesforcepercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter);
+            return new SpecificWeight<T>(tonnesforcepercubiccentimeter, SpecificWeightUnit.TonneForcePerCubicCentimeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from TonnesForcePerCubicMeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from TonnesForcePerCubicMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicMeter(QuantityValue tonnesforcepercubicmeter)
+        public static SpecificWeight<T> FromTonnesForcePerCubicMeter(T tonnesforcepercubicmeter)
         {
-            double value = (double) tonnesforcepercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter);
+            return new SpecificWeight<T>(tonnesforcepercubicmeter, SpecificWeightUnit.TonneForcePerCubicMeter);
         }
         /// <summary>
-        ///     Get SpecificWeight from TonnesForcePerCubicMillimeter.
+        ///     Get <see cref="SpecificWeight{T}" /> from TonnesForcePerCubicMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicMillimeter(QuantityValue tonnesforcepercubicmillimeter)
+        public static SpecificWeight<T> FromTonnesForcePerCubicMillimeter(T tonnesforcepercubicmillimeter)
         {
-            double value = (double) tonnesforcepercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter);
+            return new SpecificWeight<T>(tonnesforcepercubicmillimeter, SpecificWeightUnit.TonneForcePerCubicMillimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificWeightUnit" /> to <see cref="SpecificWeight" />.
+        ///     Dynamically convert from value and unit enum <see cref="SpecificWeightUnit" /> to <see cref="SpecificWeight{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificWeight unit value.</returns>
-        public static SpecificWeight From(QuantityValue value, SpecificWeightUnit fromUnit)
+        /// <returns><see cref="SpecificWeight{T}" /> unit value.</returns>
+        public static SpecificWeight<T> From(T value, SpecificWeightUnit fromUnit)
         {
-            return new SpecificWeight((double)value, fromUnit);
+            return new SpecificWeight<T>(value, fromUnit);
         }
 
         #endregion
@@ -490,7 +471,7 @@ public static SpecificWeight From(QuantityValue value, SpecificWeightUnit fromUn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static SpecificWeight Parse(string str)
+        public static SpecificWeight<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -518,9 +499,9 @@ public static SpecificWeight Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static SpecificWeight Parse(string str, IFormatProvider? provider)
+        public static SpecificWeight<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<SpecificWeight, SpecificWeightUnit>(
+            return QuantityParser.Default.Parse<T, SpecificWeight<T>, SpecificWeightUnit>(
                 str,
                 provider,
                 From);
@@ -534,7 +515,7 @@ public static SpecificWeight Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out SpecificWeight result)
+        public static bool TryParse(string? str, out SpecificWeight<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -549,9 +530,9 @@ public static bool TryParse(string? str, out SpecificWeight result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificWeight result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out SpecificWeight<T> result)
         {
-            return QuantityParser.Default.TryParse<SpecificWeight, SpecificWeightUnit>(
+            return QuantityParser.Default.TryParse<T, SpecificWeight<T>, SpecificWeightUnit>(
                 str,
                 provider,
                 From,
@@ -613,45 +594,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static SpecificWeight operator -(SpecificWeight right)
+        public static SpecificWeight<T> operator -(SpecificWeight<T> right)
         {
-            return new SpecificWeight(-right.Value, right.Unit);
+            return new SpecificWeight<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificWeight"/> from adding two <see cref="SpecificWeight"/>.</summary>
-        public static SpecificWeight operator +(SpecificWeight left, SpecificWeight right)
+        /// <summary>Get <see cref="SpecificWeight{T}"/> from adding two <see cref="SpecificWeight{T}"/>.</summary>
+        public static SpecificWeight<T> operator +(SpecificWeight<T> left, SpecificWeight<T> right)
         {
-            return new SpecificWeight(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificWeight<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificWeight"/> from subtracting two <see cref="SpecificWeight"/>.</summary>
-        public static SpecificWeight operator -(SpecificWeight left, SpecificWeight right)
+        /// <summary>Get <see cref="SpecificWeight{T}"/> from subtracting two <see cref="SpecificWeight{T}"/>.</summary>
+        public static SpecificWeight<T> operator -(SpecificWeight<T> left, SpecificWeight<T> right)
         {
-            return new SpecificWeight(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new SpecificWeight<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificWeight"/> from multiplying value and <see cref="SpecificWeight"/>.</summary>
-        public static SpecificWeight operator *(double left, SpecificWeight right)
+        /// <summary>Get <see cref="SpecificWeight{T}"/> from multiplying value and <see cref="SpecificWeight{T}"/>.</summary>
+        public static SpecificWeight<T> operator *(T left, SpecificWeight<T> right)
         {
-            return new SpecificWeight(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new SpecificWeight<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificWeight"/> from multiplying value and <see cref="SpecificWeight"/>.</summary>
-        public static SpecificWeight operator *(SpecificWeight left, double right)
+        /// <summary>Get <see cref="SpecificWeight{T}"/> from multiplying value and <see cref="SpecificWeight{T}"/>.</summary>
+        public static SpecificWeight<T> operator *(SpecificWeight<T> left, T right)
         {
-            return new SpecificWeight(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new SpecificWeight<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="SpecificWeight"/> from dividing <see cref="SpecificWeight"/> by value.</summary>
-        public static SpecificWeight operator /(SpecificWeight left, double right)
+        /// <summary>Get <see cref="SpecificWeight{T}"/> from dividing <see cref="SpecificWeight{T}"/> by value.</summary>
+        public static SpecificWeight<T> operator /(SpecificWeight<T> left, T right)
         {
-            return new SpecificWeight(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new SpecificWeight<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="SpecificWeight"/> by <see cref="SpecificWeight"/>.</summary>
-        public static double operator /(SpecificWeight left, SpecificWeight right)
+        /// <summary>Get ratio value from dividing <see cref="SpecificWeight{T}"/> by <see cref="SpecificWeight{T}"/>.</summary>
+        public static T operator /(SpecificWeight<T> left, SpecificWeight<T> right)
         {
-            return left.NewtonsPerCubicMeter / right.NewtonsPerCubicMeter;
+            return CompiledLambdas.Divide(left.NewtonsPerCubicMeter, right.NewtonsPerCubicMeter);
         }
 
         #endregion
@@ -659,39 +645,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(SpecificWeight left, SpecificWeight right)
+        public static bool operator <=(SpecificWeight<T> left, SpecificWeight<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(SpecificWeight left, SpecificWeight right)
+        public static bool operator >=(SpecificWeight<T> left, SpecificWeight<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(SpecificWeight left, SpecificWeight right)
+        public static bool operator <(SpecificWeight<T> left, SpecificWeight<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(SpecificWeight left, SpecificWeight right)
+        public static bool operator >(SpecificWeight<T> left, SpecificWeight<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificWeight, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(SpecificWeight left, SpecificWeight right)
+        /// <remarks>Consider using <see cref="Equals(SpecificWeight{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(SpecificWeight<T> left, SpecificWeight<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(SpecificWeight, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(SpecificWeight left, SpecificWeight right)
+        /// <remarks>Consider using <see cref="Equals(SpecificWeight{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(SpecificWeight<T> left, SpecificWeight<T> right)
         {
             return !(left == right);
         }
@@ -700,37 +686,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speci
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is SpecificWeight objSpecificWeight)) throw new ArgumentException("Expected type SpecificWeight.", nameof(obj));
+            if(!(obj is SpecificWeight<T> objSpecificWeight)) throw new ArgumentException("Expected type SpecificWeight.", nameof(obj));
 
             return CompareTo(objSpecificWeight);
         }
 
         /// <inheritdoc />
-        public int CompareTo(SpecificWeight other)
+        public int CompareTo(SpecificWeight<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificWeight, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(SpecificWeight{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is SpecificWeight objSpecificWeight))
+            if(obj is null || !(obj is SpecificWeight<T> objSpecificWeight))
                 return false;
 
             return Equals(objSpecificWeight);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(SpecificWeight, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(SpecificWeight other)
+        /// <remarks>Consider using <see cref="Equals(SpecificWeight{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(SpecificWeight<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another SpecificWeight within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="SpecificWeight{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -768,21 +754,19 @@ public bool Equals(SpecificWeight other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(SpecificWeight other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(SpecificWeight<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current SpecificWeight.</returns>
+        /// <returns>A hash code for the current <see cref="SpecificWeight{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -796,17 +780,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificWeightUnit unit)
+        public T As(SpecificWeightUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -826,17 +810,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is SpecificWeightUnit unitAsSpecificWeightUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificWeightUnit)} is supported.", nameof(unit));
 
-            return As(unitAsSpecificWeightUnit);
+            var asValue = As(unitAsSpecificWeightUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<SpecificWeightUnit>.As(SpecificWeightUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this SpecificWeight to another SpecificWeight with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="SpecificWeight{T}" /> to another <see cref="SpecificWeight{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A SpecificWeight with the specified unit.</returns>
-        public SpecificWeight ToUnit(SpecificWeightUnit unit)
+        /// <returns>A <see cref="SpecificWeight{T}" /> with the specified unit.</returns>
+        public SpecificWeight<T> ToUnit(SpecificWeightUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new SpecificWeight(convertedValue, unit);
+            return new SpecificWeight<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -849,7 +838,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public SpecificWeight ToUnit(UnitSystem unitSystem)
+        public SpecificWeight<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -869,35 +858,41 @@ public SpecificWeight ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificWeightUnit> IQuantity<SpecificWeightUnit>.ToUnit(SpecificWeightUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificWeightUnit, T> IQuantityT<SpecificWeightUnit, T>.ToUnit(SpecificWeightUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<SpecificWeightUnit> IQuantity<SpecificWeightUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<SpecificWeightUnit, T> IQuantityT<SpecificWeightUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case SpecificWeightUnit.KilogramForcePerCubicCentimeter: return _value*9.80665e6;
-                case SpecificWeightUnit.KilogramForcePerCubicMeter: return _value*9.80665;
-                case SpecificWeightUnit.KilogramForcePerCubicMillimeter: return _value*9.80665e9;
-                case SpecificWeightUnit.KilonewtonPerCubicCentimeter: return (_value*1000000) * 1e3d;
-                case SpecificWeightUnit.KilonewtonPerCubicMeter: return (_value) * 1e3d;
-                case SpecificWeightUnit.KilonewtonPerCubicMillimeter: return (_value*1000000000) * 1e3d;
-                case SpecificWeightUnit.KilopoundForcePerCubicFoot: return (_value*1.570874638462462e2) * 1e3d;
-                case SpecificWeightUnit.KilopoundForcePerCubicInch: return (_value*2.714471375263134e5) * 1e3d;
-                case SpecificWeightUnit.MeganewtonPerCubicMeter: return (_value) * 1e6d;
-                case SpecificWeightUnit.NewtonPerCubicCentimeter: return _value*1000000;
-                case SpecificWeightUnit.NewtonPerCubicMeter: return _value;
-                case SpecificWeightUnit.NewtonPerCubicMillimeter: return _value*1000000000;
-                case SpecificWeightUnit.PoundForcePerCubicFoot: return _value*1.570874638462462e2;
-                case SpecificWeightUnit.PoundForcePerCubicInch: return _value*2.714471375263134e5;
-                case SpecificWeightUnit.TonneForcePerCubicCentimeter: return _value*9.80665e9;
-                case SpecificWeightUnit.TonneForcePerCubicMeter: return _value*9.80665e3;
-                case SpecificWeightUnit.TonneForcePerCubicMillimeter: return _value*9.80665e12;
+                case SpecificWeightUnit.KilogramForcePerCubicCentimeter: return Value*9.80665e6;
+                case SpecificWeightUnit.KilogramForcePerCubicMeter: return Value*9.80665;
+                case SpecificWeightUnit.KilogramForcePerCubicMillimeter: return Value*9.80665e9;
+                case SpecificWeightUnit.KilonewtonPerCubicCentimeter: return (Value*1000000) * 1e3d;
+                case SpecificWeightUnit.KilonewtonPerCubicMeter: return (Value) * 1e3d;
+                case SpecificWeightUnit.KilonewtonPerCubicMillimeter: return (Value*1000000000) * 1e3d;
+                case SpecificWeightUnit.KilopoundForcePerCubicFoot: return (Value*1.570874638462462e2) * 1e3d;
+                case SpecificWeightUnit.KilopoundForcePerCubicInch: return (Value*2.714471375263134e5) * 1e3d;
+                case SpecificWeightUnit.MeganewtonPerCubicMeter: return (Value) * 1e6d;
+                case SpecificWeightUnit.NewtonPerCubicCentimeter: return Value*1000000;
+                case SpecificWeightUnit.NewtonPerCubicMeter: return Value;
+                case SpecificWeightUnit.NewtonPerCubicMillimeter: return Value*1000000000;
+                case SpecificWeightUnit.PoundForcePerCubicFoot: return Value*1.570874638462462e2;
+                case SpecificWeightUnit.PoundForcePerCubicInch: return Value*2.714471375263134e5;
+                case SpecificWeightUnit.TonneForcePerCubicCentimeter: return Value*9.80665e9;
+                case SpecificWeightUnit.TonneForcePerCubicMeter: return Value*9.80665e3;
+                case SpecificWeightUnit.TonneForcePerCubicMillimeter: return Value*9.80665e12;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -908,16 +903,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal SpecificWeight ToBaseUnit()
+        internal SpecificWeight<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new SpecificWeight(baseUnitValue, BaseUnit);
+            return new SpecificWeight<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(SpecificWeightUnit unit)
+        private T GetValueAs(SpecificWeightUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1036,57 +1031,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificWeight)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificWeight<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificWeight)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificWeight<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(SpecificWeight)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(SpecificWeight<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1096,33 +1091,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(SpecificWeight))
+            if(conversionType == typeof(SpecificWeight<T>))
                 return this;
             else if(conversionType == typeof(SpecificWeightUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return SpecificWeight.QuantityType;
+                return SpecificWeight<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return SpecificWeight.Info;
+                return SpecificWeight<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return SpecificWeight.BaseDimensions;
+                return SpecificWeight<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(SpecificWeight)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(SpecificWeight<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
index f8c93c4ed9..1ed96205a6 100644
--- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In everyday use and in kinematics, the speed of an object is the magnitude of its velocity (the rate of change of its position); it is thus a scalar quantity.[1] The average speed of an object in an interval of time is the distance travelled by the object divided by the duration of the interval;[2] the instantaneous speed is the limit of the average speed as the duration of the time interval approaches zero.
     /// </summary>
-    public partial struct Speed : IQuantity<SpeedUnit>, IEquatable<Speed>, IComparable, IComparable<Speed>, IConvertible, IFormattable
+    public partial struct Speed<T> : IQuantityT<SpeedUnit, T>, IEquatable<Speed<T>>, IComparable, IComparable<Speed<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -94,12 +90,12 @@ static Speed()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Speed(double value, SpeedUnit unit)
+        public Speed(T value, SpeedUnit unit)
         {
             if(unit == SpeedUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -111,14 +107,14 @@ public Speed(double value, SpeedUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Speed(double value, UnitSystem unitSystem)
+        public Speed(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -133,19 +129,19 @@ public Speed(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Speed, which is MeterPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="Speed{T}" />, which is MeterPerSecond. All conversions go via this value.
         /// </summary>
         public static SpeedUnit BaseUnit { get; } = SpeedUnit.MeterPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of Speed
+        /// Represents the largest possible value of <see cref="Speed{T}" />
         /// </summary>
-        public static Speed MaxValue { get; } = new Speed(double.MaxValue, BaseUnit);
+        public static Speed<T> MaxValue { get; } = new Speed<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Speed
+        /// Represents the smallest possible value of <see cref="Speed{T}" />
         /// </summary>
-        public static Speed MinValue { get; } = new Speed(double.MinValue, BaseUnit);
+        public static Speed<T> MinValue { get; } = new Speed<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -154,14 +150,14 @@ public Speed(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Speed;
 
         /// <summary>
-        ///     All units of measurement for the Speed quantity.
+        ///     All units of measurement for the <see cref="Speed{T}" /> quantity.
         /// </summary>
         public static SpeedUnit[] Units { get; } = Enum.GetValues(typeof(SpeedUnit)).Cast<SpeedUnit>().Except(new SpeedUnit[]{ SpeedUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit MeterPerSecond.
         /// </summary>
-        public static Speed Zero { get; } = new Speed(0, BaseUnit);
+        public static Speed<T> Zero { get; } = new Speed<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -170,7 +166,9 @@ public Speed(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -186,176 +184,176 @@ public Speed(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Speed.QuantityType;
+        public QuantityType Type => Speed<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Speed.BaseDimensions;
+        public BaseDimensions Dimensions => Speed<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Speed in CentimetersPerHour.
+        ///     Get <see cref="Speed{T}" /> in CentimetersPerHour.
         /// </summary>
-        public double CentimetersPerHour => As(SpeedUnit.CentimeterPerHour);
+        public T CentimetersPerHour => As(SpeedUnit.CentimeterPerHour);
 
         /// <summary>
-        ///     Get Speed in CentimetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> in CentimetersPerMinutes.
         /// </summary>
-        public double CentimetersPerMinutes => As(SpeedUnit.CentimeterPerMinute);
+        public T CentimetersPerMinutes => As(SpeedUnit.CentimeterPerMinute);
 
         /// <summary>
-        ///     Get Speed in CentimetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> in CentimetersPerSecond.
         /// </summary>
-        public double CentimetersPerSecond => As(SpeedUnit.CentimeterPerSecond);
+        public T CentimetersPerSecond => As(SpeedUnit.CentimeterPerSecond);
 
         /// <summary>
-        ///     Get Speed in DecimetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> in DecimetersPerMinutes.
         /// </summary>
-        public double DecimetersPerMinutes => As(SpeedUnit.DecimeterPerMinute);
+        public T DecimetersPerMinutes => As(SpeedUnit.DecimeterPerMinute);
 
         /// <summary>
-        ///     Get Speed in DecimetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> in DecimetersPerSecond.
         /// </summary>
-        public double DecimetersPerSecond => As(SpeedUnit.DecimeterPerSecond);
+        public T DecimetersPerSecond => As(SpeedUnit.DecimeterPerSecond);
 
         /// <summary>
-        ///     Get Speed in FeetPerHour.
+        ///     Get <see cref="Speed{T}" /> in FeetPerHour.
         /// </summary>
-        public double FeetPerHour => As(SpeedUnit.FootPerHour);
+        public T FeetPerHour => As(SpeedUnit.FootPerHour);
 
         /// <summary>
-        ///     Get Speed in FeetPerMinute.
+        ///     Get <see cref="Speed{T}" /> in FeetPerMinute.
         /// </summary>
-        public double FeetPerMinute => As(SpeedUnit.FootPerMinute);
+        public T FeetPerMinute => As(SpeedUnit.FootPerMinute);
 
         /// <summary>
-        ///     Get Speed in FeetPerSecond.
+        ///     Get <see cref="Speed{T}" /> in FeetPerSecond.
         /// </summary>
-        public double FeetPerSecond => As(SpeedUnit.FootPerSecond);
+        public T FeetPerSecond => As(SpeedUnit.FootPerSecond);
 
         /// <summary>
-        ///     Get Speed in InchesPerHour.
+        ///     Get <see cref="Speed{T}" /> in InchesPerHour.
         /// </summary>
-        public double InchesPerHour => As(SpeedUnit.InchPerHour);
+        public T InchesPerHour => As(SpeedUnit.InchPerHour);
 
         /// <summary>
-        ///     Get Speed in InchesPerMinute.
+        ///     Get <see cref="Speed{T}" /> in InchesPerMinute.
         /// </summary>
-        public double InchesPerMinute => As(SpeedUnit.InchPerMinute);
+        public T InchesPerMinute => As(SpeedUnit.InchPerMinute);
 
         /// <summary>
-        ///     Get Speed in InchesPerSecond.
+        ///     Get <see cref="Speed{T}" /> in InchesPerSecond.
         /// </summary>
-        public double InchesPerSecond => As(SpeedUnit.InchPerSecond);
+        public T InchesPerSecond => As(SpeedUnit.InchPerSecond);
 
         /// <summary>
-        ///     Get Speed in KilometersPerHour.
+        ///     Get <see cref="Speed{T}" /> in KilometersPerHour.
         /// </summary>
-        public double KilometersPerHour => As(SpeedUnit.KilometerPerHour);
+        public T KilometersPerHour => As(SpeedUnit.KilometerPerHour);
 
         /// <summary>
-        ///     Get Speed in KilometersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> in KilometersPerMinutes.
         /// </summary>
-        public double KilometersPerMinutes => As(SpeedUnit.KilometerPerMinute);
+        public T KilometersPerMinutes => As(SpeedUnit.KilometerPerMinute);
 
         /// <summary>
-        ///     Get Speed in KilometersPerSecond.
+        ///     Get <see cref="Speed{T}" /> in KilometersPerSecond.
         /// </summary>
-        public double KilometersPerSecond => As(SpeedUnit.KilometerPerSecond);
+        public T KilometersPerSecond => As(SpeedUnit.KilometerPerSecond);
 
         /// <summary>
-        ///     Get Speed in Knots.
+        ///     Get <see cref="Speed{T}" /> in Knots.
         /// </summary>
-        public double Knots => As(SpeedUnit.Knot);
+        public T Knots => As(SpeedUnit.Knot);
 
         /// <summary>
-        ///     Get Speed in MetersPerHour.
+        ///     Get <see cref="Speed{T}" /> in MetersPerHour.
         /// </summary>
-        public double MetersPerHour => As(SpeedUnit.MeterPerHour);
+        public T MetersPerHour => As(SpeedUnit.MeterPerHour);
 
         /// <summary>
-        ///     Get Speed in MetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> in MetersPerMinutes.
         /// </summary>
-        public double MetersPerMinutes => As(SpeedUnit.MeterPerMinute);
+        public T MetersPerMinutes => As(SpeedUnit.MeterPerMinute);
 
         /// <summary>
-        ///     Get Speed in MetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> in MetersPerSecond.
         /// </summary>
-        public double MetersPerSecond => As(SpeedUnit.MeterPerSecond);
+        public T MetersPerSecond => As(SpeedUnit.MeterPerSecond);
 
         /// <summary>
-        ///     Get Speed in MicrometersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> in MicrometersPerMinutes.
         /// </summary>
-        public double MicrometersPerMinutes => As(SpeedUnit.MicrometerPerMinute);
+        public T MicrometersPerMinutes => As(SpeedUnit.MicrometerPerMinute);
 
         /// <summary>
-        ///     Get Speed in MicrometersPerSecond.
+        ///     Get <see cref="Speed{T}" /> in MicrometersPerSecond.
         /// </summary>
-        public double MicrometersPerSecond => As(SpeedUnit.MicrometerPerSecond);
+        public T MicrometersPerSecond => As(SpeedUnit.MicrometerPerSecond);
 
         /// <summary>
-        ///     Get Speed in MilesPerHour.
+        ///     Get <see cref="Speed{T}" /> in MilesPerHour.
         /// </summary>
-        public double MilesPerHour => As(SpeedUnit.MilePerHour);
+        public T MilesPerHour => As(SpeedUnit.MilePerHour);
 
         /// <summary>
-        ///     Get Speed in MillimetersPerHour.
+        ///     Get <see cref="Speed{T}" /> in MillimetersPerHour.
         /// </summary>
-        public double MillimetersPerHour => As(SpeedUnit.MillimeterPerHour);
+        public T MillimetersPerHour => As(SpeedUnit.MillimeterPerHour);
 
         /// <summary>
-        ///     Get Speed in MillimetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> in MillimetersPerMinutes.
         /// </summary>
-        public double MillimetersPerMinutes => As(SpeedUnit.MillimeterPerMinute);
+        public T MillimetersPerMinutes => As(SpeedUnit.MillimeterPerMinute);
 
         /// <summary>
-        ///     Get Speed in MillimetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> in MillimetersPerSecond.
         /// </summary>
-        public double MillimetersPerSecond => As(SpeedUnit.MillimeterPerSecond);
+        public T MillimetersPerSecond => As(SpeedUnit.MillimeterPerSecond);
 
         /// <summary>
-        ///     Get Speed in NanometersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> in NanometersPerMinutes.
         /// </summary>
-        public double NanometersPerMinutes => As(SpeedUnit.NanometerPerMinute);
+        public T NanometersPerMinutes => As(SpeedUnit.NanometerPerMinute);
 
         /// <summary>
-        ///     Get Speed in NanometersPerSecond.
+        ///     Get <see cref="Speed{T}" /> in NanometersPerSecond.
         /// </summary>
-        public double NanometersPerSecond => As(SpeedUnit.NanometerPerSecond);
+        public T NanometersPerSecond => As(SpeedUnit.NanometerPerSecond);
 
         /// <summary>
-        ///     Get Speed in UsSurveyFeetPerHour.
+        ///     Get <see cref="Speed{T}" /> in UsSurveyFeetPerHour.
         /// </summary>
-        public double UsSurveyFeetPerHour => As(SpeedUnit.UsSurveyFootPerHour);
+        public T UsSurveyFeetPerHour => As(SpeedUnit.UsSurveyFootPerHour);
 
         /// <summary>
-        ///     Get Speed in UsSurveyFeetPerMinute.
+        ///     Get <see cref="Speed{T}" /> in UsSurveyFeetPerMinute.
         /// </summary>
-        public double UsSurveyFeetPerMinute => As(SpeedUnit.UsSurveyFootPerMinute);
+        public T UsSurveyFeetPerMinute => As(SpeedUnit.UsSurveyFootPerMinute);
 
         /// <summary>
-        ///     Get Speed in UsSurveyFeetPerSecond.
+        ///     Get <see cref="Speed{T}" /> in UsSurveyFeetPerSecond.
         /// </summary>
-        public double UsSurveyFeetPerSecond => As(SpeedUnit.UsSurveyFootPerSecond);
+        public T UsSurveyFeetPerSecond => As(SpeedUnit.UsSurveyFootPerSecond);
 
         /// <summary>
-        ///     Get Speed in YardsPerHour.
+        ///     Get <see cref="Speed{T}" /> in YardsPerHour.
         /// </summary>
-        public double YardsPerHour => As(SpeedUnit.YardPerHour);
+        public T YardsPerHour => As(SpeedUnit.YardPerHour);
 
         /// <summary>
-        ///     Get Speed in YardsPerMinute.
+        ///     Get <see cref="Speed{T}" /> in YardsPerMinute.
         /// </summary>
-        public double YardsPerMinute => As(SpeedUnit.YardPerMinute);
+        public T YardsPerMinute => As(SpeedUnit.YardPerMinute);
 
         /// <summary>
-        ///     Get Speed in YardsPerSecond.
+        ///     Get <see cref="Speed{T}" /> in YardsPerSecond.
         /// </summary>
-        public double YardsPerSecond => As(SpeedUnit.YardPerSecond);
+        public T YardsPerSecond => As(SpeedUnit.YardPerSecond);
 
         #endregion
 
@@ -387,303 +385,271 @@ public static string GetAbbreviation(SpeedUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Speed from CentimetersPerHour.
+        ///     Get <see cref="Speed{T}" /> from CentimetersPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerHour(QuantityValue centimetersperhour)
+        public static Speed<T> FromCentimetersPerHour(T centimetersperhour)
         {
-            double value = (double) centimetersperhour;
-            return new Speed(value, SpeedUnit.CentimeterPerHour);
+            return new Speed<T>(centimetersperhour, SpeedUnit.CentimeterPerHour);
         }
         /// <summary>
-        ///     Get Speed from CentimetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> from CentimetersPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerMinutes(QuantityValue centimetersperminutes)
+        public static Speed<T> FromCentimetersPerMinutes(T centimetersperminutes)
         {
-            double value = (double) centimetersperminutes;
-            return new Speed(value, SpeedUnit.CentimeterPerMinute);
+            return new Speed<T>(centimetersperminutes, SpeedUnit.CentimeterPerMinute);
         }
         /// <summary>
-        ///     Get Speed from CentimetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> from CentimetersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerSecond(QuantityValue centimeterspersecond)
+        public static Speed<T> FromCentimetersPerSecond(T centimeterspersecond)
         {
-            double value = (double) centimeterspersecond;
-            return new Speed(value, SpeedUnit.CentimeterPerSecond);
+            return new Speed<T>(centimeterspersecond, SpeedUnit.CentimeterPerSecond);
         }
         /// <summary>
-        ///     Get Speed from DecimetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> from DecimetersPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromDecimetersPerMinutes(QuantityValue decimetersperminutes)
+        public static Speed<T> FromDecimetersPerMinutes(T decimetersperminutes)
         {
-            double value = (double) decimetersperminutes;
-            return new Speed(value, SpeedUnit.DecimeterPerMinute);
+            return new Speed<T>(decimetersperminutes, SpeedUnit.DecimeterPerMinute);
         }
         /// <summary>
-        ///     Get Speed from DecimetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> from DecimetersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromDecimetersPerSecond(QuantityValue decimeterspersecond)
+        public static Speed<T> FromDecimetersPerSecond(T decimeterspersecond)
         {
-            double value = (double) decimeterspersecond;
-            return new Speed(value, SpeedUnit.DecimeterPerSecond);
+            return new Speed<T>(decimeterspersecond, SpeedUnit.DecimeterPerSecond);
         }
         /// <summary>
-        ///     Get Speed from FeetPerHour.
+        ///     Get <see cref="Speed{T}" /> from FeetPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerHour(QuantityValue feetperhour)
+        public static Speed<T> FromFeetPerHour(T feetperhour)
         {
-            double value = (double) feetperhour;
-            return new Speed(value, SpeedUnit.FootPerHour);
+            return new Speed<T>(feetperhour, SpeedUnit.FootPerHour);
         }
         /// <summary>
-        ///     Get Speed from FeetPerMinute.
+        ///     Get <see cref="Speed{T}" /> from FeetPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerMinute(QuantityValue feetperminute)
+        public static Speed<T> FromFeetPerMinute(T feetperminute)
         {
-            double value = (double) feetperminute;
-            return new Speed(value, SpeedUnit.FootPerMinute);
+            return new Speed<T>(feetperminute, SpeedUnit.FootPerMinute);
         }
         /// <summary>
-        ///     Get Speed from FeetPerSecond.
+        ///     Get <see cref="Speed{T}" /> from FeetPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerSecond(QuantityValue feetpersecond)
+        public static Speed<T> FromFeetPerSecond(T feetpersecond)
         {
-            double value = (double) feetpersecond;
-            return new Speed(value, SpeedUnit.FootPerSecond);
+            return new Speed<T>(feetpersecond, SpeedUnit.FootPerSecond);
         }
         /// <summary>
-        ///     Get Speed from InchesPerHour.
+        ///     Get <see cref="Speed{T}" /> from InchesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerHour(QuantityValue inchesperhour)
+        public static Speed<T> FromInchesPerHour(T inchesperhour)
         {
-            double value = (double) inchesperhour;
-            return new Speed(value, SpeedUnit.InchPerHour);
+            return new Speed<T>(inchesperhour, SpeedUnit.InchPerHour);
         }
         /// <summary>
-        ///     Get Speed from InchesPerMinute.
+        ///     Get <see cref="Speed{T}" /> from InchesPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerMinute(QuantityValue inchesperminute)
+        public static Speed<T> FromInchesPerMinute(T inchesperminute)
         {
-            double value = (double) inchesperminute;
-            return new Speed(value, SpeedUnit.InchPerMinute);
+            return new Speed<T>(inchesperminute, SpeedUnit.InchPerMinute);
         }
         /// <summary>
-        ///     Get Speed from InchesPerSecond.
+        ///     Get <see cref="Speed{T}" /> from InchesPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerSecond(QuantityValue inchespersecond)
+        public static Speed<T> FromInchesPerSecond(T inchespersecond)
         {
-            double value = (double) inchespersecond;
-            return new Speed(value, SpeedUnit.InchPerSecond);
+            return new Speed<T>(inchespersecond, SpeedUnit.InchPerSecond);
         }
         /// <summary>
-        ///     Get Speed from KilometersPerHour.
+        ///     Get <see cref="Speed{T}" /> from KilometersPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerHour(QuantityValue kilometersperhour)
+        public static Speed<T> FromKilometersPerHour(T kilometersperhour)
         {
-            double value = (double) kilometersperhour;
-            return new Speed(value, SpeedUnit.KilometerPerHour);
+            return new Speed<T>(kilometersperhour, SpeedUnit.KilometerPerHour);
         }
         /// <summary>
-        ///     Get Speed from KilometersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> from KilometersPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerMinutes(QuantityValue kilometersperminutes)
+        public static Speed<T> FromKilometersPerMinutes(T kilometersperminutes)
         {
-            double value = (double) kilometersperminutes;
-            return new Speed(value, SpeedUnit.KilometerPerMinute);
+            return new Speed<T>(kilometersperminutes, SpeedUnit.KilometerPerMinute);
         }
         /// <summary>
-        ///     Get Speed from KilometersPerSecond.
+        ///     Get <see cref="Speed{T}" /> from KilometersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerSecond(QuantityValue kilometerspersecond)
+        public static Speed<T> FromKilometersPerSecond(T kilometerspersecond)
         {
-            double value = (double) kilometerspersecond;
-            return new Speed(value, SpeedUnit.KilometerPerSecond);
+            return new Speed<T>(kilometerspersecond, SpeedUnit.KilometerPerSecond);
         }
         /// <summary>
-        ///     Get Speed from Knots.
+        ///     Get <see cref="Speed{T}" /> from Knots.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKnots(QuantityValue knots)
+        public static Speed<T> FromKnots(T knots)
         {
-            double value = (double) knots;
-            return new Speed(value, SpeedUnit.Knot);
+            return new Speed<T>(knots, SpeedUnit.Knot);
         }
         /// <summary>
-        ///     Get Speed from MetersPerHour.
+        ///     Get <see cref="Speed{T}" /> from MetersPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerHour(QuantityValue metersperhour)
+        public static Speed<T> FromMetersPerHour(T metersperhour)
         {
-            double value = (double) metersperhour;
-            return new Speed(value, SpeedUnit.MeterPerHour);
+            return new Speed<T>(metersperhour, SpeedUnit.MeterPerHour);
         }
         /// <summary>
-        ///     Get Speed from MetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> from MetersPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerMinutes(QuantityValue metersperminutes)
+        public static Speed<T> FromMetersPerMinutes(T metersperminutes)
         {
-            double value = (double) metersperminutes;
-            return new Speed(value, SpeedUnit.MeterPerMinute);
+            return new Speed<T>(metersperminutes, SpeedUnit.MeterPerMinute);
         }
         /// <summary>
-        ///     Get Speed from MetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> from MetersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerSecond(QuantityValue meterspersecond)
+        public static Speed<T> FromMetersPerSecond(T meterspersecond)
         {
-            double value = (double) meterspersecond;
-            return new Speed(value, SpeedUnit.MeterPerSecond);
+            return new Speed<T>(meterspersecond, SpeedUnit.MeterPerSecond);
         }
         /// <summary>
-        ///     Get Speed from MicrometersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> from MicrometersPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMicrometersPerMinutes(QuantityValue micrometersperminutes)
+        public static Speed<T> FromMicrometersPerMinutes(T micrometersperminutes)
         {
-            double value = (double) micrometersperminutes;
-            return new Speed(value, SpeedUnit.MicrometerPerMinute);
+            return new Speed<T>(micrometersperminutes, SpeedUnit.MicrometerPerMinute);
         }
         /// <summary>
-        ///     Get Speed from MicrometersPerSecond.
+        ///     Get <see cref="Speed{T}" /> from MicrometersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMicrometersPerSecond(QuantityValue micrometerspersecond)
+        public static Speed<T> FromMicrometersPerSecond(T micrometerspersecond)
         {
-            double value = (double) micrometerspersecond;
-            return new Speed(value, SpeedUnit.MicrometerPerSecond);
+            return new Speed<T>(micrometerspersecond, SpeedUnit.MicrometerPerSecond);
         }
         /// <summary>
-        ///     Get Speed from MilesPerHour.
+        ///     Get <see cref="Speed{T}" /> from MilesPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMilesPerHour(QuantityValue milesperhour)
+        public static Speed<T> FromMilesPerHour(T milesperhour)
         {
-            double value = (double) milesperhour;
-            return new Speed(value, SpeedUnit.MilePerHour);
+            return new Speed<T>(milesperhour, SpeedUnit.MilePerHour);
         }
         /// <summary>
-        ///     Get Speed from MillimetersPerHour.
+        ///     Get <see cref="Speed{T}" /> from MillimetersPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerHour(QuantityValue millimetersperhour)
+        public static Speed<T> FromMillimetersPerHour(T millimetersperhour)
         {
-            double value = (double) millimetersperhour;
-            return new Speed(value, SpeedUnit.MillimeterPerHour);
+            return new Speed<T>(millimetersperhour, SpeedUnit.MillimeterPerHour);
         }
         /// <summary>
-        ///     Get Speed from MillimetersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> from MillimetersPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerMinutes(QuantityValue millimetersperminutes)
+        public static Speed<T> FromMillimetersPerMinutes(T millimetersperminutes)
         {
-            double value = (double) millimetersperminutes;
-            return new Speed(value, SpeedUnit.MillimeterPerMinute);
+            return new Speed<T>(millimetersperminutes, SpeedUnit.MillimeterPerMinute);
         }
         /// <summary>
-        ///     Get Speed from MillimetersPerSecond.
+        ///     Get <see cref="Speed{T}" /> from MillimetersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerSecond(QuantityValue millimeterspersecond)
+        public static Speed<T> FromMillimetersPerSecond(T millimeterspersecond)
         {
-            double value = (double) millimeterspersecond;
-            return new Speed(value, SpeedUnit.MillimeterPerSecond);
+            return new Speed<T>(millimeterspersecond, SpeedUnit.MillimeterPerSecond);
         }
         /// <summary>
-        ///     Get Speed from NanometersPerMinutes.
+        ///     Get <see cref="Speed{T}" /> from NanometersPerMinutes.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromNanometersPerMinutes(QuantityValue nanometersperminutes)
+        public static Speed<T> FromNanometersPerMinutes(T nanometersperminutes)
         {
-            double value = (double) nanometersperminutes;
-            return new Speed(value, SpeedUnit.NanometerPerMinute);
+            return new Speed<T>(nanometersperminutes, SpeedUnit.NanometerPerMinute);
         }
         /// <summary>
-        ///     Get Speed from NanometersPerSecond.
+        ///     Get <see cref="Speed{T}" /> from NanometersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromNanometersPerSecond(QuantityValue nanometerspersecond)
+        public static Speed<T> FromNanometersPerSecond(T nanometerspersecond)
         {
-            double value = (double) nanometerspersecond;
-            return new Speed(value, SpeedUnit.NanometerPerSecond);
+            return new Speed<T>(nanometerspersecond, SpeedUnit.NanometerPerSecond);
         }
         /// <summary>
-        ///     Get Speed from UsSurveyFeetPerHour.
+        ///     Get <see cref="Speed{T}" /> from UsSurveyFeetPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerHour(QuantityValue ussurveyfeetperhour)
+        public static Speed<T> FromUsSurveyFeetPerHour(T ussurveyfeetperhour)
         {
-            double value = (double) ussurveyfeetperhour;
-            return new Speed(value, SpeedUnit.UsSurveyFootPerHour);
+            return new Speed<T>(ussurveyfeetperhour, SpeedUnit.UsSurveyFootPerHour);
         }
         /// <summary>
-        ///     Get Speed from UsSurveyFeetPerMinute.
+        ///     Get <see cref="Speed{T}" /> from UsSurveyFeetPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerMinute(QuantityValue ussurveyfeetperminute)
+        public static Speed<T> FromUsSurveyFeetPerMinute(T ussurveyfeetperminute)
         {
-            double value = (double) ussurveyfeetperminute;
-            return new Speed(value, SpeedUnit.UsSurveyFootPerMinute);
+            return new Speed<T>(ussurveyfeetperminute, SpeedUnit.UsSurveyFootPerMinute);
         }
         /// <summary>
-        ///     Get Speed from UsSurveyFeetPerSecond.
+        ///     Get <see cref="Speed{T}" /> from UsSurveyFeetPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerSecond(QuantityValue ussurveyfeetpersecond)
+        public static Speed<T> FromUsSurveyFeetPerSecond(T ussurveyfeetpersecond)
         {
-            double value = (double) ussurveyfeetpersecond;
-            return new Speed(value, SpeedUnit.UsSurveyFootPerSecond);
+            return new Speed<T>(ussurveyfeetpersecond, SpeedUnit.UsSurveyFootPerSecond);
         }
         /// <summary>
-        ///     Get Speed from YardsPerHour.
+        ///     Get <see cref="Speed{T}" /> from YardsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerHour(QuantityValue yardsperhour)
+        public static Speed<T> FromYardsPerHour(T yardsperhour)
         {
-            double value = (double) yardsperhour;
-            return new Speed(value, SpeedUnit.YardPerHour);
+            return new Speed<T>(yardsperhour, SpeedUnit.YardPerHour);
         }
         /// <summary>
-        ///     Get Speed from YardsPerMinute.
+        ///     Get <see cref="Speed{T}" /> from YardsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerMinute(QuantityValue yardsperminute)
+        public static Speed<T> FromYardsPerMinute(T yardsperminute)
         {
-            double value = (double) yardsperminute;
-            return new Speed(value, SpeedUnit.YardPerMinute);
+            return new Speed<T>(yardsperminute, SpeedUnit.YardPerMinute);
         }
         /// <summary>
-        ///     Get Speed from YardsPerSecond.
+        ///     Get <see cref="Speed{T}" /> from YardsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerSecond(QuantityValue yardspersecond)
+        public static Speed<T> FromYardsPerSecond(T yardspersecond)
         {
-            double value = (double) yardspersecond;
-            return new Speed(value, SpeedUnit.YardPerSecond);
+            return new Speed<T>(yardspersecond, SpeedUnit.YardPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpeedUnit" /> to <see cref="Speed" />.
+        ///     Dynamically convert from value and unit enum <see cref="SpeedUnit" /> to <see cref="Speed{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Speed unit value.</returns>
-        public static Speed From(QuantityValue value, SpeedUnit fromUnit)
+        /// <returns><see cref="Speed{T}" /> unit value.</returns>
+        public static Speed<T> From(T value, SpeedUnit fromUnit)
         {
-            return new Speed((double)value, fromUnit);
+            return new Speed<T>(value, fromUnit);
         }
 
         #endregion
@@ -712,7 +678,7 @@ public static Speed From(QuantityValue value, SpeedUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Speed Parse(string str)
+        public static Speed<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -740,9 +706,9 @@ public static Speed Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Speed Parse(string str, IFormatProvider? provider)
+        public static Speed<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Speed, SpeedUnit>(
+            return QuantityParser.Default.Parse<T, Speed<T>, SpeedUnit>(
                 str,
                 provider,
                 From);
@@ -756,7 +722,7 @@ public static Speed Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Speed result)
+        public static bool TryParse(string? str, out Speed<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -771,9 +737,9 @@ public static bool TryParse(string? str, out Speed result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Speed result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Speed<T> result)
         {
-            return QuantityParser.Default.TryParse<Speed, SpeedUnit>(
+            return QuantityParser.Default.TryParse<T, Speed<T>, SpeedUnit>(
                 str,
                 provider,
                 From,
@@ -835,45 +801,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speed
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Speed operator -(Speed right)
+        public static Speed<T> operator -(Speed<T> right)
         {
-            return new Speed(-right.Value, right.Unit);
+            return new Speed<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Speed"/> from adding two <see cref="Speed"/>.</summary>
-        public static Speed operator +(Speed left, Speed right)
+        /// <summary>Get <see cref="Speed{T}"/> from adding two <see cref="Speed{T}"/>.</summary>
+        public static Speed<T> operator +(Speed<T> left, Speed<T> right)
         {
-            return new Speed(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Speed<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Speed"/> from subtracting two <see cref="Speed"/>.</summary>
-        public static Speed operator -(Speed left, Speed right)
+        /// <summary>Get <see cref="Speed{T}"/> from subtracting two <see cref="Speed{T}"/>.</summary>
+        public static Speed<T> operator -(Speed<T> left, Speed<T> right)
         {
-            return new Speed(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Speed<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Speed"/> from multiplying value and <see cref="Speed"/>.</summary>
-        public static Speed operator *(double left, Speed right)
+        /// <summary>Get <see cref="Speed{T}"/> from multiplying value and <see cref="Speed{T}"/>.</summary>
+        public static Speed<T> operator *(T left, Speed<T> right)
         {
-            return new Speed(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Speed<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Speed"/> from multiplying value and <see cref="Speed"/>.</summary>
-        public static Speed operator *(Speed left, double right)
+        /// <summary>Get <see cref="Speed{T}"/> from multiplying value and <see cref="Speed{T}"/>.</summary>
+        public static Speed<T> operator *(Speed<T> left, T right)
         {
-            return new Speed(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Speed<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Speed"/> from dividing <see cref="Speed"/> by value.</summary>
-        public static Speed operator /(Speed left, double right)
+        /// <summary>Get <see cref="Speed{T}"/> from dividing <see cref="Speed{T}"/> by value.</summary>
+        public static Speed<T> operator /(Speed<T> left, T right)
         {
-            return new Speed(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Speed<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Speed"/> by <see cref="Speed"/>.</summary>
-        public static double operator /(Speed left, Speed right)
+        /// <summary>Get ratio value from dividing <see cref="Speed{T}"/> by <see cref="Speed{T}"/>.</summary>
+        public static T operator /(Speed<T> left, Speed<T> right)
         {
-            return left.MetersPerSecond / right.MetersPerSecond;
+            return CompiledLambdas.Divide(left.MetersPerSecond, right.MetersPerSecond);
         }
 
         #endregion
@@ -881,39 +852,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speed
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Speed left, Speed right)
+        public static bool operator <=(Speed<T> left, Speed<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Speed left, Speed right)
+        public static bool operator >=(Speed<T> left, Speed<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Speed left, Speed right)
+        public static bool operator <(Speed<T> left, Speed<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Speed left, Speed right)
+        public static bool operator >(Speed<T> left, Speed<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Speed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Speed left, Speed right)
+        /// <remarks>Consider using <see cref="Equals(Speed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Speed<T> left, Speed<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Speed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Speed left, Speed right)
+        /// <remarks>Consider using <see cref="Equals(Speed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Speed<T> left, Speed<T> right)
         {
             return !(left == right);
         }
@@ -922,37 +893,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Speed
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Speed objSpeed)) throw new ArgumentException("Expected type Speed.", nameof(obj));
+            if(!(obj is Speed<T> objSpeed)) throw new ArgumentException("Expected type Speed.", nameof(obj));
 
             return CompareTo(objSpeed);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Speed other)
+        public int CompareTo(Speed<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Speed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Speed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Speed objSpeed))
+            if(obj is null || !(obj is Speed<T> objSpeed))
                 return false;
 
             return Equals(objSpeed);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Speed, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Speed other)
+        /// <remarks>Consider using <see cref="Equals(Speed{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Speed<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Speed within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Speed{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -990,21 +961,19 @@ public bool Equals(Speed other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Speed other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Speed<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Speed.</returns>
+        /// <returns>A hash code for the current <see cref="Speed{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1018,17 +987,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpeedUnit unit)
+        public T As(SpeedUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1048,17 +1017,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is SpeedUnit unitAsSpeedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpeedUnit)} is supported.", nameof(unit));
 
-            return As(unitAsSpeedUnit);
+            var asValue = As(unitAsSpeedUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<SpeedUnit>.As(SpeedUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Speed to another Speed with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Speed{T}" /> to another <see cref="Speed{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Speed with the specified unit.</returns>
-        public Speed ToUnit(SpeedUnit unit)
+        /// <returns>A <see cref="Speed{T}" /> with the specified unit.</returns>
+        public Speed<T> ToUnit(SpeedUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Speed(convertedValue, unit);
+            return new Speed<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1071,7 +1045,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Speed ToUnit(UnitSystem unitSystem)
+        public Speed<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1091,50 +1065,56 @@ public Speed ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpeedUnit> IQuantity<SpeedUnit>.ToUnit(SpeedUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<SpeedUnit, T> IQuantityT<SpeedUnit, T>.ToUnit(SpeedUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<SpeedUnit> IQuantity<SpeedUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<SpeedUnit, T> IQuantityT<SpeedUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case SpeedUnit.CentimeterPerHour: return (_value/3600) * 1e-2d;
-                case SpeedUnit.CentimeterPerMinute: return (_value/60) * 1e-2d;
-                case SpeedUnit.CentimeterPerSecond: return (_value) * 1e-2d;
-                case SpeedUnit.DecimeterPerMinute: return (_value/60) * 1e-1d;
-                case SpeedUnit.DecimeterPerSecond: return (_value) * 1e-1d;
-                case SpeedUnit.FootPerHour: return _value*0.3048/3600;
-                case SpeedUnit.FootPerMinute: return _value*0.3048/60;
-                case SpeedUnit.FootPerSecond: return _value*0.3048;
-                case SpeedUnit.InchPerHour: return (_value/3600)*2.54e-2;
-                case SpeedUnit.InchPerMinute: return (_value/60)*2.54e-2;
-                case SpeedUnit.InchPerSecond: return _value*2.54e-2;
-                case SpeedUnit.KilometerPerHour: return (_value/3600) * 1e3d;
-                case SpeedUnit.KilometerPerMinute: return (_value/60) * 1e3d;
-                case SpeedUnit.KilometerPerSecond: return (_value) * 1e3d;
-                case SpeedUnit.Knot: return _value*0.514444;
-                case SpeedUnit.MeterPerHour: return _value/3600;
-                case SpeedUnit.MeterPerMinute: return _value/60;
-                case SpeedUnit.MeterPerSecond: return _value;
-                case SpeedUnit.MicrometerPerMinute: return (_value/60) * 1e-6d;
-                case SpeedUnit.MicrometerPerSecond: return (_value) * 1e-6d;
-                case SpeedUnit.MilePerHour: return _value*0.44704;
-                case SpeedUnit.MillimeterPerHour: return (_value/3600) * 1e-3d;
-                case SpeedUnit.MillimeterPerMinute: return (_value/60) * 1e-3d;
-                case SpeedUnit.MillimeterPerSecond: return (_value) * 1e-3d;
-                case SpeedUnit.NanometerPerMinute: return (_value/60) * 1e-9d;
-                case SpeedUnit.NanometerPerSecond: return (_value) * 1e-9d;
-                case SpeedUnit.UsSurveyFootPerHour: return (_value*1200/3937)/3600;
-                case SpeedUnit.UsSurveyFootPerMinute: return (_value*1200/3937)/60;
-                case SpeedUnit.UsSurveyFootPerSecond: return _value*1200/3937;
-                case SpeedUnit.YardPerHour: return _value*0.9144/3600;
-                case SpeedUnit.YardPerMinute: return _value*0.9144/60;
-                case SpeedUnit.YardPerSecond: return _value*0.9144;
+                case SpeedUnit.CentimeterPerHour: return (Value/3600) * 1e-2d;
+                case SpeedUnit.CentimeterPerMinute: return (Value/60) * 1e-2d;
+                case SpeedUnit.CentimeterPerSecond: return (Value) * 1e-2d;
+                case SpeedUnit.DecimeterPerMinute: return (Value/60) * 1e-1d;
+                case SpeedUnit.DecimeterPerSecond: return (Value) * 1e-1d;
+                case SpeedUnit.FootPerHour: return Value*0.3048/3600;
+                case SpeedUnit.FootPerMinute: return Value*0.3048/60;
+                case SpeedUnit.FootPerSecond: return Value*0.3048;
+                case SpeedUnit.InchPerHour: return (Value/3600)*2.54e-2;
+                case SpeedUnit.InchPerMinute: return (Value/60)*2.54e-2;
+                case SpeedUnit.InchPerSecond: return Value*2.54e-2;
+                case SpeedUnit.KilometerPerHour: return (Value/3600) * 1e3d;
+                case SpeedUnit.KilometerPerMinute: return (Value/60) * 1e3d;
+                case SpeedUnit.KilometerPerSecond: return (Value) * 1e3d;
+                case SpeedUnit.Knot: return Value*0.514444;
+                case SpeedUnit.MeterPerHour: return Value/3600;
+                case SpeedUnit.MeterPerMinute: return Value/60;
+                case SpeedUnit.MeterPerSecond: return Value;
+                case SpeedUnit.MicrometerPerMinute: return (Value/60) * 1e-6d;
+                case SpeedUnit.MicrometerPerSecond: return (Value) * 1e-6d;
+                case SpeedUnit.MilePerHour: return Value*0.44704;
+                case SpeedUnit.MillimeterPerHour: return (Value/3600) * 1e-3d;
+                case SpeedUnit.MillimeterPerMinute: return (Value/60) * 1e-3d;
+                case SpeedUnit.MillimeterPerSecond: return (Value) * 1e-3d;
+                case SpeedUnit.NanometerPerMinute: return (Value/60) * 1e-9d;
+                case SpeedUnit.NanometerPerSecond: return (Value) * 1e-9d;
+                case SpeedUnit.UsSurveyFootPerHour: return (Value*1200/3937)/3600;
+                case SpeedUnit.UsSurveyFootPerMinute: return (Value*1200/3937)/60;
+                case SpeedUnit.UsSurveyFootPerSecond: return Value*1200/3937;
+                case SpeedUnit.YardPerHour: return Value*0.9144/3600;
+                case SpeedUnit.YardPerMinute: return Value*0.9144/60;
+                case SpeedUnit.YardPerSecond: return Value*0.9144;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1145,16 +1125,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Speed ToBaseUnit()
+        internal Speed<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Speed(baseUnitValue, BaseUnit);
+            return new Speed<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(SpeedUnit unit)
+        private T GetValueAs(SpeedUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1288,57 +1268,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Speed)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Speed<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Speed)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Speed<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Speed)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Speed<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1348,33 +1328,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Speed))
+            if(conversionType == typeof(Speed<T>))
                 return this;
             else if(conversionType == typeof(SpeedUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Speed.QuantityType;
+                return Speed<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Speed.Info;
+                return Speed<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Speed.BaseDimensions;
+                return Speed<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Speed)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Speed<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
index 1eff9c3275..e1527c263c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     A temperature is a numerical measure of hot or cold. Its measurement is by detection of heat radiation or particle velocity or kinetic energy, or by the bulk behavior of a thermometric material. It may be calibrated in any of various temperature scales, Celsius, Fahrenheit, Kelvin, etc. The fundamental physical definition of temperature is provided by thermodynamics.
     /// </summary>
-    public partial struct Temperature : IQuantity<TemperatureUnit>, IEquatable<Temperature>, IComparable, IComparable<Temperature>, IConvertible, IFormattable
+    public partial struct Temperature<T> : IQuantityT<TemperatureUnit, T>, IEquatable<Temperature<T>>, IComparable, IComparable<Temperature<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -72,12 +68,12 @@ static Temperature()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Temperature(double value, TemperatureUnit unit)
+        public Temperature(T value, TemperatureUnit unit)
         {
             if(unit == TemperatureUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -89,14 +85,14 @@ public Temperature(double value, TemperatureUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Temperature(double value, UnitSystem unitSystem)
+        public Temperature(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -111,19 +107,19 @@ public Temperature(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Temperature, which is Kelvin. All conversions go via this value.
+        ///     The base unit of <see cref="Temperature{T}" />, which is Kelvin. All conversions go via this value.
         /// </summary>
         public static TemperatureUnit BaseUnit { get; } = TemperatureUnit.Kelvin;
 
         /// <summary>
-        /// Represents the largest possible value of Temperature
+        /// Represents the largest possible value of <see cref="Temperature{T}" />
         /// </summary>
-        public static Temperature MaxValue { get; } = new Temperature(double.MaxValue, BaseUnit);
+        public static Temperature<T> MaxValue { get; } = new Temperature<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Temperature
+        /// Represents the smallest possible value of <see cref="Temperature{T}" />
         /// </summary>
-        public static Temperature MinValue { get; } = new Temperature(double.MinValue, BaseUnit);
+        public static Temperature<T> MinValue { get; } = new Temperature<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -132,14 +128,14 @@ public Temperature(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Temperature;
 
         /// <summary>
-        ///     All units of measurement for the Temperature quantity.
+        ///     All units of measurement for the <see cref="Temperature{T}" /> quantity.
         /// </summary>
         public static TemperatureUnit[] Units { get; } = Enum.GetValues(typeof(TemperatureUnit)).Cast<TemperatureUnit>().Except(new TemperatureUnit[]{ TemperatureUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Kelvin.
         /// </summary>
-        public static Temperature Zero { get; } = new Temperature(0, BaseUnit);
+        public static Temperature<T> Zero { get; } = new Temperature<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -148,7 +144,9 @@ public Temperature(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -164,66 +162,66 @@ public Temperature(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Temperature.QuantityType;
+        public QuantityType Type => Temperature<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Temperature.BaseDimensions;
+        public BaseDimensions Dimensions => Temperature<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Temperature in DegreesCelsius.
+        ///     Get <see cref="Temperature{T}" /> in DegreesCelsius.
         /// </summary>
-        public double DegreesCelsius => As(TemperatureUnit.DegreeCelsius);
+        public T DegreesCelsius => As(TemperatureUnit.DegreeCelsius);
 
         /// <summary>
-        ///     Get Temperature in DegreesDelisle.
+        ///     Get <see cref="Temperature{T}" /> in DegreesDelisle.
         /// </summary>
-        public double DegreesDelisle => As(TemperatureUnit.DegreeDelisle);
+        public T DegreesDelisle => As(TemperatureUnit.DegreeDelisle);
 
         /// <summary>
-        ///     Get Temperature in DegreesFahrenheit.
+        ///     Get <see cref="Temperature{T}" /> in DegreesFahrenheit.
         /// </summary>
-        public double DegreesFahrenheit => As(TemperatureUnit.DegreeFahrenheit);
+        public T DegreesFahrenheit => As(TemperatureUnit.DegreeFahrenheit);
 
         /// <summary>
-        ///     Get Temperature in DegreesNewton.
+        ///     Get <see cref="Temperature{T}" /> in DegreesNewton.
         /// </summary>
-        public double DegreesNewton => As(TemperatureUnit.DegreeNewton);
+        public T DegreesNewton => As(TemperatureUnit.DegreeNewton);
 
         /// <summary>
-        ///     Get Temperature in DegreesRankine.
+        ///     Get <see cref="Temperature{T}" /> in DegreesRankine.
         /// </summary>
-        public double DegreesRankine => As(TemperatureUnit.DegreeRankine);
+        public T DegreesRankine => As(TemperatureUnit.DegreeRankine);
 
         /// <summary>
-        ///     Get Temperature in DegreesReaumur.
+        ///     Get <see cref="Temperature{T}" /> in DegreesReaumur.
         /// </summary>
-        public double DegreesReaumur => As(TemperatureUnit.DegreeReaumur);
+        public T DegreesReaumur => As(TemperatureUnit.DegreeReaumur);
 
         /// <summary>
-        ///     Get Temperature in DegreesRoemer.
+        ///     Get <see cref="Temperature{T}" /> in DegreesRoemer.
         /// </summary>
-        public double DegreesRoemer => As(TemperatureUnit.DegreeRoemer);
+        public T DegreesRoemer => As(TemperatureUnit.DegreeRoemer);
 
         /// <summary>
-        ///     Get Temperature in Kelvins.
+        ///     Get <see cref="Temperature{T}" /> in Kelvins.
         /// </summary>
-        public double Kelvins => As(TemperatureUnit.Kelvin);
+        public T Kelvins => As(TemperatureUnit.Kelvin);
 
         /// <summary>
-        ///     Get Temperature in MillidegreesCelsius.
+        ///     Get <see cref="Temperature{T}" /> in MillidegreesCelsius.
         /// </summary>
-        public double MillidegreesCelsius => As(TemperatureUnit.MillidegreeCelsius);
+        public T MillidegreesCelsius => As(TemperatureUnit.MillidegreeCelsius);
 
         /// <summary>
-        ///     Get Temperature in SolarTemperatures.
+        ///     Get <see cref="Temperature{T}" /> in SolarTemperatures.
         /// </summary>
-        public double SolarTemperatures => As(TemperatureUnit.SolarTemperature);
+        public T SolarTemperatures => As(TemperatureUnit.SolarTemperature);
 
         #endregion
 
@@ -255,105 +253,95 @@ public static string GetAbbreviation(TemperatureUnit unit, IFormatProvider? prov
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Temperature from DegreesCelsius.
+        ///     Get <see cref="Temperature{T}" /> from DegreesCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesCelsius(QuantityValue degreescelsius)
+        public static Temperature<T> FromDegreesCelsius(T degreescelsius)
         {
-            double value = (double) degreescelsius;
-            return new Temperature(value, TemperatureUnit.DegreeCelsius);
+            return new Temperature<T>(degreescelsius, TemperatureUnit.DegreeCelsius);
         }
         /// <summary>
-        ///     Get Temperature from DegreesDelisle.
+        ///     Get <see cref="Temperature{T}" /> from DegreesDelisle.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesDelisle(QuantityValue degreesdelisle)
+        public static Temperature<T> FromDegreesDelisle(T degreesdelisle)
         {
-            double value = (double) degreesdelisle;
-            return new Temperature(value, TemperatureUnit.DegreeDelisle);
+            return new Temperature<T>(degreesdelisle, TemperatureUnit.DegreeDelisle);
         }
         /// <summary>
-        ///     Get Temperature from DegreesFahrenheit.
+        ///     Get <see cref="Temperature{T}" /> from DegreesFahrenheit.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesFahrenheit(QuantityValue degreesfahrenheit)
+        public static Temperature<T> FromDegreesFahrenheit(T degreesfahrenheit)
         {
-            double value = (double) degreesfahrenheit;
-            return new Temperature(value, TemperatureUnit.DegreeFahrenheit);
+            return new Temperature<T>(degreesfahrenheit, TemperatureUnit.DegreeFahrenheit);
         }
         /// <summary>
-        ///     Get Temperature from DegreesNewton.
+        ///     Get <see cref="Temperature{T}" /> from DegreesNewton.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesNewton(QuantityValue degreesnewton)
+        public static Temperature<T> FromDegreesNewton(T degreesnewton)
         {
-            double value = (double) degreesnewton;
-            return new Temperature(value, TemperatureUnit.DegreeNewton);
+            return new Temperature<T>(degreesnewton, TemperatureUnit.DegreeNewton);
         }
         /// <summary>
-        ///     Get Temperature from DegreesRankine.
+        ///     Get <see cref="Temperature{T}" /> from DegreesRankine.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesRankine(QuantityValue degreesrankine)
+        public static Temperature<T> FromDegreesRankine(T degreesrankine)
         {
-            double value = (double) degreesrankine;
-            return new Temperature(value, TemperatureUnit.DegreeRankine);
+            return new Temperature<T>(degreesrankine, TemperatureUnit.DegreeRankine);
         }
         /// <summary>
-        ///     Get Temperature from DegreesReaumur.
+        ///     Get <see cref="Temperature{T}" /> from DegreesReaumur.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesReaumur(QuantityValue degreesreaumur)
+        public static Temperature<T> FromDegreesReaumur(T degreesreaumur)
         {
-            double value = (double) degreesreaumur;
-            return new Temperature(value, TemperatureUnit.DegreeReaumur);
+            return new Temperature<T>(degreesreaumur, TemperatureUnit.DegreeReaumur);
         }
         /// <summary>
-        ///     Get Temperature from DegreesRoemer.
+        ///     Get <see cref="Temperature{T}" /> from DegreesRoemer.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesRoemer(QuantityValue degreesroemer)
+        public static Temperature<T> FromDegreesRoemer(T degreesroemer)
         {
-            double value = (double) degreesroemer;
-            return new Temperature(value, TemperatureUnit.DegreeRoemer);
+            return new Temperature<T>(degreesroemer, TemperatureUnit.DegreeRoemer);
         }
         /// <summary>
-        ///     Get Temperature from Kelvins.
+        ///     Get <see cref="Temperature{T}" /> from Kelvins.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromKelvins(QuantityValue kelvins)
+        public static Temperature<T> FromKelvins(T kelvins)
         {
-            double value = (double) kelvins;
-            return new Temperature(value, TemperatureUnit.Kelvin);
+            return new Temperature<T>(kelvins, TemperatureUnit.Kelvin);
         }
         /// <summary>
-        ///     Get Temperature from MillidegreesCelsius.
+        ///     Get <see cref="Temperature{T}" /> from MillidegreesCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromMillidegreesCelsius(QuantityValue millidegreescelsius)
+        public static Temperature<T> FromMillidegreesCelsius(T millidegreescelsius)
         {
-            double value = (double) millidegreescelsius;
-            return new Temperature(value, TemperatureUnit.MillidegreeCelsius);
+            return new Temperature<T>(millidegreescelsius, TemperatureUnit.MillidegreeCelsius);
         }
         /// <summary>
-        ///     Get Temperature from SolarTemperatures.
+        ///     Get <see cref="Temperature{T}" /> from SolarTemperatures.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromSolarTemperatures(QuantityValue solartemperatures)
+        public static Temperature<T> FromSolarTemperatures(T solartemperatures)
         {
-            double value = (double) solartemperatures;
-            return new Temperature(value, TemperatureUnit.SolarTemperature);
+            return new Temperature<T>(solartemperatures, TemperatureUnit.SolarTemperature);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TemperatureUnit" /> to <see cref="Temperature" />.
+        ///     Dynamically convert from value and unit enum <see cref="TemperatureUnit" /> to <see cref="Temperature{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Temperature unit value.</returns>
-        public static Temperature From(QuantityValue value, TemperatureUnit fromUnit)
+        /// <returns><see cref="Temperature{T}" /> unit value.</returns>
+        public static Temperature<T> From(T value, TemperatureUnit fromUnit)
         {
-            return new Temperature((double)value, fromUnit);
+            return new Temperature<T>(value, fromUnit);
         }
 
         #endregion
@@ -382,7 +370,7 @@ public static Temperature From(QuantityValue value, TemperatureUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Temperature Parse(string str)
+        public static Temperature<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -410,9 +398,9 @@ public static Temperature Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Temperature Parse(string str, IFormatProvider? provider)
+        public static Temperature<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Temperature, TemperatureUnit>(
+            return QuantityParser.Default.Parse<T, Temperature<T>, TemperatureUnit>(
                 str,
                 provider,
                 From);
@@ -426,7 +414,7 @@ public static Temperature Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Temperature result)
+        public static bool TryParse(string? str, out Temperature<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -441,9 +429,9 @@ public static bool TryParse(string? str, out Temperature result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Temperature result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Temperature<T> result)
         {
-            return QuantityParser.Default.TryParse<Temperature, TemperatureUnit>(
+            return QuantityParser.Default.TryParse<T, Temperature<T>, TemperatureUnit>(
                 str,
                 provider,
                 From,
@@ -505,39 +493,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Temperature left, Temperature right)
+        public static bool operator <=(Temperature<T> left, Temperature<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Temperature left, Temperature right)
+        public static bool operator >=(Temperature<T> left, Temperature<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Temperature left, Temperature right)
+        public static bool operator <(Temperature<T> left, Temperature<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Temperature left, Temperature right)
+        public static bool operator >(Temperature<T> left, Temperature<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Temperature, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Temperature left, Temperature right)
+        /// <remarks>Consider using <see cref="Equals(Temperature{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Temperature<T> left, Temperature<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Temperature, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Temperature left, Temperature right)
+        /// <remarks>Consider using <see cref="Equals(Temperature{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Temperature<T> left, Temperature<T> right)
         {
             return !(left == right);
         }
@@ -546,37 +534,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Temperature objTemperature)) throw new ArgumentException("Expected type Temperature.", nameof(obj));
+            if(!(obj is Temperature<T> objTemperature)) throw new ArgumentException("Expected type Temperature.", nameof(obj));
 
             return CompareTo(objTemperature);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Temperature other)
+        public int CompareTo(Temperature<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Temperature, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Temperature{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Temperature objTemperature))
+            if(obj is null || !(obj is Temperature<T> objTemperature))
                 return false;
 
             return Equals(objTemperature);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Temperature, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Temperature other)
+        /// <remarks>Consider using <see cref="Equals(Temperature{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Temperature<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Temperature within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Temperature{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -614,21 +602,19 @@ public bool Equals(Temperature other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Temperature other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Temperature<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Temperature.</returns>
+        /// <returns>A hash code for the current <see cref="Temperature{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -642,17 +628,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(TemperatureUnit unit)
+        public T As(TemperatureUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -672,17 +658,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is TemperatureUnit unitAsTemperatureUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureUnit)} is supported.", nameof(unit));
 
-            return As(unitAsTemperatureUnit);
+            var asValue = As(unitAsTemperatureUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<TemperatureUnit>.As(TemperatureUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Temperature to another Temperature with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Temperature{T}" /> to another <see cref="Temperature{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Temperature with the specified unit.</returns>
-        public Temperature ToUnit(TemperatureUnit unit)
+        /// <returns>A <see cref="Temperature{T}" /> with the specified unit.</returns>
+        public Temperature<T> ToUnit(TemperatureUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Temperature(convertedValue, unit);
+            return new Temperature<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -695,7 +686,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Temperature ToUnit(UnitSystem unitSystem)
+        public Temperature<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -715,28 +706,34 @@ public Temperature ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TemperatureUnit> IQuantity<TemperatureUnit>.ToUnit(TemperatureUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<TemperatureUnit, T> IQuantityT<TemperatureUnit, T>.ToUnit(TemperatureUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<TemperatureUnit> IQuantity<TemperatureUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<TemperatureUnit, T> IQuantityT<TemperatureUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case TemperatureUnit.DegreeCelsius: return _value + 273.15;
-                case TemperatureUnit.DegreeDelisle: return _value*-2/3 + 373.15;
-                case TemperatureUnit.DegreeFahrenheit: return _value*5/9 + 459.67*5/9;
-                case TemperatureUnit.DegreeNewton: return _value*100/33 + 273.15;
-                case TemperatureUnit.DegreeRankine: return _value*5/9;
-                case TemperatureUnit.DegreeReaumur: return _value*5/4 + 273.15;
-                case TemperatureUnit.DegreeRoemer: return _value*40/21 + 273.15 - 7.5*40d/21;
-                case TemperatureUnit.Kelvin: return _value;
-                case TemperatureUnit.MillidegreeCelsius: return _value / 1000 + 273.15;
-                case TemperatureUnit.SolarTemperature: return _value * 5778;
+                case TemperatureUnit.DegreeCelsius: return Value + 273.15;
+                case TemperatureUnit.DegreeDelisle: return Value*-2/3 + 373.15;
+                case TemperatureUnit.DegreeFahrenheit: return Value*5/9 + 459.67*5/9;
+                case TemperatureUnit.DegreeNewton: return Value*100/33 + 273.15;
+                case TemperatureUnit.DegreeRankine: return Value*5/9;
+                case TemperatureUnit.DegreeReaumur: return Value*5/4 + 273.15;
+                case TemperatureUnit.DegreeRoemer: return Value*40/21 + 273.15 - 7.5*40d/21;
+                case TemperatureUnit.Kelvin: return Value;
+                case TemperatureUnit.MillidegreeCelsius: return Value / 1000 + 273.15;
+                case TemperatureUnit.SolarTemperature: return Value * 5778;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -747,16 +744,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Temperature ToBaseUnit()
+        internal Temperature<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Temperature(baseUnitValue, BaseUnit);
+            return new Temperature<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(TemperatureUnit unit)
+        private T GetValueAs(TemperatureUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -868,57 +865,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Temperature)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Temperature<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Temperature)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Temperature<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Temperature)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Temperature<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -928,33 +925,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Temperature))
+            if(conversionType == typeof(Temperature<T>))
                 return this;
             else if(conversionType == typeof(TemperatureUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Temperature.QuantityType;
+                return Temperature<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Temperature.Info;
+                return Temperature<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Temperature.BaseDimensions;
+                return Temperature<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Temperature)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Temperature<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
index cd276f47a8..66d073ac7d 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Temperature change rate is the ratio of the temperature change to the time during which the change occurred (value of temperature changes per unit time).
     /// </summary>
-    public partial struct TemperatureChangeRate : IQuantity<TemperatureChangeRateUnit>, IEquatable<TemperatureChangeRate>, IComparable, IComparable<TemperatureChangeRate>, IConvertible, IFormattable
+    public partial struct TemperatureChangeRate<T> : IQuantityT<TemperatureChangeRateUnit, T>, IEquatable<TemperatureChangeRate<T>>, IComparable, IComparable<TemperatureChangeRate<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -72,12 +68,12 @@ static TemperatureChangeRate()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public TemperatureChangeRate(double value, TemperatureChangeRateUnit unit)
+        public TemperatureChangeRate(T value, TemperatureChangeRateUnit unit)
         {
             if(unit == TemperatureChangeRateUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -89,14 +85,14 @@ public TemperatureChangeRate(double value, TemperatureChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public TemperatureChangeRate(double value, UnitSystem unitSystem)
+        public TemperatureChangeRate(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -111,19 +107,19 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of TemperatureChangeRate, which is DegreeCelsiusPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="TemperatureChangeRate{T}" />, which is DegreeCelsiusPerSecond. All conversions go via this value.
         /// </summary>
         public static TemperatureChangeRateUnit BaseUnit { get; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of TemperatureChangeRate
+        /// Represents the largest possible value of <see cref="TemperatureChangeRate{T}" />
         /// </summary>
-        public static TemperatureChangeRate MaxValue { get; } = new TemperatureChangeRate(double.MaxValue, BaseUnit);
+        public static TemperatureChangeRate<T> MaxValue { get; } = new TemperatureChangeRate<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of TemperatureChangeRate
+        /// Represents the smallest possible value of <see cref="TemperatureChangeRate{T}" />
         /// </summary>
-        public static TemperatureChangeRate MinValue { get; } = new TemperatureChangeRate(double.MinValue, BaseUnit);
+        public static TemperatureChangeRate<T> MinValue { get; } = new TemperatureChangeRate<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -132,14 +128,14 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.TemperatureChangeRate;
 
         /// <summary>
-        ///     All units of measurement for the TemperatureChangeRate quantity.
+        ///     All units of measurement for the <see cref="TemperatureChangeRate{T}" /> quantity.
         /// </summary>
         public static TemperatureChangeRateUnit[] Units { get; } = Enum.GetValues(typeof(TemperatureChangeRateUnit)).Cast<TemperatureChangeRateUnit>().Except(new TemperatureChangeRateUnit[]{ TemperatureChangeRateUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DegreeCelsiusPerSecond.
         /// </summary>
-        public static TemperatureChangeRate Zero { get; } = new TemperatureChangeRate(0, BaseUnit);
+        public static TemperatureChangeRate<T> Zero { get; } = new TemperatureChangeRate<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -148,7 +144,9 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -164,66 +162,66 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => TemperatureChangeRate.QuantityType;
+        public QuantityType Type => TemperatureChangeRate<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => TemperatureChangeRate.BaseDimensions;
+        public BaseDimensions Dimensions => TemperatureChangeRate<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get TemperatureChangeRate in CentidegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in CentidegreesCelsiusPerSecond.
         /// </summary>
-        public double CentidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
+        public T CentidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in DecadegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in DecadegreesCelsiusPerSecond.
         /// </summary>
-        public double DecadegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
+        public T DecadegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in DecidegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in DecidegreesCelsiusPerSecond.
         /// </summary>
-        public double DecidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
+        public T DecidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in DegreesCelsiusPerMinute.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in DegreesCelsiusPerMinute.
         /// </summary>
-        public double DegreesCelsiusPerMinute => As(TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
+        public T DegreesCelsiusPerMinute => As(TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in DegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in DegreesCelsiusPerSecond.
         /// </summary>
-        public double DegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
+        public T DegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in HectodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in HectodegreesCelsiusPerSecond.
         /// </summary>
-        public double HectodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
+        public T HectodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in KilodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in KilodegreesCelsiusPerSecond.
         /// </summary>
-        public double KilodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
+        public T KilodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in MicrodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in MicrodegreesCelsiusPerSecond.
         /// </summary>
-        public double MicrodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
+        public T MicrodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in MillidegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in MillidegreesCelsiusPerSecond.
         /// </summary>
-        public double MillidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
+        public T MillidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Get TemperatureChangeRate in NanodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> in NanodegreesCelsiusPerSecond.
         /// </summary>
-        public double NanodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
+        public T NanodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
 
         #endregion
 
@@ -255,105 +253,95 @@ public static string GetAbbreviation(TemperatureChangeRateUnit unit, IFormatProv
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get TemperatureChangeRate from CentidegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from CentidegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(QuantityValue centidegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromCentidegreesCelsiusPerSecond(T centidegreescelsiuspersecond)
         {
-            double value = (double) centidegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(centidegreescelsiuspersecond, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from DecadegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from DecadegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(QuantityValue decadegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromDecadegreesCelsiusPerSecond(T decadegreescelsiuspersecond)
         {
-            double value = (double) decadegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(decadegreescelsiuspersecond, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from DecidegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from DecidegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(QuantityValue decidegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromDecidegreesCelsiusPerSecond(T decidegreescelsiuspersecond)
         {
-            double value = (double) decidegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(decidegreescelsiuspersecond, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from DegreesCelsiusPerMinute.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from DegreesCelsiusPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(QuantityValue degreescelsiusperminute)
+        public static TemperatureChangeRate<T> FromDegreesCelsiusPerMinute(T degreescelsiusperminute)
         {
-            double value = (double) degreescelsiusperminute;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
+            return new TemperatureChangeRate<T>(degreescelsiusperminute, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from DegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from DegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(QuantityValue degreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromDegreesCelsiusPerSecond(T degreescelsiuspersecond)
         {
-            double value = (double) degreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(degreescelsiuspersecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from HectodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from HectodegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(QuantityValue hectodegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromHectodegreesCelsiusPerSecond(T hectodegreescelsiuspersecond)
         {
-            double value = (double) hectodegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(hectodegreescelsiuspersecond, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from KilodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from KilodegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(QuantityValue kilodegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromKilodegreesCelsiusPerSecond(T kilodegreescelsiuspersecond)
         {
-            double value = (double) kilodegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(kilodegreescelsiuspersecond, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from MicrodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from MicrodegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(QuantityValue microdegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromMicrodegreesCelsiusPerSecond(T microdegreescelsiuspersecond)
         {
-            double value = (double) microdegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(microdegreescelsiuspersecond, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from MillidegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from MillidegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(QuantityValue millidegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromMillidegreesCelsiusPerSecond(T millidegreescelsiuspersecond)
         {
-            double value = (double) millidegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(millidegreescelsiuspersecond, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
         }
         /// <summary>
-        ///     Get TemperatureChangeRate from NanodegreesCelsiusPerSecond.
+        ///     Get <see cref="TemperatureChangeRate{T}" /> from NanodegreesCelsiusPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(QuantityValue nanodegreescelsiuspersecond)
+        public static TemperatureChangeRate<T> FromNanodegreesCelsiusPerSecond(T nanodegreescelsiuspersecond)
         {
-            double value = (double) nanodegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate<T>(nanodegreescelsiuspersecond, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TemperatureChangeRateUnit" /> to <see cref="TemperatureChangeRate" />.
+        ///     Dynamically convert from value and unit enum <see cref="TemperatureChangeRateUnit" /> to <see cref="TemperatureChangeRate{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>TemperatureChangeRate unit value.</returns>
-        public static TemperatureChangeRate From(QuantityValue value, TemperatureChangeRateUnit fromUnit)
+        /// <returns><see cref="TemperatureChangeRate{T}" /> unit value.</returns>
+        public static TemperatureChangeRate<T> From(T value, TemperatureChangeRateUnit fromUnit)
         {
-            return new TemperatureChangeRate((double)value, fromUnit);
+            return new TemperatureChangeRate<T>(value, fromUnit);
         }
 
         #endregion
@@ -382,7 +370,7 @@ public static TemperatureChangeRate From(QuantityValue value, TemperatureChangeR
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static TemperatureChangeRate Parse(string str)
+        public static TemperatureChangeRate<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -410,9 +398,9 @@ public static TemperatureChangeRate Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static TemperatureChangeRate Parse(string str, IFormatProvider? provider)
+        public static TemperatureChangeRate<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<TemperatureChangeRate, TemperatureChangeRateUnit>(
+            return QuantityParser.Default.Parse<T, TemperatureChangeRate<T>, TemperatureChangeRateUnit>(
                 str,
                 provider,
                 From);
@@ -426,7 +414,7 @@ public static TemperatureChangeRate Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out TemperatureChangeRate result)
+        public static bool TryParse(string? str, out TemperatureChangeRate<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -441,9 +429,9 @@ public static bool TryParse(string? str, out TemperatureChangeRate result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out TemperatureChangeRate result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out TemperatureChangeRate<T> result)
         {
-            return QuantityParser.Default.TryParse<TemperatureChangeRate, TemperatureChangeRateUnit>(
+            return QuantityParser.Default.TryParse<T, TemperatureChangeRate<T>, TemperatureChangeRateUnit>(
                 str,
                 provider,
                 From,
@@ -505,45 +493,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static TemperatureChangeRate operator -(TemperatureChangeRate right)
+        public static TemperatureChangeRate<T> operator -(TemperatureChangeRate<T> right)
         {
-            return new TemperatureChangeRate(-right.Value, right.Unit);
+            return new TemperatureChangeRate<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureChangeRate"/> from adding two <see cref="TemperatureChangeRate"/>.</summary>
-        public static TemperatureChangeRate operator +(TemperatureChangeRate left, TemperatureChangeRate right)
+        /// <summary>Get <see cref="TemperatureChangeRate{T}"/> from adding two <see cref="TemperatureChangeRate{T}"/>.</summary>
+        public static TemperatureChangeRate<T> operator +(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
-            return new TemperatureChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new TemperatureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureChangeRate"/> from subtracting two <see cref="TemperatureChangeRate"/>.</summary>
-        public static TemperatureChangeRate operator -(TemperatureChangeRate left, TemperatureChangeRate right)
+        /// <summary>Get <see cref="TemperatureChangeRate{T}"/> from subtracting two <see cref="TemperatureChangeRate{T}"/>.</summary>
+        public static TemperatureChangeRate<T> operator -(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
-            return new TemperatureChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new TemperatureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureChangeRate"/> from multiplying value and <see cref="TemperatureChangeRate"/>.</summary>
-        public static TemperatureChangeRate operator *(double left, TemperatureChangeRate right)
+        /// <summary>Get <see cref="TemperatureChangeRate{T}"/> from multiplying value and <see cref="TemperatureChangeRate{T}"/>.</summary>
+        public static TemperatureChangeRate<T> operator *(T left, TemperatureChangeRate<T> right)
         {
-            return new TemperatureChangeRate(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new TemperatureChangeRate<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureChangeRate"/> from multiplying value and <see cref="TemperatureChangeRate"/>.</summary>
-        public static TemperatureChangeRate operator *(TemperatureChangeRate left, double right)
+        /// <summary>Get <see cref="TemperatureChangeRate{T}"/> from multiplying value and <see cref="TemperatureChangeRate{T}"/>.</summary>
+        public static TemperatureChangeRate<T> operator *(TemperatureChangeRate<T> left, T right)
         {
-            return new TemperatureChangeRate(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new TemperatureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureChangeRate"/> from dividing <see cref="TemperatureChangeRate"/> by value.</summary>
-        public static TemperatureChangeRate operator /(TemperatureChangeRate left, double right)
+        /// <summary>Get <see cref="TemperatureChangeRate{T}"/> from dividing <see cref="TemperatureChangeRate{T}"/> by value.</summary>
+        public static TemperatureChangeRate<T> operator /(TemperatureChangeRate<T> left, T right)
         {
-            return new TemperatureChangeRate(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new TemperatureChangeRate<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="TemperatureChangeRate"/> by <see cref="TemperatureChangeRate"/>.</summary>
-        public static double operator /(TemperatureChangeRate left, TemperatureChangeRate right)
+        /// <summary>Get ratio value from dividing <see cref="TemperatureChangeRate{T}"/> by <see cref="TemperatureChangeRate{T}"/>.</summary>
+        public static T operator /(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
-            return left.DegreesCelsiusPerSecond / right.DegreesCelsiusPerSecond;
+            return CompiledLambdas.Divide(left.DegreesCelsiusPerSecond, right.DegreesCelsiusPerSecond);
         }
 
         #endregion
@@ -551,39 +544,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(TemperatureChangeRate left, TemperatureChangeRate right)
+        public static bool operator <=(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(TemperatureChangeRate left, TemperatureChangeRate right)
+        public static bool operator >=(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(TemperatureChangeRate left, TemperatureChangeRate right)
+        public static bool operator <(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(TemperatureChangeRate left, TemperatureChangeRate right)
+        public static bool operator >(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(TemperatureChangeRate left, TemperatureChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(TemperatureChangeRate left, TemperatureChangeRate right)
+        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(TemperatureChangeRate<T> left, TemperatureChangeRate<T> right)
         {
             return !(left == right);
         }
@@ -592,37 +585,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is TemperatureChangeRate objTemperatureChangeRate)) throw new ArgumentException("Expected type TemperatureChangeRate.", nameof(obj));
+            if(!(obj is TemperatureChangeRate<T> objTemperatureChangeRate)) throw new ArgumentException("Expected type TemperatureChangeRate.", nameof(obj));
 
             return CompareTo(objTemperatureChangeRate);
         }
 
         /// <inheritdoc />
-        public int CompareTo(TemperatureChangeRate other)
+        public int CompareTo(TemperatureChangeRate<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is TemperatureChangeRate objTemperatureChangeRate))
+            if(obj is null || !(obj is TemperatureChangeRate<T> objTemperatureChangeRate))
                 return false;
 
             return Equals(objTemperatureChangeRate);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(TemperatureChangeRate other)
+        /// <remarks>Consider using <see cref="Equals(TemperatureChangeRate{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(TemperatureChangeRate<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another TemperatureChangeRate within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="TemperatureChangeRate{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -660,21 +653,19 @@ public bool Equals(TemperatureChangeRate other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(TemperatureChangeRate other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(TemperatureChangeRate<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current TemperatureChangeRate.</returns>
+        /// <returns>A hash code for the current <see cref="TemperatureChangeRate{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -688,17 +679,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(TemperatureChangeRateUnit unit)
+        public T As(TemperatureChangeRateUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -718,17 +709,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is TemperatureChangeRateUnit unitAsTemperatureChangeRateUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureChangeRateUnit)} is supported.", nameof(unit));
 
-            return As(unitAsTemperatureChangeRateUnit);
+            var asValue = As(unitAsTemperatureChangeRateUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<TemperatureChangeRateUnit>.As(TemperatureChangeRateUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this TemperatureChangeRate to another TemperatureChangeRate with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="TemperatureChangeRate{T}" /> to another <see cref="TemperatureChangeRate{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A TemperatureChangeRate with the specified unit.</returns>
-        public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit)
+        /// <returns>A <see cref="TemperatureChangeRate{T}" /> with the specified unit.</returns>
+        public TemperatureChangeRate<T> ToUnit(TemperatureChangeRateUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new TemperatureChangeRate(convertedValue, unit);
+            return new TemperatureChangeRate<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -741,7 +737,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public TemperatureChangeRate ToUnit(UnitSystem unitSystem)
+        public TemperatureChangeRate<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -761,28 +757,34 @@ public TemperatureChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TemperatureChangeRateUnit> IQuantity<TemperatureChangeRateUnit>.ToUnit(TemperatureChangeRateUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<TemperatureChangeRateUnit, T> IQuantityT<TemperatureChangeRateUnit, T>.ToUnit(TemperatureChangeRateUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<TemperatureChangeRateUnit> IQuantity<TemperatureChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<TemperatureChangeRateUnit, T> IQuantityT<TemperatureChangeRateUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: return (_value) * 1e-2d;
-                case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: return (_value) * 1e1d;
-                case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: return (_value) * 1e-1d;
-                case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: return _value/60;
-                case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: return _value;
-                case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: return (_value) * 1e2d;
-                case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: return (_value) * 1e3d;
-                case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: return (_value) * 1e-6d;
-                case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: return (_value) * 1e-3d;
-                case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: return (_value) * 1e-9d;
+                case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: return (Value) * 1e-2d;
+                case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: return (Value) * 1e1d;
+                case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: return (Value) * 1e-1d;
+                case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: return Value/60;
+                case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: return Value;
+                case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: return (Value) * 1e2d;
+                case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: return (Value) * 1e3d;
+                case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: return (Value) * 1e-6d;
+                case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: return (Value) * 1e-3d;
+                case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: return (Value) * 1e-9d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -793,16 +795,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal TemperatureChangeRate ToBaseUnit()
+        internal TemperatureChangeRate<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new TemperatureChangeRate(baseUnitValue, BaseUnit);
+            return new TemperatureChangeRate<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(TemperatureChangeRateUnit unit)
+        private T GetValueAs(TemperatureChangeRateUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -914,57 +916,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -974,33 +976,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(TemperatureChangeRate))
+            if(conversionType == typeof(TemperatureChangeRate<T>))
                 return this;
             else if(conversionType == typeof(TemperatureChangeRateUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return TemperatureChangeRate.QuantityType;
+                return TemperatureChangeRate<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return TemperatureChangeRate.Info;
+                return TemperatureChangeRate<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return TemperatureChangeRate.BaseDimensions;
+                return TemperatureChangeRate<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(TemperatureChangeRate<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
index af3d547f75..1767e3b2db 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Difference between two temperatures. The conversions are different than for Temperature.
     /// </summary>
-    public partial struct TemperatureDelta : IQuantity<TemperatureDeltaUnit>, IEquatable<TemperatureDelta>, IComparable, IComparable<TemperatureDelta>, IConvertible, IFormattable
+    public partial struct TemperatureDelta<T> : IQuantityT<TemperatureDeltaUnit, T>, IEquatable<TemperatureDelta<T>>, IComparable, IComparable<TemperatureDelta<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -71,12 +67,12 @@ static TemperatureDelta()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public TemperatureDelta(double value, TemperatureDeltaUnit unit)
+        public TemperatureDelta(T value, TemperatureDeltaUnit unit)
         {
             if(unit == TemperatureDeltaUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -88,14 +84,14 @@ public TemperatureDelta(double value, TemperatureDeltaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public TemperatureDelta(double value, UnitSystem unitSystem)
+        public TemperatureDelta(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -110,19 +106,19 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of TemperatureDelta, which is Kelvin. All conversions go via this value.
+        ///     The base unit of <see cref="TemperatureDelta{T}" />, which is Kelvin. All conversions go via this value.
         /// </summary>
         public static TemperatureDeltaUnit BaseUnit { get; } = TemperatureDeltaUnit.Kelvin;
 
         /// <summary>
-        /// Represents the largest possible value of TemperatureDelta
+        /// Represents the largest possible value of <see cref="TemperatureDelta{T}" />
         /// </summary>
-        public static TemperatureDelta MaxValue { get; } = new TemperatureDelta(double.MaxValue, BaseUnit);
+        public static TemperatureDelta<T> MaxValue { get; } = new TemperatureDelta<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of TemperatureDelta
+        /// Represents the smallest possible value of <see cref="TemperatureDelta{T}" />
         /// </summary>
-        public static TemperatureDelta MinValue { get; } = new TemperatureDelta(double.MinValue, BaseUnit);
+        public static TemperatureDelta<T> MinValue { get; } = new TemperatureDelta<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -131,14 +127,14 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.TemperatureDelta;
 
         /// <summary>
-        ///     All units of measurement for the TemperatureDelta quantity.
+        ///     All units of measurement for the <see cref="TemperatureDelta{T}" /> quantity.
         /// </summary>
         public static TemperatureDeltaUnit[] Units { get; } = Enum.GetValues(typeof(TemperatureDeltaUnit)).Cast<TemperatureDeltaUnit>().Except(new TemperatureDeltaUnit[]{ TemperatureDeltaUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Kelvin.
         /// </summary>
-        public static TemperatureDelta Zero { get; } = new TemperatureDelta(0, BaseUnit);
+        public static TemperatureDelta<T> Zero { get; } = new TemperatureDelta<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -147,7 +143,9 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -163,61 +161,61 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => TemperatureDelta.QuantityType;
+        public QuantityType Type => TemperatureDelta<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => TemperatureDelta.BaseDimensions;
+        public BaseDimensions Dimensions => TemperatureDelta<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get TemperatureDelta in DegreesCelsius.
+        ///     Get <see cref="TemperatureDelta{T}" /> in DegreesCelsius.
         /// </summary>
-        public double DegreesCelsius => As(TemperatureDeltaUnit.DegreeCelsius);
+        public T DegreesCelsius => As(TemperatureDeltaUnit.DegreeCelsius);
 
         /// <summary>
-        ///     Get TemperatureDelta in DegreesDelisle.
+        ///     Get <see cref="TemperatureDelta{T}" /> in DegreesDelisle.
         /// </summary>
-        public double DegreesDelisle => As(TemperatureDeltaUnit.DegreeDelisle);
+        public T DegreesDelisle => As(TemperatureDeltaUnit.DegreeDelisle);
 
         /// <summary>
-        ///     Get TemperatureDelta in DegreesFahrenheit.
+        ///     Get <see cref="TemperatureDelta{T}" /> in DegreesFahrenheit.
         /// </summary>
-        public double DegreesFahrenheit => As(TemperatureDeltaUnit.DegreeFahrenheit);
+        public T DegreesFahrenheit => As(TemperatureDeltaUnit.DegreeFahrenheit);
 
         /// <summary>
-        ///     Get TemperatureDelta in DegreesNewton.
+        ///     Get <see cref="TemperatureDelta{T}" /> in DegreesNewton.
         /// </summary>
-        public double DegreesNewton => As(TemperatureDeltaUnit.DegreeNewton);
+        public T DegreesNewton => As(TemperatureDeltaUnit.DegreeNewton);
 
         /// <summary>
-        ///     Get TemperatureDelta in DegreesRankine.
+        ///     Get <see cref="TemperatureDelta{T}" /> in DegreesRankine.
         /// </summary>
-        public double DegreesRankine => As(TemperatureDeltaUnit.DegreeRankine);
+        public T DegreesRankine => As(TemperatureDeltaUnit.DegreeRankine);
 
         /// <summary>
-        ///     Get TemperatureDelta in DegreesReaumur.
+        ///     Get <see cref="TemperatureDelta{T}" /> in DegreesReaumur.
         /// </summary>
-        public double DegreesReaumur => As(TemperatureDeltaUnit.DegreeReaumur);
+        public T DegreesReaumur => As(TemperatureDeltaUnit.DegreeReaumur);
 
         /// <summary>
-        ///     Get TemperatureDelta in DegreesRoemer.
+        ///     Get <see cref="TemperatureDelta{T}" /> in DegreesRoemer.
         /// </summary>
-        public double DegreesRoemer => As(TemperatureDeltaUnit.DegreeRoemer);
+        public T DegreesRoemer => As(TemperatureDeltaUnit.DegreeRoemer);
 
         /// <summary>
-        ///     Get TemperatureDelta in Kelvins.
+        ///     Get <see cref="TemperatureDelta{T}" /> in Kelvins.
         /// </summary>
-        public double Kelvins => As(TemperatureDeltaUnit.Kelvin);
+        public T Kelvins => As(TemperatureDeltaUnit.Kelvin);
 
         /// <summary>
-        ///     Get TemperatureDelta in MillidegreesCelsius.
+        ///     Get <see cref="TemperatureDelta{T}" /> in MillidegreesCelsius.
         /// </summary>
-        public double MillidegreesCelsius => As(TemperatureDeltaUnit.MillidegreeCelsius);
+        public T MillidegreesCelsius => As(TemperatureDeltaUnit.MillidegreeCelsius);
 
         #endregion
 
@@ -249,96 +247,87 @@ public static string GetAbbreviation(TemperatureDeltaUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get TemperatureDelta from DegreesCelsius.
+        ///     Get <see cref="TemperatureDelta{T}" /> from DegreesCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesCelsius(QuantityValue degreescelsius)
+        public static TemperatureDelta<T> FromDegreesCelsius(T degreescelsius)
         {
-            double value = (double) degreescelsius;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius);
+            return new TemperatureDelta<T>(degreescelsius, TemperatureDeltaUnit.DegreeCelsius);
         }
         /// <summary>
-        ///     Get TemperatureDelta from DegreesDelisle.
+        ///     Get <see cref="TemperatureDelta{T}" /> from DegreesDelisle.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesDelisle(QuantityValue degreesdelisle)
+        public static TemperatureDelta<T> FromDegreesDelisle(T degreesdelisle)
         {
-            double value = (double) degreesdelisle;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle);
+            return new TemperatureDelta<T>(degreesdelisle, TemperatureDeltaUnit.DegreeDelisle);
         }
         /// <summary>
-        ///     Get TemperatureDelta from DegreesFahrenheit.
+        ///     Get <see cref="TemperatureDelta{T}" /> from DegreesFahrenheit.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesFahrenheit(QuantityValue degreesfahrenheit)
+        public static TemperatureDelta<T> FromDegreesFahrenheit(T degreesfahrenheit)
         {
-            double value = (double) degreesfahrenheit;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit);
+            return new TemperatureDelta<T>(degreesfahrenheit, TemperatureDeltaUnit.DegreeFahrenheit);
         }
         /// <summary>
-        ///     Get TemperatureDelta from DegreesNewton.
+        ///     Get <see cref="TemperatureDelta{T}" /> from DegreesNewton.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesNewton(QuantityValue degreesnewton)
+        public static TemperatureDelta<T> FromDegreesNewton(T degreesnewton)
         {
-            double value = (double) degreesnewton;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton);
+            return new TemperatureDelta<T>(degreesnewton, TemperatureDeltaUnit.DegreeNewton);
         }
         /// <summary>
-        ///     Get TemperatureDelta from DegreesRankine.
+        ///     Get <see cref="TemperatureDelta{T}" /> from DegreesRankine.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesRankine(QuantityValue degreesrankine)
+        public static TemperatureDelta<T> FromDegreesRankine(T degreesrankine)
         {
-            double value = (double) degreesrankine;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine);
+            return new TemperatureDelta<T>(degreesrankine, TemperatureDeltaUnit.DegreeRankine);
         }
         /// <summary>
-        ///     Get TemperatureDelta from DegreesReaumur.
+        ///     Get <see cref="TemperatureDelta{T}" /> from DegreesReaumur.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesReaumur(QuantityValue degreesreaumur)
+        public static TemperatureDelta<T> FromDegreesReaumur(T degreesreaumur)
         {
-            double value = (double) degreesreaumur;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur);
+            return new TemperatureDelta<T>(degreesreaumur, TemperatureDeltaUnit.DegreeReaumur);
         }
         /// <summary>
-        ///     Get TemperatureDelta from DegreesRoemer.
+        ///     Get <see cref="TemperatureDelta{T}" /> from DegreesRoemer.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesRoemer(QuantityValue degreesroemer)
+        public static TemperatureDelta<T> FromDegreesRoemer(T degreesroemer)
         {
-            double value = (double) degreesroemer;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer);
+            return new TemperatureDelta<T>(degreesroemer, TemperatureDeltaUnit.DegreeRoemer);
         }
         /// <summary>
-        ///     Get TemperatureDelta from Kelvins.
+        ///     Get <see cref="TemperatureDelta{T}" /> from Kelvins.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromKelvins(QuantityValue kelvins)
+        public static TemperatureDelta<T> FromKelvins(T kelvins)
         {
-            double value = (double) kelvins;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin);
+            return new TemperatureDelta<T>(kelvins, TemperatureDeltaUnit.Kelvin);
         }
         /// <summary>
-        ///     Get TemperatureDelta from MillidegreesCelsius.
+        ///     Get <see cref="TemperatureDelta{T}" /> from MillidegreesCelsius.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromMillidegreesCelsius(QuantityValue millidegreescelsius)
+        public static TemperatureDelta<T> FromMillidegreesCelsius(T millidegreescelsius)
         {
-            double value = (double) millidegreescelsius;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius);
+            return new TemperatureDelta<T>(millidegreescelsius, TemperatureDeltaUnit.MillidegreeCelsius);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TemperatureDeltaUnit" /> to <see cref="TemperatureDelta" />.
+        ///     Dynamically convert from value and unit enum <see cref="TemperatureDeltaUnit" /> to <see cref="TemperatureDelta{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>TemperatureDelta unit value.</returns>
-        public static TemperatureDelta From(QuantityValue value, TemperatureDeltaUnit fromUnit)
+        /// <returns><see cref="TemperatureDelta{T}" /> unit value.</returns>
+        public static TemperatureDelta<T> From(T value, TemperatureDeltaUnit fromUnit)
         {
-            return new TemperatureDelta((double)value, fromUnit);
+            return new TemperatureDelta<T>(value, fromUnit);
         }
 
         #endregion
@@ -367,7 +356,7 @@ public static TemperatureDelta From(QuantityValue value, TemperatureDeltaUnit fr
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static TemperatureDelta Parse(string str)
+        public static TemperatureDelta<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -395,9 +384,9 @@ public static TemperatureDelta Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static TemperatureDelta Parse(string str, IFormatProvider? provider)
+        public static TemperatureDelta<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<TemperatureDelta, TemperatureDeltaUnit>(
+            return QuantityParser.Default.Parse<T, TemperatureDelta<T>, TemperatureDeltaUnit>(
                 str,
                 provider,
                 From);
@@ -411,7 +400,7 @@ public static TemperatureDelta Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out TemperatureDelta result)
+        public static bool TryParse(string? str, out TemperatureDelta<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -426,9 +415,9 @@ public static bool TryParse(string? str, out TemperatureDelta result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out TemperatureDelta result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out TemperatureDelta<T> result)
         {
-            return QuantityParser.Default.TryParse<TemperatureDelta, TemperatureDeltaUnit>(
+            return QuantityParser.Default.TryParse<T, TemperatureDelta<T>, TemperatureDeltaUnit>(
                 str,
                 provider,
                 From,
@@ -490,45 +479,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static TemperatureDelta operator -(TemperatureDelta right)
+        public static TemperatureDelta<T> operator -(TemperatureDelta<T> right)
         {
-            return new TemperatureDelta(-right.Value, right.Unit);
+            return new TemperatureDelta<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureDelta"/> from adding two <see cref="TemperatureDelta"/>.</summary>
-        public static TemperatureDelta operator +(TemperatureDelta left, TemperatureDelta right)
+        /// <summary>Get <see cref="TemperatureDelta{T}"/> from adding two <see cref="TemperatureDelta{T}"/>.</summary>
+        public static TemperatureDelta<T> operator +(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
-            return new TemperatureDelta(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new TemperatureDelta<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureDelta"/> from subtracting two <see cref="TemperatureDelta"/>.</summary>
-        public static TemperatureDelta operator -(TemperatureDelta left, TemperatureDelta right)
+        /// <summary>Get <see cref="TemperatureDelta{T}"/> from subtracting two <see cref="TemperatureDelta{T}"/>.</summary>
+        public static TemperatureDelta<T> operator -(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
-            return new TemperatureDelta(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new TemperatureDelta<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureDelta"/> from multiplying value and <see cref="TemperatureDelta"/>.</summary>
-        public static TemperatureDelta operator *(double left, TemperatureDelta right)
+        /// <summary>Get <see cref="TemperatureDelta{T}"/> from multiplying value and <see cref="TemperatureDelta{T}"/>.</summary>
+        public static TemperatureDelta<T> operator *(T left, TemperatureDelta<T> right)
         {
-            return new TemperatureDelta(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new TemperatureDelta<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureDelta"/> from multiplying value and <see cref="TemperatureDelta"/>.</summary>
-        public static TemperatureDelta operator *(TemperatureDelta left, double right)
+        /// <summary>Get <see cref="TemperatureDelta{T}"/> from multiplying value and <see cref="TemperatureDelta{T}"/>.</summary>
+        public static TemperatureDelta<T> operator *(TemperatureDelta<T> left, T right)
         {
-            return new TemperatureDelta(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new TemperatureDelta<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TemperatureDelta"/> from dividing <see cref="TemperatureDelta"/> by value.</summary>
-        public static TemperatureDelta operator /(TemperatureDelta left, double right)
+        /// <summary>Get <see cref="TemperatureDelta{T}"/> from dividing <see cref="TemperatureDelta{T}"/> by value.</summary>
+        public static TemperatureDelta<T> operator /(TemperatureDelta<T> left, T right)
         {
-            return new TemperatureDelta(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new TemperatureDelta<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="TemperatureDelta"/> by <see cref="TemperatureDelta"/>.</summary>
-        public static double operator /(TemperatureDelta left, TemperatureDelta right)
+        /// <summary>Get ratio value from dividing <see cref="TemperatureDelta{T}"/> by <see cref="TemperatureDelta{T}"/>.</summary>
+        public static T operator /(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
-            return left.Kelvins / right.Kelvins;
+            return CompiledLambdas.Divide(left.Kelvins, right.Kelvins);
         }
 
         #endregion
@@ -536,39 +530,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(TemperatureDelta left, TemperatureDelta right)
+        public static bool operator <=(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(TemperatureDelta left, TemperatureDelta right)
+        public static bool operator >=(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(TemperatureDelta left, TemperatureDelta right)
+        public static bool operator <(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(TemperatureDelta left, TemperatureDelta right)
+        public static bool operator >(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(TemperatureDelta, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(TemperatureDelta left, TemperatureDelta right)
+        /// <remarks>Consider using <see cref="Equals(TemperatureDelta{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(TemperatureDelta, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(TemperatureDelta left, TemperatureDelta right)
+        /// <remarks>Consider using <see cref="Equals(TemperatureDelta{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(TemperatureDelta<T> left, TemperatureDelta<T> right)
         {
             return !(left == right);
         }
@@ -577,37 +571,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Tempe
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is TemperatureDelta objTemperatureDelta)) throw new ArgumentException("Expected type TemperatureDelta.", nameof(obj));
+            if(!(obj is TemperatureDelta<T> objTemperatureDelta)) throw new ArgumentException("Expected type TemperatureDelta.", nameof(obj));
 
             return CompareTo(objTemperatureDelta);
         }
 
         /// <inheritdoc />
-        public int CompareTo(TemperatureDelta other)
+        public int CompareTo(TemperatureDelta<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(TemperatureDelta, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(TemperatureDelta{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is TemperatureDelta objTemperatureDelta))
+            if(obj is null || !(obj is TemperatureDelta<T> objTemperatureDelta))
                 return false;
 
             return Equals(objTemperatureDelta);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(TemperatureDelta, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(TemperatureDelta other)
+        /// <remarks>Consider using <see cref="Equals(TemperatureDelta{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(TemperatureDelta<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another TemperatureDelta within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="TemperatureDelta{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -645,21 +639,19 @@ public bool Equals(TemperatureDelta other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(TemperatureDelta other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(TemperatureDelta<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current TemperatureDelta.</returns>
+        /// <returns>A hash code for the current <see cref="TemperatureDelta{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -673,17 +665,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(TemperatureDeltaUnit unit)
+        public T As(TemperatureDeltaUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -703,17 +695,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is TemperatureDeltaUnit unitAsTemperatureDeltaUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureDeltaUnit)} is supported.", nameof(unit));
 
-            return As(unitAsTemperatureDeltaUnit);
+            var asValue = As(unitAsTemperatureDeltaUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<TemperatureDeltaUnit>.As(TemperatureDeltaUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this TemperatureDelta to another TemperatureDelta with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="TemperatureDelta{T}" /> to another <see cref="TemperatureDelta{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A TemperatureDelta with the specified unit.</returns>
-        public TemperatureDelta ToUnit(TemperatureDeltaUnit unit)
+        /// <returns>A <see cref="TemperatureDelta{T}" /> with the specified unit.</returns>
+        public TemperatureDelta<T> ToUnit(TemperatureDeltaUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new TemperatureDelta(convertedValue, unit);
+            return new TemperatureDelta<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -726,7 +723,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public TemperatureDelta ToUnit(UnitSystem unitSystem)
+        public TemperatureDelta<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -746,27 +743,33 @@ public TemperatureDelta ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TemperatureDeltaUnit> IQuantity<TemperatureDeltaUnit>.ToUnit(TemperatureDeltaUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<TemperatureDeltaUnit, T> IQuantityT<TemperatureDeltaUnit, T>.ToUnit(TemperatureDeltaUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<TemperatureDeltaUnit> IQuantity<TemperatureDeltaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<TemperatureDeltaUnit, T> IQuantityT<TemperatureDeltaUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case TemperatureDeltaUnit.DegreeCelsius: return _value;
-                case TemperatureDeltaUnit.DegreeDelisle: return _value*-2/3;
-                case TemperatureDeltaUnit.DegreeFahrenheit: return _value*5/9;
-                case TemperatureDeltaUnit.DegreeNewton: return _value*100/33;
-                case TemperatureDeltaUnit.DegreeRankine: return _value*5/9;
-                case TemperatureDeltaUnit.DegreeReaumur: return _value*5/4;
-                case TemperatureDeltaUnit.DegreeRoemer: return _value*40/21;
-                case TemperatureDeltaUnit.Kelvin: return _value;
-                case TemperatureDeltaUnit.MillidegreeCelsius: return (_value) * 1e-3d;
+                case TemperatureDeltaUnit.DegreeCelsius: return Value;
+                case TemperatureDeltaUnit.DegreeDelisle: return Value*-2/3;
+                case TemperatureDeltaUnit.DegreeFahrenheit: return Value*5/9;
+                case TemperatureDeltaUnit.DegreeNewton: return Value*100/33;
+                case TemperatureDeltaUnit.DegreeRankine: return Value*5/9;
+                case TemperatureDeltaUnit.DegreeReaumur: return Value*5/4;
+                case TemperatureDeltaUnit.DegreeRoemer: return Value*40/21;
+                case TemperatureDeltaUnit.Kelvin: return Value;
+                case TemperatureDeltaUnit.MillidegreeCelsius: return (Value) * 1e-3d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -777,16 +780,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal TemperatureDelta ToBaseUnit()
+        internal TemperatureDelta<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new TemperatureDelta(baseUnitValue, BaseUnit);
+            return new TemperatureDelta<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(TemperatureDeltaUnit unit)
+        private T GetValueAs(TemperatureDeltaUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -897,57 +900,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TemperatureDelta)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TemperatureDelta<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TemperatureDelta)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TemperatureDelta<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TemperatureDelta)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TemperatureDelta<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -957,33 +960,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(TemperatureDelta))
+            if(conversionType == typeof(TemperatureDelta<T>))
                 return this;
             else if(conversionType == typeof(TemperatureDeltaUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return TemperatureDelta.QuantityType;
+                return TemperatureDelta<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return TemperatureDelta.Info;
+                return TemperatureDelta<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return TemperatureDelta.BaseDimensions;
+                return TemperatureDelta<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(TemperatureDelta)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(TemperatureDelta<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
index ed9855f86d..01758f0d33 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Thermal_Conductivity
     /// </remarks>
-    public partial struct ThermalConductivity : IQuantity<ThermalConductivityUnit>, IEquatable<ThermalConductivity>, IComparable, IComparable<ThermalConductivity>, IConvertible, IFormattable
+    public partial struct ThermalConductivity<T> : IQuantityT<ThermalConductivityUnit, T>, IEquatable<ThermalConductivity<T>>, IComparable, IComparable<ThermalConductivity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -67,12 +63,12 @@ static ThermalConductivity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ThermalConductivity(double value, ThermalConductivityUnit unit)
+        public ThermalConductivity(T value, ThermalConductivityUnit unit)
         {
             if(unit == ThermalConductivityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -84,14 +80,14 @@ public ThermalConductivity(double value, ThermalConductivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ThermalConductivity(double value, UnitSystem unitSystem)
+        public ThermalConductivity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -106,19 +102,19 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ThermalConductivity, which is WattPerMeterKelvin. All conversions go via this value.
+        ///     The base unit of <see cref="ThermalConductivity{T}" />, which is WattPerMeterKelvin. All conversions go via this value.
         /// </summary>
         public static ThermalConductivityUnit BaseUnit { get; } = ThermalConductivityUnit.WattPerMeterKelvin;
 
         /// <summary>
-        /// Represents the largest possible value of ThermalConductivity
+        /// Represents the largest possible value of <see cref="ThermalConductivity{T}" />
         /// </summary>
-        public static ThermalConductivity MaxValue { get; } = new ThermalConductivity(double.MaxValue, BaseUnit);
+        public static ThermalConductivity<T> MaxValue { get; } = new ThermalConductivity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ThermalConductivity
+        /// Represents the smallest possible value of <see cref="ThermalConductivity{T}" />
         /// </summary>
-        public static ThermalConductivity MinValue { get; } = new ThermalConductivity(double.MinValue, BaseUnit);
+        public static ThermalConductivity<T> MinValue { get; } = new ThermalConductivity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -127,14 +123,14 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ThermalConductivity;
 
         /// <summary>
-        ///     All units of measurement for the ThermalConductivity quantity.
+        ///     All units of measurement for the <see cref="ThermalConductivity{T}" /> quantity.
         /// </summary>
         public static ThermalConductivityUnit[] Units { get; } = Enum.GetValues(typeof(ThermalConductivityUnit)).Cast<ThermalConductivityUnit>().Except(new ThermalConductivityUnit[]{ ThermalConductivityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit WattPerMeterKelvin.
         /// </summary>
-        public static ThermalConductivity Zero { get; } = new ThermalConductivity(0, BaseUnit);
+        public static ThermalConductivity<T> Zero { get; } = new ThermalConductivity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -143,7 +139,9 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -159,26 +157,26 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ThermalConductivity.QuantityType;
+        public QuantityType Type => ThermalConductivity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ThermalConductivity.BaseDimensions;
+        public BaseDimensions Dimensions => ThermalConductivity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ThermalConductivity in BtusPerHourFootFahrenheit.
+        ///     Get <see cref="ThermalConductivity{T}" /> in BtusPerHourFootFahrenheit.
         /// </summary>
-        public double BtusPerHourFootFahrenheit => As(ThermalConductivityUnit.BtuPerHourFootFahrenheit);
+        public T BtusPerHourFootFahrenheit => As(ThermalConductivityUnit.BtuPerHourFootFahrenheit);
 
         /// <summary>
-        ///     Get ThermalConductivity in WattsPerMeterKelvin.
+        ///     Get <see cref="ThermalConductivity{T}" /> in WattsPerMeterKelvin.
         /// </summary>
-        public double WattsPerMeterKelvin => As(ThermalConductivityUnit.WattPerMeterKelvin);
+        public T WattsPerMeterKelvin => As(ThermalConductivityUnit.WattPerMeterKelvin);
 
         #endregion
 
@@ -210,33 +208,31 @@ public static string GetAbbreviation(ThermalConductivityUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ThermalConductivity from BtusPerHourFootFahrenheit.
+        ///     Get <see cref="ThermalConductivity{T}" /> from BtusPerHourFootFahrenheit.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalConductivity FromBtusPerHourFootFahrenheit(QuantityValue btusperhourfootfahrenheit)
+        public static ThermalConductivity<T> FromBtusPerHourFootFahrenheit(T btusperhourfootfahrenheit)
         {
-            double value = (double) btusperhourfootfahrenheit;
-            return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
+            return new ThermalConductivity<T>(btusperhourfootfahrenheit, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
         }
         /// <summary>
-        ///     Get ThermalConductivity from WattsPerMeterKelvin.
+        ///     Get <see cref="ThermalConductivity{T}" /> from WattsPerMeterKelvin.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalConductivity FromWattsPerMeterKelvin(QuantityValue wattspermeterkelvin)
+        public static ThermalConductivity<T> FromWattsPerMeterKelvin(T wattspermeterkelvin)
         {
-            double value = (double) wattspermeterkelvin;
-            return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin);
+            return new ThermalConductivity<T>(wattspermeterkelvin, ThermalConductivityUnit.WattPerMeterKelvin);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ThermalConductivityUnit" /> to <see cref="ThermalConductivity" />.
+        ///     Dynamically convert from value and unit enum <see cref="ThermalConductivityUnit" /> to <see cref="ThermalConductivity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ThermalConductivity unit value.</returns>
-        public static ThermalConductivity From(QuantityValue value, ThermalConductivityUnit fromUnit)
+        /// <returns><see cref="ThermalConductivity{T}" /> unit value.</returns>
+        public static ThermalConductivity<T> From(T value, ThermalConductivityUnit fromUnit)
         {
-            return new ThermalConductivity((double)value, fromUnit);
+            return new ThermalConductivity<T>(value, fromUnit);
         }
 
         #endregion
@@ -265,7 +261,7 @@ public static ThermalConductivity From(QuantityValue value, ThermalConductivityU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ThermalConductivity Parse(string str)
+        public static ThermalConductivity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -293,9 +289,9 @@ public static ThermalConductivity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ThermalConductivity Parse(string str, IFormatProvider? provider)
+        public static ThermalConductivity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ThermalConductivity, ThermalConductivityUnit>(
+            return QuantityParser.Default.Parse<T, ThermalConductivity<T>, ThermalConductivityUnit>(
                 str,
                 provider,
                 From);
@@ -309,7 +305,7 @@ public static ThermalConductivity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ThermalConductivity result)
+        public static bool TryParse(string? str, out ThermalConductivity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -324,9 +320,9 @@ public static bool TryParse(string? str, out ThermalConductivity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ThermalConductivity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ThermalConductivity<T> result)
         {
-            return QuantityParser.Default.TryParse<ThermalConductivity, ThermalConductivityUnit>(
+            return QuantityParser.Default.TryParse<T, ThermalConductivity<T>, ThermalConductivityUnit>(
                 str,
                 provider,
                 From,
@@ -388,45 +384,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Therm
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ThermalConductivity operator -(ThermalConductivity right)
+        public static ThermalConductivity<T> operator -(ThermalConductivity<T> right)
         {
-            return new ThermalConductivity(-right.Value, right.Unit);
+            return new ThermalConductivity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalConductivity"/> from adding two <see cref="ThermalConductivity"/>.</summary>
-        public static ThermalConductivity operator +(ThermalConductivity left, ThermalConductivity right)
+        /// <summary>Get <see cref="ThermalConductivity{T}"/> from adding two <see cref="ThermalConductivity{T}"/>.</summary>
+        public static ThermalConductivity<T> operator +(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
-            return new ThermalConductivity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ThermalConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalConductivity"/> from subtracting two <see cref="ThermalConductivity"/>.</summary>
-        public static ThermalConductivity operator -(ThermalConductivity left, ThermalConductivity right)
+        /// <summary>Get <see cref="ThermalConductivity{T}"/> from subtracting two <see cref="ThermalConductivity{T}"/>.</summary>
+        public static ThermalConductivity<T> operator -(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
-            return new ThermalConductivity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ThermalConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalConductivity"/> from multiplying value and <see cref="ThermalConductivity"/>.</summary>
-        public static ThermalConductivity operator *(double left, ThermalConductivity right)
+        /// <summary>Get <see cref="ThermalConductivity{T}"/> from multiplying value and <see cref="ThermalConductivity{T}"/>.</summary>
+        public static ThermalConductivity<T> operator *(T left, ThermalConductivity<T> right)
         {
-            return new ThermalConductivity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ThermalConductivity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalConductivity"/> from multiplying value and <see cref="ThermalConductivity"/>.</summary>
-        public static ThermalConductivity operator *(ThermalConductivity left, double right)
+        /// <summary>Get <see cref="ThermalConductivity{T}"/> from multiplying value and <see cref="ThermalConductivity{T}"/>.</summary>
+        public static ThermalConductivity<T> operator *(ThermalConductivity<T> left, T right)
         {
-            return new ThermalConductivity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ThermalConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalConductivity"/> from dividing <see cref="ThermalConductivity"/> by value.</summary>
-        public static ThermalConductivity operator /(ThermalConductivity left, double right)
+        /// <summary>Get <see cref="ThermalConductivity{T}"/> from dividing <see cref="ThermalConductivity{T}"/> by value.</summary>
+        public static ThermalConductivity<T> operator /(ThermalConductivity<T> left, T right)
         {
-            return new ThermalConductivity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ThermalConductivity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ThermalConductivity"/> by <see cref="ThermalConductivity"/>.</summary>
-        public static double operator /(ThermalConductivity left, ThermalConductivity right)
+        /// <summary>Get ratio value from dividing <see cref="ThermalConductivity{T}"/> by <see cref="ThermalConductivity{T}"/>.</summary>
+        public static T operator /(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
-            return left.WattsPerMeterKelvin / right.WattsPerMeterKelvin;
+            return CompiledLambdas.Divide(left.WattsPerMeterKelvin, right.WattsPerMeterKelvin);
         }
 
         #endregion
@@ -434,39 +435,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Therm
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ThermalConductivity left, ThermalConductivity right)
+        public static bool operator <=(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ThermalConductivity left, ThermalConductivity right)
+        public static bool operator >=(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ThermalConductivity left, ThermalConductivity right)
+        public static bool operator <(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ThermalConductivity left, ThermalConductivity right)
+        public static bool operator >(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ThermalConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ThermalConductivity left, ThermalConductivity right)
+        /// <remarks>Consider using <see cref="Equals(ThermalConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ThermalConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ThermalConductivity left, ThermalConductivity right)
+        /// <remarks>Consider using <see cref="Equals(ThermalConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ThermalConductivity<T> left, ThermalConductivity<T> right)
         {
             return !(left == right);
         }
@@ -475,37 +476,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Therm
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ThermalConductivity objThermalConductivity)) throw new ArgumentException("Expected type ThermalConductivity.", nameof(obj));
+            if(!(obj is ThermalConductivity<T> objThermalConductivity)) throw new ArgumentException("Expected type ThermalConductivity.", nameof(obj));
 
             return CompareTo(objThermalConductivity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ThermalConductivity other)
+        public int CompareTo(ThermalConductivity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ThermalConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ThermalConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ThermalConductivity objThermalConductivity))
+            if(obj is null || !(obj is ThermalConductivity<T> objThermalConductivity))
                 return false;
 
             return Equals(objThermalConductivity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ThermalConductivity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ThermalConductivity other)
+        /// <remarks>Consider using <see cref="Equals(ThermalConductivity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ThermalConductivity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ThermalConductivity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ThermalConductivity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -543,21 +544,19 @@ public bool Equals(ThermalConductivity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ThermalConductivity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ThermalConductivity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ThermalConductivity.</returns>
+        /// <returns>A hash code for the current <see cref="ThermalConductivity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -571,17 +570,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ThermalConductivityUnit unit)
+        public T As(ThermalConductivityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -601,17 +600,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ThermalConductivityUnit unitAsThermalConductivityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalConductivityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsThermalConductivityUnit);
+            var asValue = As(unitAsThermalConductivityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ThermalConductivityUnit>.As(ThermalConductivityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ThermalConductivity to another ThermalConductivity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ThermalConductivity{T}" /> to another <see cref="ThermalConductivity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ThermalConductivity with the specified unit.</returns>
-        public ThermalConductivity ToUnit(ThermalConductivityUnit unit)
+        /// <returns>A <see cref="ThermalConductivity{T}" /> with the specified unit.</returns>
+        public ThermalConductivity<T> ToUnit(ThermalConductivityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ThermalConductivity(convertedValue, unit);
+            return new ThermalConductivity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -624,7 +628,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ThermalConductivity ToUnit(UnitSystem unitSystem)
+        public ThermalConductivity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -644,20 +648,26 @@ public ThermalConductivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ThermalConductivityUnit> IQuantity<ThermalConductivityUnit>.ToUnit(ThermalConductivityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ThermalConductivityUnit, T> IQuantityT<ThermalConductivityUnit, T>.ToUnit(ThermalConductivityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ThermalConductivityUnit> IQuantity<ThermalConductivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ThermalConductivityUnit, T> IQuantityT<ThermalConductivityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ThermalConductivityUnit.BtuPerHourFootFahrenheit: return _value*1.73073467;
-                case ThermalConductivityUnit.WattPerMeterKelvin: return _value;
+                case ThermalConductivityUnit.BtuPerHourFootFahrenheit: return Value*1.73073467;
+                case ThermalConductivityUnit.WattPerMeterKelvin: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -668,16 +678,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ThermalConductivity ToBaseUnit()
+        internal ThermalConductivity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ThermalConductivity(baseUnitValue, BaseUnit);
+            return new ThermalConductivity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ThermalConductivityUnit unit)
+        private T GetValueAs(ThermalConductivityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -781,57 +791,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ThermalConductivity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ThermalConductivity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ThermalConductivity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ThermalConductivity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ThermalConductivity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ThermalConductivity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -841,33 +851,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ThermalConductivity))
+            if(conversionType == typeof(ThermalConductivity<T>))
                 return this;
             else if(conversionType == typeof(ThermalConductivityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ThermalConductivity.QuantityType;
+                return ThermalConductivity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ThermalConductivity.Info;
+                return ThermalConductivity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ThermalConductivity.BaseDimensions;
+                return ThermalConductivity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ThermalConductivity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ThermalConductivity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
index f52cc28ff4..e44b00d3ae 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Heat Transfer Coefficient or Thermal conductivity - indicates a materials ability to conduct heat.
     /// </summary>
-    public partial struct ThermalResistance : IQuantity<ThermalResistanceUnit>, IEquatable<ThermalResistance>, IComparable, IComparable<ThermalResistance>, IConvertible, IFormattable
+    public partial struct ThermalResistance<T> : IQuantityT<ThermalResistanceUnit, T>, IEquatable<ThermalResistance<T>>, IComparable, IComparable<ThermalResistance<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -67,12 +63,12 @@ static ThermalResistance()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public ThermalResistance(double value, ThermalResistanceUnit unit)
+        public ThermalResistance(T value, ThermalResistanceUnit unit)
         {
             if(unit == ThermalResistanceUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -84,14 +80,14 @@ public ThermalResistance(double value, ThermalResistanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ThermalResistance(double value, UnitSystem unitSystem)
+        public ThermalResistance(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -106,19 +102,19 @@ public ThermalResistance(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of ThermalResistance, which is SquareMeterKelvinPerKilowatt. All conversions go via this value.
+        ///     The base unit of <see cref="ThermalResistance{T}" />, which is SquareMeterKelvinPerKilowatt. All conversions go via this value.
         /// </summary>
         public static ThermalResistanceUnit BaseUnit { get; } = ThermalResistanceUnit.SquareMeterKelvinPerKilowatt;
 
         /// <summary>
-        /// Represents the largest possible value of ThermalResistance
+        /// Represents the largest possible value of <see cref="ThermalResistance{T}" />
         /// </summary>
-        public static ThermalResistance MaxValue { get; } = new ThermalResistance(double.MaxValue, BaseUnit);
+        public static ThermalResistance<T> MaxValue { get; } = new ThermalResistance<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of ThermalResistance
+        /// Represents the smallest possible value of <see cref="ThermalResistance{T}" />
         /// </summary>
-        public static ThermalResistance MinValue { get; } = new ThermalResistance(double.MinValue, BaseUnit);
+        public static ThermalResistance<T> MinValue { get; } = new ThermalResistance<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -127,14 +123,14 @@ public ThermalResistance(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.ThermalResistance;
 
         /// <summary>
-        ///     All units of measurement for the ThermalResistance quantity.
+        ///     All units of measurement for the <see cref="ThermalResistance{T}" /> quantity.
         /// </summary>
         public static ThermalResistanceUnit[] Units { get; } = Enum.GetValues(typeof(ThermalResistanceUnit)).Cast<ThermalResistanceUnit>().Except(new ThermalResistanceUnit[]{ ThermalResistanceUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit SquareMeterKelvinPerKilowatt.
         /// </summary>
-        public static ThermalResistance Zero { get; } = new ThermalResistance(0, BaseUnit);
+        public static ThermalResistance<T> Zero { get; } = new ThermalResistance<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -143,7 +139,9 @@ public ThermalResistance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -159,41 +157,41 @@ public ThermalResistance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => ThermalResistance.QuantityType;
+        public QuantityType Type => ThermalResistance<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => ThermalResistance.BaseDimensions;
+        public BaseDimensions Dimensions => ThermalResistance<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get ThermalResistance in HourSquareFeetDegreesFahrenheitPerBtu.
+        ///     Get <see cref="ThermalResistance{T}" /> in HourSquareFeetDegreesFahrenheitPerBtu.
         /// </summary>
-        public double HourSquareFeetDegreesFahrenheitPerBtu => As(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
+        public T HourSquareFeetDegreesFahrenheitPerBtu => As(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
 
         /// <summary>
-        ///     Get ThermalResistance in SquareCentimeterHourDegreesCelsiusPerKilocalorie.
+        ///     Get <see cref="ThermalResistance{T}" /> in SquareCentimeterHourDegreesCelsiusPerKilocalorie.
         /// </summary>
-        public double SquareCentimeterHourDegreesCelsiusPerKilocalorie => As(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
+        public T SquareCentimeterHourDegreesCelsiusPerKilocalorie => As(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
 
         /// <summary>
-        ///     Get ThermalResistance in SquareCentimeterKelvinsPerWatt.
+        ///     Get <see cref="ThermalResistance{T}" /> in SquareCentimeterKelvinsPerWatt.
         /// </summary>
-        public double SquareCentimeterKelvinsPerWatt => As(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
+        public T SquareCentimeterKelvinsPerWatt => As(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
 
         /// <summary>
-        ///     Get ThermalResistance in SquareMeterDegreesCelsiusPerWatt.
+        ///     Get <see cref="ThermalResistance{T}" /> in SquareMeterDegreesCelsiusPerWatt.
         /// </summary>
-        public double SquareMeterDegreesCelsiusPerWatt => As(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
+        public T SquareMeterDegreesCelsiusPerWatt => As(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
 
         /// <summary>
-        ///     Get ThermalResistance in SquareMeterKelvinsPerKilowatt.
+        ///     Get <see cref="ThermalResistance{T}" /> in SquareMeterKelvinsPerKilowatt.
         /// </summary>
-        public double SquareMeterKelvinsPerKilowatt => As(ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
+        public T SquareMeterKelvinsPerKilowatt => As(ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
 
         #endregion
 
@@ -225,60 +223,55 @@ public static string GetAbbreviation(ThermalResistanceUnit unit, IFormatProvider
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get ThermalResistance from HourSquareFeetDegreesFahrenheitPerBtu.
+        ///     Get <see cref="ThermalResistance{T}" /> from HourSquareFeetDegreesFahrenheitPerBtu.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(QuantityValue hoursquarefeetdegreesfahrenheitperbtu)
+        public static ThermalResistance<T> FromHourSquareFeetDegreesFahrenheitPerBtu(T hoursquarefeetdegreesfahrenheitperbtu)
         {
-            double value = (double) hoursquarefeetdegreesfahrenheitperbtu;
-            return new ThermalResistance(value, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
+            return new ThermalResistance<T>(hoursquarefeetdegreesfahrenheitperbtu, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
         }
         /// <summary>
-        ///     Get ThermalResistance from SquareCentimeterHourDegreesCelsiusPerKilocalorie.
+        ///     Get <see cref="ThermalResistance{T}" /> from SquareCentimeterHourDegreesCelsiusPerKilocalorie.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(QuantityValue squarecentimeterhourdegreescelsiusperkilocalorie)
+        public static ThermalResistance<T> FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(T squarecentimeterhourdegreescelsiusperkilocalorie)
         {
-            double value = (double) squarecentimeterhourdegreescelsiusperkilocalorie;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
+            return new ThermalResistance<T>(squarecentimeterhourdegreescelsiusperkilocalorie, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
         }
         /// <summary>
-        ///     Get ThermalResistance from SquareCentimeterKelvinsPerWatt.
+        ///     Get <see cref="ThermalResistance{T}" /> from SquareCentimeterKelvinsPerWatt.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(QuantityValue squarecentimeterkelvinsperwatt)
+        public static ThermalResistance<T> FromSquareCentimeterKelvinsPerWatt(T squarecentimeterkelvinsperwatt)
         {
-            double value = (double) squarecentimeterkelvinsperwatt;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
+            return new ThermalResistance<T>(squarecentimeterkelvinsperwatt, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
         }
         /// <summary>
-        ///     Get ThermalResistance from SquareMeterDegreesCelsiusPerWatt.
+        ///     Get <see cref="ThermalResistance{T}" /> from SquareMeterDegreesCelsiusPerWatt.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(QuantityValue squaremeterdegreescelsiusperwatt)
+        public static ThermalResistance<T> FromSquareMeterDegreesCelsiusPerWatt(T squaremeterdegreescelsiusperwatt)
         {
-            double value = (double) squaremeterdegreescelsiusperwatt;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
+            return new ThermalResistance<T>(squaremeterdegreescelsiusperwatt, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
         }
         /// <summary>
-        ///     Get ThermalResistance from SquareMeterKelvinsPerKilowatt.
+        ///     Get <see cref="ThermalResistance{T}" /> from SquareMeterKelvinsPerKilowatt.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(QuantityValue squaremeterkelvinsperkilowatt)
+        public static ThermalResistance<T> FromSquareMeterKelvinsPerKilowatt(T squaremeterkelvinsperkilowatt)
         {
-            double value = (double) squaremeterkelvinsperkilowatt;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
+            return new ThermalResistance<T>(squaremeterkelvinsperkilowatt, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ThermalResistanceUnit" /> to <see cref="ThermalResistance" />.
+        ///     Dynamically convert from value and unit enum <see cref="ThermalResistanceUnit" /> to <see cref="ThermalResistance{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ThermalResistance unit value.</returns>
-        public static ThermalResistance From(QuantityValue value, ThermalResistanceUnit fromUnit)
+        /// <returns><see cref="ThermalResistance{T}" /> unit value.</returns>
+        public static ThermalResistance<T> From(T value, ThermalResistanceUnit fromUnit)
         {
-            return new ThermalResistance((double)value, fromUnit);
+            return new ThermalResistance<T>(value, fromUnit);
         }
 
         #endregion
@@ -307,7 +300,7 @@ public static ThermalResistance From(QuantityValue value, ThermalResistanceUnit
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static ThermalResistance Parse(string str)
+        public static ThermalResistance<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -335,9 +328,9 @@ public static ThermalResistance Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static ThermalResistance Parse(string str, IFormatProvider? provider)
+        public static ThermalResistance<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<ThermalResistance, ThermalResistanceUnit>(
+            return QuantityParser.Default.Parse<T, ThermalResistance<T>, ThermalResistanceUnit>(
                 str,
                 provider,
                 From);
@@ -351,7 +344,7 @@ public static ThermalResistance Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out ThermalResistance result)
+        public static bool TryParse(string? str, out ThermalResistance<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -366,9 +359,9 @@ public static bool TryParse(string? str, out ThermalResistance result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out ThermalResistance result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out ThermalResistance<T> result)
         {
-            return QuantityParser.Default.TryParse<ThermalResistance, ThermalResistanceUnit>(
+            return QuantityParser.Default.TryParse<T, ThermalResistance<T>, ThermalResistanceUnit>(
                 str,
                 provider,
                 From,
@@ -430,45 +423,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Therm
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static ThermalResistance operator -(ThermalResistance right)
+        public static ThermalResistance<T> operator -(ThermalResistance<T> right)
         {
-            return new ThermalResistance(-right.Value, right.Unit);
+            return new ThermalResistance<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalResistance"/> from adding two <see cref="ThermalResistance"/>.</summary>
-        public static ThermalResistance operator +(ThermalResistance left, ThermalResistance right)
+        /// <summary>Get <see cref="ThermalResistance{T}"/> from adding two <see cref="ThermalResistance{T}"/>.</summary>
+        public static ThermalResistance<T> operator +(ThermalResistance<T> left, ThermalResistance<T> right)
         {
-            return new ThermalResistance(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new ThermalResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalResistance"/> from subtracting two <see cref="ThermalResistance"/>.</summary>
-        public static ThermalResistance operator -(ThermalResistance left, ThermalResistance right)
+        /// <summary>Get <see cref="ThermalResistance{T}"/> from subtracting two <see cref="ThermalResistance{T}"/>.</summary>
+        public static ThermalResistance<T> operator -(ThermalResistance<T> left, ThermalResistance<T> right)
         {
-            return new ThermalResistance(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new ThermalResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalResistance"/> from multiplying value and <see cref="ThermalResistance"/>.</summary>
-        public static ThermalResistance operator *(double left, ThermalResistance right)
+        /// <summary>Get <see cref="ThermalResistance{T}"/> from multiplying value and <see cref="ThermalResistance{T}"/>.</summary>
+        public static ThermalResistance<T> operator *(T left, ThermalResistance<T> right)
         {
-            return new ThermalResistance(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new ThermalResistance<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalResistance"/> from multiplying value and <see cref="ThermalResistance"/>.</summary>
-        public static ThermalResistance operator *(ThermalResistance left, double right)
+        /// <summary>Get <see cref="ThermalResistance{T}"/> from multiplying value and <see cref="ThermalResistance{T}"/>.</summary>
+        public static ThermalResistance<T> operator *(ThermalResistance<T> left, T right)
         {
-            return new ThermalResistance(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new ThermalResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="ThermalResistance"/> from dividing <see cref="ThermalResistance"/> by value.</summary>
-        public static ThermalResistance operator /(ThermalResistance left, double right)
+        /// <summary>Get <see cref="ThermalResistance{T}"/> from dividing <see cref="ThermalResistance{T}"/> by value.</summary>
+        public static ThermalResistance<T> operator /(ThermalResistance<T> left, T right)
         {
-            return new ThermalResistance(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new ThermalResistance<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="ThermalResistance"/> by <see cref="ThermalResistance"/>.</summary>
-        public static double operator /(ThermalResistance left, ThermalResistance right)
+        /// <summary>Get ratio value from dividing <see cref="ThermalResistance{T}"/> by <see cref="ThermalResistance{T}"/>.</summary>
+        public static T operator /(ThermalResistance<T> left, ThermalResistance<T> right)
         {
-            return left.SquareMeterKelvinsPerKilowatt / right.SquareMeterKelvinsPerKilowatt;
+            return CompiledLambdas.Divide(left.SquareMeterKelvinsPerKilowatt, right.SquareMeterKelvinsPerKilowatt);
         }
 
         #endregion
@@ -476,39 +474,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Therm
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(ThermalResistance left, ThermalResistance right)
+        public static bool operator <=(ThermalResistance<T> left, ThermalResistance<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(ThermalResistance left, ThermalResistance right)
+        public static bool operator >=(ThermalResistance<T> left, ThermalResistance<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(ThermalResistance left, ThermalResistance right)
+        public static bool operator <(ThermalResistance<T> left, ThermalResistance<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(ThermalResistance left, ThermalResistance right)
+        public static bool operator >(ThermalResistance<T> left, ThermalResistance<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ThermalResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(ThermalResistance left, ThermalResistance right)
+        /// <remarks>Consider using <see cref="Equals(ThermalResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(ThermalResistance<T> left, ThermalResistance<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(ThermalResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(ThermalResistance left, ThermalResistance right)
+        /// <remarks>Consider using <see cref="Equals(ThermalResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(ThermalResistance<T> left, ThermalResistance<T> right)
         {
             return !(left == right);
         }
@@ -517,37 +515,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Therm
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is ThermalResistance objThermalResistance)) throw new ArgumentException("Expected type ThermalResistance.", nameof(obj));
+            if(!(obj is ThermalResistance<T> objThermalResistance)) throw new ArgumentException("Expected type ThermalResistance.", nameof(obj));
 
             return CompareTo(objThermalResistance);
         }
 
         /// <inheritdoc />
-        public int CompareTo(ThermalResistance other)
+        public int CompareTo(ThermalResistance<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ThermalResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(ThermalResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is ThermalResistance objThermalResistance))
+            if(obj is null || !(obj is ThermalResistance<T> objThermalResistance))
                 return false;
 
             return Equals(objThermalResistance);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(ThermalResistance, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(ThermalResistance other)
+        /// <remarks>Consider using <see cref="Equals(ThermalResistance{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(ThermalResistance<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another ThermalResistance within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="ThermalResistance{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -585,21 +583,19 @@ public bool Equals(ThermalResistance other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(ThermalResistance other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(ThermalResistance<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current ThermalResistance.</returns>
+        /// <returns>A hash code for the current <see cref="ThermalResistance{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -613,17 +609,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(ThermalResistanceUnit unit)
+        public T As(ThermalResistanceUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -643,17 +639,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is ThermalResistanceUnit unitAsThermalResistanceUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalResistanceUnit)} is supported.", nameof(unit));
 
-            return As(unitAsThermalResistanceUnit);
+            var asValue = As(unitAsThermalResistanceUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<ThermalResistanceUnit>.As(ThermalResistanceUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this ThermalResistance to another ThermalResistance with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="ThermalResistance{T}" /> to another <see cref="ThermalResistance{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A ThermalResistance with the specified unit.</returns>
-        public ThermalResistance ToUnit(ThermalResistanceUnit unit)
+        /// <returns>A <see cref="ThermalResistance{T}" /> with the specified unit.</returns>
+        public ThermalResistance<T> ToUnit(ThermalResistanceUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new ThermalResistance(convertedValue, unit);
+            return new ThermalResistance<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -666,7 +667,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public ThermalResistance ToUnit(UnitSystem unitSystem)
+        public ThermalResistance<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -686,23 +687,29 @@ public ThermalResistance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ThermalResistanceUnit> IQuantity<ThermalResistanceUnit>.ToUnit(ThermalResistanceUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<ThermalResistanceUnit, T> IQuantityT<ThermalResistanceUnit, T>.ToUnit(ThermalResistanceUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<ThermalResistanceUnit> IQuantity<ThermalResistanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<ThermalResistanceUnit, T> IQuantityT<ThermalResistanceUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: return _value*176.1121482159839;
-                case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: return _value*0.0859779507590433;
-                case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: return _value*0.0999964777570357;
-                case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: return _value*1000.088056074108;
-                case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: return _value;
+                case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: return Value*176.1121482159839;
+                case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: return Value*0.0859779507590433;
+                case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: return Value*0.0999964777570357;
+                case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: return Value*1000.088056074108;
+                case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -713,16 +720,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal ThermalResistance ToBaseUnit()
+        internal ThermalResistance<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new ThermalResistance(baseUnitValue, BaseUnit);
+            return new ThermalResistance<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(ThermalResistanceUnit unit)
+        private T GetValueAs(ThermalResistanceUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -829,57 +836,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ThermalResistance)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ThermalResistance<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ThermalResistance)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ThermalResistance<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(ThermalResistance)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(ThermalResistance<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -889,33 +896,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(ThermalResistance))
+            if(conversionType == typeof(ThermalResistance<T>))
                 return this;
             else if(conversionType == typeof(ThermalResistanceUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return ThermalResistance.QuantityType;
+                return ThermalResistance<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return ThermalResistance.Info;
+                return ThermalResistance<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return ThermalResistance.BaseDimensions;
+                return ThermalResistance<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(ThermalResistance)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(ThermalResistance<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
index 66891854ab..a27105b619 100644
--- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Torque, moment or moment of force (see the terminology below), is the tendency of a force to rotate an object about an axis,[1] fulcrum, or pivot. Just as a force is a push or a pull, a torque can be thought of as a twist to an object. Mathematically, torque is defined as the cross product of the lever-arm distance and force, which tends to produce rotation. Loosely speaking, torque is a measure of the turning force on an object such as a bolt or a flywheel. For example, pushing or pulling the handle of a wrench connected to a nut or bolt produces a torque (turning force) that loosens or tightens the nut or bolt.
     /// </summary>
-    public partial struct Torque : IQuantity<TorqueUnit>, IEquatable<Torque>, IComparable, IComparable<Torque>, IConvertible, IFormattable
+    public partial struct Torque<T> : IQuantityT<TorqueUnit, T>, IEquatable<Torque<T>>, IComparable, IComparable<Torque<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -84,12 +80,12 @@ static Torque()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Torque(double value, TorqueUnit unit)
+        public Torque(T value, TorqueUnit unit)
         {
             if(unit == TorqueUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -101,14 +97,14 @@ public Torque(double value, TorqueUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Torque(double value, UnitSystem unitSystem)
+        public Torque(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -123,19 +119,19 @@ public Torque(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Torque, which is NewtonMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Torque{T}" />, which is NewtonMeter. All conversions go via this value.
         /// </summary>
         public static TorqueUnit BaseUnit { get; } = TorqueUnit.NewtonMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Torque
+        /// Represents the largest possible value of <see cref="Torque{T}" />
         /// </summary>
-        public static Torque MaxValue { get; } = new Torque(double.MaxValue, BaseUnit);
+        public static Torque<T> MaxValue { get; } = new Torque<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Torque
+        /// Represents the smallest possible value of <see cref="Torque{T}" />
         /// </summary>
-        public static Torque MinValue { get; } = new Torque(double.MinValue, BaseUnit);
+        public static Torque<T> MinValue { get; } = new Torque<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -144,14 +140,14 @@ public Torque(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Torque;
 
         /// <summary>
-        ///     All units of measurement for the Torque quantity.
+        ///     All units of measurement for the <see cref="Torque{T}" /> quantity.
         /// </summary>
         public static TorqueUnit[] Units { get; } = Enum.GetValues(typeof(TorqueUnit)).Cast<TorqueUnit>().Except(new TorqueUnit[]{ TorqueUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonMeter.
         /// </summary>
-        public static Torque Zero { get; } = new Torque(0, BaseUnit);
+        public static Torque<T> Zero { get; } = new Torque<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -160,7 +156,9 @@ public Torque(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -176,126 +174,126 @@ public Torque(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Torque.QuantityType;
+        public QuantityType Type => Torque<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Torque.BaseDimensions;
+        public BaseDimensions Dimensions => Torque<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Torque in KilogramForceCentimeters.
+        ///     Get <see cref="Torque{T}" /> in KilogramForceCentimeters.
         /// </summary>
-        public double KilogramForceCentimeters => As(TorqueUnit.KilogramForceCentimeter);
+        public T KilogramForceCentimeters => As(TorqueUnit.KilogramForceCentimeter);
 
         /// <summary>
-        ///     Get Torque in KilogramForceMeters.
+        ///     Get <see cref="Torque{T}" /> in KilogramForceMeters.
         /// </summary>
-        public double KilogramForceMeters => As(TorqueUnit.KilogramForceMeter);
+        public T KilogramForceMeters => As(TorqueUnit.KilogramForceMeter);
 
         /// <summary>
-        ///     Get Torque in KilogramForceMillimeters.
+        ///     Get <see cref="Torque{T}" /> in KilogramForceMillimeters.
         /// </summary>
-        public double KilogramForceMillimeters => As(TorqueUnit.KilogramForceMillimeter);
+        public T KilogramForceMillimeters => As(TorqueUnit.KilogramForceMillimeter);
 
         /// <summary>
-        ///     Get Torque in KilonewtonCentimeters.
+        ///     Get <see cref="Torque{T}" /> in KilonewtonCentimeters.
         /// </summary>
-        public double KilonewtonCentimeters => As(TorqueUnit.KilonewtonCentimeter);
+        public T KilonewtonCentimeters => As(TorqueUnit.KilonewtonCentimeter);
 
         /// <summary>
-        ///     Get Torque in KilonewtonMeters.
+        ///     Get <see cref="Torque{T}" /> in KilonewtonMeters.
         /// </summary>
-        public double KilonewtonMeters => As(TorqueUnit.KilonewtonMeter);
+        public T KilonewtonMeters => As(TorqueUnit.KilonewtonMeter);
 
         /// <summary>
-        ///     Get Torque in KilonewtonMillimeters.
+        ///     Get <see cref="Torque{T}" /> in KilonewtonMillimeters.
         /// </summary>
-        public double KilonewtonMillimeters => As(TorqueUnit.KilonewtonMillimeter);
+        public T KilonewtonMillimeters => As(TorqueUnit.KilonewtonMillimeter);
 
         /// <summary>
-        ///     Get Torque in KilopoundForceFeet.
+        ///     Get <see cref="Torque{T}" /> in KilopoundForceFeet.
         /// </summary>
-        public double KilopoundForceFeet => As(TorqueUnit.KilopoundForceFoot);
+        public T KilopoundForceFeet => As(TorqueUnit.KilopoundForceFoot);
 
         /// <summary>
-        ///     Get Torque in KilopoundForceInches.
+        ///     Get <see cref="Torque{T}" /> in KilopoundForceInches.
         /// </summary>
-        public double KilopoundForceInches => As(TorqueUnit.KilopoundForceInch);
+        public T KilopoundForceInches => As(TorqueUnit.KilopoundForceInch);
 
         /// <summary>
-        ///     Get Torque in MeganewtonCentimeters.
+        ///     Get <see cref="Torque{T}" /> in MeganewtonCentimeters.
         /// </summary>
-        public double MeganewtonCentimeters => As(TorqueUnit.MeganewtonCentimeter);
+        public T MeganewtonCentimeters => As(TorqueUnit.MeganewtonCentimeter);
 
         /// <summary>
-        ///     Get Torque in MeganewtonMeters.
+        ///     Get <see cref="Torque{T}" /> in MeganewtonMeters.
         /// </summary>
-        public double MeganewtonMeters => As(TorqueUnit.MeganewtonMeter);
+        public T MeganewtonMeters => As(TorqueUnit.MeganewtonMeter);
 
         /// <summary>
-        ///     Get Torque in MeganewtonMillimeters.
+        ///     Get <see cref="Torque{T}" /> in MeganewtonMillimeters.
         /// </summary>
-        public double MeganewtonMillimeters => As(TorqueUnit.MeganewtonMillimeter);
+        public T MeganewtonMillimeters => As(TorqueUnit.MeganewtonMillimeter);
 
         /// <summary>
-        ///     Get Torque in MegapoundForceFeet.
+        ///     Get <see cref="Torque{T}" /> in MegapoundForceFeet.
         /// </summary>
-        public double MegapoundForceFeet => As(TorqueUnit.MegapoundForceFoot);
+        public T MegapoundForceFeet => As(TorqueUnit.MegapoundForceFoot);
 
         /// <summary>
-        ///     Get Torque in MegapoundForceInches.
+        ///     Get <see cref="Torque{T}" /> in MegapoundForceInches.
         /// </summary>
-        public double MegapoundForceInches => As(TorqueUnit.MegapoundForceInch);
+        public T MegapoundForceInches => As(TorqueUnit.MegapoundForceInch);
 
         /// <summary>
-        ///     Get Torque in NewtonCentimeters.
+        ///     Get <see cref="Torque{T}" /> in NewtonCentimeters.
         /// </summary>
-        public double NewtonCentimeters => As(TorqueUnit.NewtonCentimeter);
+        public T NewtonCentimeters => As(TorqueUnit.NewtonCentimeter);
 
         /// <summary>
-        ///     Get Torque in NewtonMeters.
+        ///     Get <see cref="Torque{T}" /> in NewtonMeters.
         /// </summary>
-        public double NewtonMeters => As(TorqueUnit.NewtonMeter);
+        public T NewtonMeters => As(TorqueUnit.NewtonMeter);
 
         /// <summary>
-        ///     Get Torque in NewtonMillimeters.
+        ///     Get <see cref="Torque{T}" /> in NewtonMillimeters.
         /// </summary>
-        public double NewtonMillimeters => As(TorqueUnit.NewtonMillimeter);
+        public T NewtonMillimeters => As(TorqueUnit.NewtonMillimeter);
 
         /// <summary>
-        ///     Get Torque in PoundalFeet.
+        ///     Get <see cref="Torque{T}" /> in PoundalFeet.
         /// </summary>
-        public double PoundalFeet => As(TorqueUnit.PoundalFoot);
+        public T PoundalFeet => As(TorqueUnit.PoundalFoot);
 
         /// <summary>
-        ///     Get Torque in PoundForceFeet.
+        ///     Get <see cref="Torque{T}" /> in PoundForceFeet.
         /// </summary>
-        public double PoundForceFeet => As(TorqueUnit.PoundForceFoot);
+        public T PoundForceFeet => As(TorqueUnit.PoundForceFoot);
 
         /// <summary>
-        ///     Get Torque in PoundForceInches.
+        ///     Get <see cref="Torque{T}" /> in PoundForceInches.
         /// </summary>
-        public double PoundForceInches => As(TorqueUnit.PoundForceInch);
+        public T PoundForceInches => As(TorqueUnit.PoundForceInch);
 
         /// <summary>
-        ///     Get Torque in TonneForceCentimeters.
+        ///     Get <see cref="Torque{T}" /> in TonneForceCentimeters.
         /// </summary>
-        public double TonneForceCentimeters => As(TorqueUnit.TonneForceCentimeter);
+        public T TonneForceCentimeters => As(TorqueUnit.TonneForceCentimeter);
 
         /// <summary>
-        ///     Get Torque in TonneForceMeters.
+        ///     Get <see cref="Torque{T}" /> in TonneForceMeters.
         /// </summary>
-        public double TonneForceMeters => As(TorqueUnit.TonneForceMeter);
+        public T TonneForceMeters => As(TorqueUnit.TonneForceMeter);
 
         /// <summary>
-        ///     Get Torque in TonneForceMillimeters.
+        ///     Get <see cref="Torque{T}" /> in TonneForceMillimeters.
         /// </summary>
-        public double TonneForceMillimeters => As(TorqueUnit.TonneForceMillimeter);
+        public T TonneForceMillimeters => As(TorqueUnit.TonneForceMillimeter);
 
         #endregion
 
@@ -327,213 +325,191 @@ public static string GetAbbreviation(TorqueUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Torque from KilogramForceCentimeters.
+        ///     Get <see cref="Torque{T}" /> from KilogramForceCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceCentimeters(QuantityValue kilogramforcecentimeters)
+        public static Torque<T> FromKilogramForceCentimeters(T kilogramforcecentimeters)
         {
-            double value = (double) kilogramforcecentimeters;
-            return new Torque(value, TorqueUnit.KilogramForceCentimeter);
+            return new Torque<T>(kilogramforcecentimeters, TorqueUnit.KilogramForceCentimeter);
         }
         /// <summary>
-        ///     Get Torque from KilogramForceMeters.
+        ///     Get <see cref="Torque{T}" /> from KilogramForceMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceMeters(QuantityValue kilogramforcemeters)
+        public static Torque<T> FromKilogramForceMeters(T kilogramforcemeters)
         {
-            double value = (double) kilogramforcemeters;
-            return new Torque(value, TorqueUnit.KilogramForceMeter);
+            return new Torque<T>(kilogramforcemeters, TorqueUnit.KilogramForceMeter);
         }
         /// <summary>
-        ///     Get Torque from KilogramForceMillimeters.
+        ///     Get <see cref="Torque{T}" /> from KilogramForceMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceMillimeters(QuantityValue kilogramforcemillimeters)
+        public static Torque<T> FromKilogramForceMillimeters(T kilogramforcemillimeters)
         {
-            double value = (double) kilogramforcemillimeters;
-            return new Torque(value, TorqueUnit.KilogramForceMillimeter);
+            return new Torque<T>(kilogramforcemillimeters, TorqueUnit.KilogramForceMillimeter);
         }
         /// <summary>
-        ///     Get Torque from KilonewtonCentimeters.
+        ///     Get <see cref="Torque{T}" /> from KilonewtonCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonCentimeters(QuantityValue kilonewtoncentimeters)
+        public static Torque<T> FromKilonewtonCentimeters(T kilonewtoncentimeters)
         {
-            double value = (double) kilonewtoncentimeters;
-            return new Torque(value, TorqueUnit.KilonewtonCentimeter);
+            return new Torque<T>(kilonewtoncentimeters, TorqueUnit.KilonewtonCentimeter);
         }
         /// <summary>
-        ///     Get Torque from KilonewtonMeters.
+        ///     Get <see cref="Torque{T}" /> from KilonewtonMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonMeters(QuantityValue kilonewtonmeters)
+        public static Torque<T> FromKilonewtonMeters(T kilonewtonmeters)
         {
-            double value = (double) kilonewtonmeters;
-            return new Torque(value, TorqueUnit.KilonewtonMeter);
+            return new Torque<T>(kilonewtonmeters, TorqueUnit.KilonewtonMeter);
         }
         /// <summary>
-        ///     Get Torque from KilonewtonMillimeters.
+        ///     Get <see cref="Torque{T}" /> from KilonewtonMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonMillimeters(QuantityValue kilonewtonmillimeters)
+        public static Torque<T> FromKilonewtonMillimeters(T kilonewtonmillimeters)
         {
-            double value = (double) kilonewtonmillimeters;
-            return new Torque(value, TorqueUnit.KilonewtonMillimeter);
+            return new Torque<T>(kilonewtonmillimeters, TorqueUnit.KilonewtonMillimeter);
         }
         /// <summary>
-        ///     Get Torque from KilopoundForceFeet.
+        ///     Get <see cref="Torque{T}" /> from KilopoundForceFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilopoundForceFeet(QuantityValue kilopoundforcefeet)
+        public static Torque<T> FromKilopoundForceFeet(T kilopoundforcefeet)
         {
-            double value = (double) kilopoundforcefeet;
-            return new Torque(value, TorqueUnit.KilopoundForceFoot);
+            return new Torque<T>(kilopoundforcefeet, TorqueUnit.KilopoundForceFoot);
         }
         /// <summary>
-        ///     Get Torque from KilopoundForceInches.
+        ///     Get <see cref="Torque{T}" /> from KilopoundForceInches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilopoundForceInches(QuantityValue kilopoundforceinches)
+        public static Torque<T> FromKilopoundForceInches(T kilopoundforceinches)
         {
-            double value = (double) kilopoundforceinches;
-            return new Torque(value, TorqueUnit.KilopoundForceInch);
+            return new Torque<T>(kilopoundforceinches, TorqueUnit.KilopoundForceInch);
         }
         /// <summary>
-        ///     Get Torque from MeganewtonCentimeters.
+        ///     Get <see cref="Torque{T}" /> from MeganewtonCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonCentimeters(QuantityValue meganewtoncentimeters)
+        public static Torque<T> FromMeganewtonCentimeters(T meganewtoncentimeters)
         {
-            double value = (double) meganewtoncentimeters;
-            return new Torque(value, TorqueUnit.MeganewtonCentimeter);
+            return new Torque<T>(meganewtoncentimeters, TorqueUnit.MeganewtonCentimeter);
         }
         /// <summary>
-        ///     Get Torque from MeganewtonMeters.
+        ///     Get <see cref="Torque{T}" /> from MeganewtonMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonMeters(QuantityValue meganewtonmeters)
+        public static Torque<T> FromMeganewtonMeters(T meganewtonmeters)
         {
-            double value = (double) meganewtonmeters;
-            return new Torque(value, TorqueUnit.MeganewtonMeter);
+            return new Torque<T>(meganewtonmeters, TorqueUnit.MeganewtonMeter);
         }
         /// <summary>
-        ///     Get Torque from MeganewtonMillimeters.
+        ///     Get <see cref="Torque{T}" /> from MeganewtonMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonMillimeters(QuantityValue meganewtonmillimeters)
+        public static Torque<T> FromMeganewtonMillimeters(T meganewtonmillimeters)
         {
-            double value = (double) meganewtonmillimeters;
-            return new Torque(value, TorqueUnit.MeganewtonMillimeter);
+            return new Torque<T>(meganewtonmillimeters, TorqueUnit.MeganewtonMillimeter);
         }
         /// <summary>
-        ///     Get Torque from MegapoundForceFeet.
+        ///     Get <see cref="Torque{T}" /> from MegapoundForceFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMegapoundForceFeet(QuantityValue megapoundforcefeet)
+        public static Torque<T> FromMegapoundForceFeet(T megapoundforcefeet)
         {
-            double value = (double) megapoundforcefeet;
-            return new Torque(value, TorqueUnit.MegapoundForceFoot);
+            return new Torque<T>(megapoundforcefeet, TorqueUnit.MegapoundForceFoot);
         }
         /// <summary>
-        ///     Get Torque from MegapoundForceInches.
+        ///     Get <see cref="Torque{T}" /> from MegapoundForceInches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMegapoundForceInches(QuantityValue megapoundforceinches)
+        public static Torque<T> FromMegapoundForceInches(T megapoundforceinches)
         {
-            double value = (double) megapoundforceinches;
-            return new Torque(value, TorqueUnit.MegapoundForceInch);
+            return new Torque<T>(megapoundforceinches, TorqueUnit.MegapoundForceInch);
         }
         /// <summary>
-        ///     Get Torque from NewtonCentimeters.
+        ///     Get <see cref="Torque{T}" /> from NewtonCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonCentimeters(QuantityValue newtoncentimeters)
+        public static Torque<T> FromNewtonCentimeters(T newtoncentimeters)
         {
-            double value = (double) newtoncentimeters;
-            return new Torque(value, TorqueUnit.NewtonCentimeter);
+            return new Torque<T>(newtoncentimeters, TorqueUnit.NewtonCentimeter);
         }
         /// <summary>
-        ///     Get Torque from NewtonMeters.
+        ///     Get <see cref="Torque{T}" /> from NewtonMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonMeters(QuantityValue newtonmeters)
+        public static Torque<T> FromNewtonMeters(T newtonmeters)
         {
-            double value = (double) newtonmeters;
-            return new Torque(value, TorqueUnit.NewtonMeter);
+            return new Torque<T>(newtonmeters, TorqueUnit.NewtonMeter);
         }
         /// <summary>
-        ///     Get Torque from NewtonMillimeters.
+        ///     Get <see cref="Torque{T}" /> from NewtonMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonMillimeters(QuantityValue newtonmillimeters)
+        public static Torque<T> FromNewtonMillimeters(T newtonmillimeters)
         {
-            double value = (double) newtonmillimeters;
-            return new Torque(value, TorqueUnit.NewtonMillimeter);
+            return new Torque<T>(newtonmillimeters, TorqueUnit.NewtonMillimeter);
         }
         /// <summary>
-        ///     Get Torque from PoundalFeet.
+        ///     Get <see cref="Torque{T}" /> from PoundalFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundalFeet(QuantityValue poundalfeet)
+        public static Torque<T> FromPoundalFeet(T poundalfeet)
         {
-            double value = (double) poundalfeet;
-            return new Torque(value, TorqueUnit.PoundalFoot);
+            return new Torque<T>(poundalfeet, TorqueUnit.PoundalFoot);
         }
         /// <summary>
-        ///     Get Torque from PoundForceFeet.
+        ///     Get <see cref="Torque{T}" /> from PoundForceFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundForceFeet(QuantityValue poundforcefeet)
+        public static Torque<T> FromPoundForceFeet(T poundforcefeet)
         {
-            double value = (double) poundforcefeet;
-            return new Torque(value, TorqueUnit.PoundForceFoot);
+            return new Torque<T>(poundforcefeet, TorqueUnit.PoundForceFoot);
         }
         /// <summary>
-        ///     Get Torque from PoundForceInches.
+        ///     Get <see cref="Torque{T}" /> from PoundForceInches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundForceInches(QuantityValue poundforceinches)
+        public static Torque<T> FromPoundForceInches(T poundforceinches)
         {
-            double value = (double) poundforceinches;
-            return new Torque(value, TorqueUnit.PoundForceInch);
+            return new Torque<T>(poundforceinches, TorqueUnit.PoundForceInch);
         }
         /// <summary>
-        ///     Get Torque from TonneForceCentimeters.
+        ///     Get <see cref="Torque{T}" /> from TonneForceCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceCentimeters(QuantityValue tonneforcecentimeters)
+        public static Torque<T> FromTonneForceCentimeters(T tonneforcecentimeters)
         {
-            double value = (double) tonneforcecentimeters;
-            return new Torque(value, TorqueUnit.TonneForceCentimeter);
+            return new Torque<T>(tonneforcecentimeters, TorqueUnit.TonneForceCentimeter);
         }
         /// <summary>
-        ///     Get Torque from TonneForceMeters.
+        ///     Get <see cref="Torque{T}" /> from TonneForceMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceMeters(QuantityValue tonneforcemeters)
+        public static Torque<T> FromTonneForceMeters(T tonneforcemeters)
         {
-            double value = (double) tonneforcemeters;
-            return new Torque(value, TorqueUnit.TonneForceMeter);
+            return new Torque<T>(tonneforcemeters, TorqueUnit.TonneForceMeter);
         }
         /// <summary>
-        ///     Get Torque from TonneForceMillimeters.
+        ///     Get <see cref="Torque{T}" /> from TonneForceMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceMillimeters(QuantityValue tonneforcemillimeters)
+        public static Torque<T> FromTonneForceMillimeters(T tonneforcemillimeters)
         {
-            double value = (double) tonneforcemillimeters;
-            return new Torque(value, TorqueUnit.TonneForceMillimeter);
+            return new Torque<T>(tonneforcemillimeters, TorqueUnit.TonneForceMillimeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TorqueUnit" /> to <see cref="Torque" />.
+        ///     Dynamically convert from value and unit enum <see cref="TorqueUnit" /> to <see cref="Torque{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Torque unit value.</returns>
-        public static Torque From(QuantityValue value, TorqueUnit fromUnit)
+        /// <returns><see cref="Torque{T}" /> unit value.</returns>
+        public static Torque<T> From(T value, TorqueUnit fromUnit)
         {
-            return new Torque((double)value, fromUnit);
+            return new Torque<T>(value, fromUnit);
         }
 
         #endregion
@@ -562,7 +538,7 @@ public static Torque From(QuantityValue value, TorqueUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Torque Parse(string str)
+        public static Torque<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -590,9 +566,9 @@ public static Torque Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Torque Parse(string str, IFormatProvider? provider)
+        public static Torque<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Torque, TorqueUnit>(
+            return QuantityParser.Default.Parse<T, Torque<T>, TorqueUnit>(
                 str,
                 provider,
                 From);
@@ -606,7 +582,7 @@ public static Torque Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Torque result)
+        public static bool TryParse(string? str, out Torque<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -621,9 +597,9 @@ public static bool TryParse(string? str, out Torque result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Torque result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Torque<T> result)
         {
-            return QuantityParser.Default.TryParse<Torque, TorqueUnit>(
+            return QuantityParser.Default.TryParse<T, Torque<T>, TorqueUnit>(
                 str,
                 provider,
                 From,
@@ -685,45 +661,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Torqu
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Torque operator -(Torque right)
+        public static Torque<T> operator -(Torque<T> right)
         {
-            return new Torque(-right.Value, right.Unit);
+            return new Torque<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Torque"/> from adding two <see cref="Torque"/>.</summary>
-        public static Torque operator +(Torque left, Torque right)
+        /// <summary>Get <see cref="Torque{T}"/> from adding two <see cref="Torque{T}"/>.</summary>
+        public static Torque<T> operator +(Torque<T> left, Torque<T> right)
         {
-            return new Torque(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Torque<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Torque"/> from subtracting two <see cref="Torque"/>.</summary>
-        public static Torque operator -(Torque left, Torque right)
+        /// <summary>Get <see cref="Torque{T}"/> from subtracting two <see cref="Torque{T}"/>.</summary>
+        public static Torque<T> operator -(Torque<T> left, Torque<T> right)
         {
-            return new Torque(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Torque<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Torque"/> from multiplying value and <see cref="Torque"/>.</summary>
-        public static Torque operator *(double left, Torque right)
+        /// <summary>Get <see cref="Torque{T}"/> from multiplying value and <see cref="Torque{T}"/>.</summary>
+        public static Torque<T> operator *(T left, Torque<T> right)
         {
-            return new Torque(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Torque<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Torque"/> from multiplying value and <see cref="Torque"/>.</summary>
-        public static Torque operator *(Torque left, double right)
+        /// <summary>Get <see cref="Torque{T}"/> from multiplying value and <see cref="Torque{T}"/>.</summary>
+        public static Torque<T> operator *(Torque<T> left, T right)
         {
-            return new Torque(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Torque<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Torque"/> from dividing <see cref="Torque"/> by value.</summary>
-        public static Torque operator /(Torque left, double right)
+        /// <summary>Get <see cref="Torque{T}"/> from dividing <see cref="Torque{T}"/> by value.</summary>
+        public static Torque<T> operator /(Torque<T> left, T right)
         {
-            return new Torque(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Torque<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Torque"/> by <see cref="Torque"/>.</summary>
-        public static double operator /(Torque left, Torque right)
+        /// <summary>Get ratio value from dividing <see cref="Torque{T}"/> by <see cref="Torque{T}"/>.</summary>
+        public static T operator /(Torque<T> left, Torque<T> right)
         {
-            return left.NewtonMeters / right.NewtonMeters;
+            return CompiledLambdas.Divide(left.NewtonMeters, right.NewtonMeters);
         }
 
         #endregion
@@ -731,39 +712,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Torqu
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Torque left, Torque right)
+        public static bool operator <=(Torque<T> left, Torque<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Torque left, Torque right)
+        public static bool operator >=(Torque<T> left, Torque<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Torque left, Torque right)
+        public static bool operator <(Torque<T> left, Torque<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Torque left, Torque right)
+        public static bool operator >(Torque<T> left, Torque<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Torque, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Torque left, Torque right)
+        /// <remarks>Consider using <see cref="Equals(Torque{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Torque<T> left, Torque<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Torque, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Torque left, Torque right)
+        /// <remarks>Consider using <see cref="Equals(Torque{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Torque<T> left, Torque<T> right)
         {
             return !(left == right);
         }
@@ -772,37 +753,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Torqu
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Torque objTorque)) throw new ArgumentException("Expected type Torque.", nameof(obj));
+            if(!(obj is Torque<T> objTorque)) throw new ArgumentException("Expected type Torque.", nameof(obj));
 
             return CompareTo(objTorque);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Torque other)
+        public int CompareTo(Torque<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Torque, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Torque{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Torque objTorque))
+            if(obj is null || !(obj is Torque<T> objTorque))
                 return false;
 
             return Equals(objTorque);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Torque, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Torque other)
+        /// <remarks>Consider using <see cref="Equals(Torque{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Torque<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Torque within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Torque{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -840,21 +821,19 @@ public bool Equals(Torque other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Torque other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Torque<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Torque.</returns>
+        /// <returns>A hash code for the current <see cref="Torque{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -868,17 +847,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(TorqueUnit unit)
+        public T As(TorqueUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -898,17 +877,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is TorqueUnit unitAsTorqueUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorqueUnit)} is supported.", nameof(unit));
 
-            return As(unitAsTorqueUnit);
+            var asValue = As(unitAsTorqueUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<TorqueUnit>.As(TorqueUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Torque to another Torque with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Torque{T}" /> to another <see cref="Torque{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Torque with the specified unit.</returns>
-        public Torque ToUnit(TorqueUnit unit)
+        /// <returns>A <see cref="Torque{T}" /> with the specified unit.</returns>
+        public Torque<T> ToUnit(TorqueUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Torque(convertedValue, unit);
+            return new Torque<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -921,7 +905,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Torque ToUnit(UnitSystem unitSystem)
+        public Torque<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -941,40 +925,46 @@ public Torque ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TorqueUnit> IQuantity<TorqueUnit>.ToUnit(TorqueUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<TorqueUnit, T> IQuantityT<TorqueUnit, T>.ToUnit(TorqueUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<TorqueUnit> IQuantity<TorqueUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<TorqueUnit, T> IQuantityT<TorqueUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case TorqueUnit.KilogramForceCentimeter: return _value*0.0980665019960652;
-                case TorqueUnit.KilogramForceMeter: return _value*9.80665019960652;
-                case TorqueUnit.KilogramForceMillimeter: return _value*0.00980665019960652;
-                case TorqueUnit.KilonewtonCentimeter: return (_value*0.01) * 1e3d;
-                case TorqueUnit.KilonewtonMeter: return (_value) * 1e3d;
-                case TorqueUnit.KilonewtonMillimeter: return (_value*0.001) * 1e3d;
-                case TorqueUnit.KilopoundForceFoot: return (_value*1.3558179483314) * 1e3d;
-                case TorqueUnit.KilopoundForceInch: return (_value*1.129848290276167e-1) * 1e3d;
-                case TorqueUnit.MeganewtonCentimeter: return (_value*0.01) * 1e6d;
-                case TorqueUnit.MeganewtonMeter: return (_value) * 1e6d;
-                case TorqueUnit.MeganewtonMillimeter: return (_value*0.001) * 1e6d;
-                case TorqueUnit.MegapoundForceFoot: return (_value*1.3558179483314) * 1e6d;
-                case TorqueUnit.MegapoundForceInch: return (_value*1.129848290276167e-1) * 1e6d;
-                case TorqueUnit.NewtonCentimeter: return _value*0.01;
-                case TorqueUnit.NewtonMeter: return _value;
-                case TorqueUnit.NewtonMillimeter: return _value*0.001;
-                case TorqueUnit.PoundalFoot: return _value*4.21401100938048e-2;
-                case TorqueUnit.PoundForceFoot: return _value*1.3558179483314;
-                case TorqueUnit.PoundForceInch: return _value*1.129848290276167e-1;
-                case TorqueUnit.TonneForceCentimeter: return _value*98.0665019960652;
-                case TorqueUnit.TonneForceMeter: return _value*9806.65019960653;
-                case TorqueUnit.TonneForceMillimeter: return _value*9.80665019960652;
+                case TorqueUnit.KilogramForceCentimeter: return Value*0.0980665019960652;
+                case TorqueUnit.KilogramForceMeter: return Value*9.80665019960652;
+                case TorqueUnit.KilogramForceMillimeter: return Value*0.00980665019960652;
+                case TorqueUnit.KilonewtonCentimeter: return (Value*0.01) * 1e3d;
+                case TorqueUnit.KilonewtonMeter: return (Value) * 1e3d;
+                case TorqueUnit.KilonewtonMillimeter: return (Value*0.001) * 1e3d;
+                case TorqueUnit.KilopoundForceFoot: return (Value*1.3558179483314) * 1e3d;
+                case TorqueUnit.KilopoundForceInch: return (Value*1.129848290276167e-1) * 1e3d;
+                case TorqueUnit.MeganewtonCentimeter: return (Value*0.01) * 1e6d;
+                case TorqueUnit.MeganewtonMeter: return (Value) * 1e6d;
+                case TorqueUnit.MeganewtonMillimeter: return (Value*0.001) * 1e6d;
+                case TorqueUnit.MegapoundForceFoot: return (Value*1.3558179483314) * 1e6d;
+                case TorqueUnit.MegapoundForceInch: return (Value*1.129848290276167e-1) * 1e6d;
+                case TorqueUnit.NewtonCentimeter: return Value*0.01;
+                case TorqueUnit.NewtonMeter: return Value;
+                case TorqueUnit.NewtonMillimeter: return Value*0.001;
+                case TorqueUnit.PoundalFoot: return Value*4.21401100938048e-2;
+                case TorqueUnit.PoundForceFoot: return Value*1.3558179483314;
+                case TorqueUnit.PoundForceInch: return Value*1.129848290276167e-1;
+                case TorqueUnit.TonneForceCentimeter: return Value*98.0665019960652;
+                case TorqueUnit.TonneForceMeter: return Value*9806.65019960653;
+                case TorqueUnit.TonneForceMillimeter: return Value*9.80665019960652;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -985,16 +975,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Torque ToBaseUnit()
+        internal Torque<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Torque(baseUnitValue, BaseUnit);
+            return new Torque<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(TorqueUnit unit)
+        private T GetValueAs(TorqueUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1118,57 +1108,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Torque)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Torque<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Torque)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Torque<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Torque)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Torque<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1178,33 +1168,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Torque))
+            if(conversionType == typeof(Torque<T>))
                 return this;
             else if(conversionType == typeof(TorqueUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Torque.QuantityType;
+                return Torque<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Torque.Info;
+                return Torque<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Torque.BaseDimensions;
+                return Torque<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Torque)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Torque<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
index 5f86782332..e069ac13e8 100644
--- a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     The magnitude of torque per unit length.
     /// </summary>
-    public partial struct TorquePerLength : IQuantity<TorquePerLengthUnit>, IEquatable<TorquePerLength>, IComparable, IComparable<TorquePerLength>, IConvertible, IFormattable
+    public partial struct TorquePerLength<T> : IQuantityT<TorquePerLengthUnit, T>, IEquatable<TorquePerLength<T>>, IComparable, IComparable<TorquePerLength<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -83,12 +79,12 @@ static TorquePerLength()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public TorquePerLength(double value, TorquePerLengthUnit unit)
+        public TorquePerLength(T value, TorquePerLengthUnit unit)
         {
             if(unit == TorquePerLengthUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -100,14 +96,14 @@ public TorquePerLength(double value, TorquePerLengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public TorquePerLength(double value, UnitSystem unitSystem)
+        public TorquePerLength(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -122,19 +118,19 @@ public TorquePerLength(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of TorquePerLength, which is NewtonMeterPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="TorquePerLength{T}" />, which is NewtonMeterPerMeter. All conversions go via this value.
         /// </summary>
         public static TorquePerLengthUnit BaseUnit { get; } = TorquePerLengthUnit.NewtonMeterPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of TorquePerLength
+        /// Represents the largest possible value of <see cref="TorquePerLength{T}" />
         /// </summary>
-        public static TorquePerLength MaxValue { get; } = new TorquePerLength(double.MaxValue, BaseUnit);
+        public static TorquePerLength<T> MaxValue { get; } = new TorquePerLength<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of TorquePerLength
+        /// Represents the smallest possible value of <see cref="TorquePerLength{T}" />
         /// </summary>
-        public static TorquePerLength MinValue { get; } = new TorquePerLength(double.MinValue, BaseUnit);
+        public static TorquePerLength<T> MinValue { get; } = new TorquePerLength<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -143,14 +139,14 @@ public TorquePerLength(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.TorquePerLength;
 
         /// <summary>
-        ///     All units of measurement for the TorquePerLength quantity.
+        ///     All units of measurement for the <see cref="TorquePerLength{T}" /> quantity.
         /// </summary>
         public static TorquePerLengthUnit[] Units { get; } = Enum.GetValues(typeof(TorquePerLengthUnit)).Cast<TorquePerLengthUnit>().Except(new TorquePerLengthUnit[]{ TorquePerLengthUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NewtonMeterPerMeter.
         /// </summary>
-        public static TorquePerLength Zero { get; } = new TorquePerLength(0, BaseUnit);
+        public static TorquePerLength<T> Zero { get; } = new TorquePerLength<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -159,7 +155,9 @@ public TorquePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -175,121 +173,121 @@ public TorquePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => TorquePerLength.QuantityType;
+        public QuantityType Type => TorquePerLength<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => TorquePerLength.BaseDimensions;
+        public BaseDimensions Dimensions => TorquePerLength<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get TorquePerLength in KilogramForceCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilogramForceCentimetersPerMeter.
         /// </summary>
-        public double KilogramForceCentimetersPerMeter => As(TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
+        public T KilogramForceCentimetersPerMeter => As(TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in KilogramForceMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilogramForceMetersPerMeter.
         /// </summary>
-        public double KilogramForceMetersPerMeter => As(TorquePerLengthUnit.KilogramForceMeterPerMeter);
+        public T KilogramForceMetersPerMeter => As(TorquePerLengthUnit.KilogramForceMeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in KilogramForceMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilogramForceMillimetersPerMeter.
         /// </summary>
-        public double KilogramForceMillimetersPerMeter => As(TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
+        public T KilogramForceMillimetersPerMeter => As(TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in KilonewtonCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilonewtonCentimetersPerMeter.
         /// </summary>
-        public double KilonewtonCentimetersPerMeter => As(TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
+        public T KilonewtonCentimetersPerMeter => As(TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in KilonewtonMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilonewtonMetersPerMeter.
         /// </summary>
-        public double KilonewtonMetersPerMeter => As(TorquePerLengthUnit.KilonewtonMeterPerMeter);
+        public T KilonewtonMetersPerMeter => As(TorquePerLengthUnit.KilonewtonMeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in KilonewtonMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilonewtonMillimetersPerMeter.
         /// </summary>
-        public double KilonewtonMillimetersPerMeter => As(TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
+        public T KilonewtonMillimetersPerMeter => As(TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in KilopoundForceFeetPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilopoundForceFeetPerFoot.
         /// </summary>
-        public double KilopoundForceFeetPerFoot => As(TorquePerLengthUnit.KilopoundForceFootPerFoot);
+        public T KilopoundForceFeetPerFoot => As(TorquePerLengthUnit.KilopoundForceFootPerFoot);
 
         /// <summary>
-        ///     Get TorquePerLength in KilopoundForceInchesPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> in KilopoundForceInchesPerFoot.
         /// </summary>
-        public double KilopoundForceInchesPerFoot => As(TorquePerLengthUnit.KilopoundForceInchPerFoot);
+        public T KilopoundForceInchesPerFoot => As(TorquePerLengthUnit.KilopoundForceInchPerFoot);
 
         /// <summary>
-        ///     Get TorquePerLength in MeganewtonCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in MeganewtonCentimetersPerMeter.
         /// </summary>
-        public double MeganewtonCentimetersPerMeter => As(TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
+        public T MeganewtonCentimetersPerMeter => As(TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in MeganewtonMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in MeganewtonMetersPerMeter.
         /// </summary>
-        public double MeganewtonMetersPerMeter => As(TorquePerLengthUnit.MeganewtonMeterPerMeter);
+        public T MeganewtonMetersPerMeter => As(TorquePerLengthUnit.MeganewtonMeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in MeganewtonMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in MeganewtonMillimetersPerMeter.
         /// </summary>
-        public double MeganewtonMillimetersPerMeter => As(TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
+        public T MeganewtonMillimetersPerMeter => As(TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in MegapoundForceFeetPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> in MegapoundForceFeetPerFoot.
         /// </summary>
-        public double MegapoundForceFeetPerFoot => As(TorquePerLengthUnit.MegapoundForceFootPerFoot);
+        public T MegapoundForceFeetPerFoot => As(TorquePerLengthUnit.MegapoundForceFootPerFoot);
 
         /// <summary>
-        ///     Get TorquePerLength in MegapoundForceInchesPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> in MegapoundForceInchesPerFoot.
         /// </summary>
-        public double MegapoundForceInchesPerFoot => As(TorquePerLengthUnit.MegapoundForceInchPerFoot);
+        public T MegapoundForceInchesPerFoot => As(TorquePerLengthUnit.MegapoundForceInchPerFoot);
 
         /// <summary>
-        ///     Get TorquePerLength in NewtonCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in NewtonCentimetersPerMeter.
         /// </summary>
-        public double NewtonCentimetersPerMeter => As(TorquePerLengthUnit.NewtonCentimeterPerMeter);
+        public T NewtonCentimetersPerMeter => As(TorquePerLengthUnit.NewtonCentimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in NewtonMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in NewtonMetersPerMeter.
         /// </summary>
-        public double NewtonMetersPerMeter => As(TorquePerLengthUnit.NewtonMeterPerMeter);
+        public T NewtonMetersPerMeter => As(TorquePerLengthUnit.NewtonMeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in NewtonMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in NewtonMillimetersPerMeter.
         /// </summary>
-        public double NewtonMillimetersPerMeter => As(TorquePerLengthUnit.NewtonMillimeterPerMeter);
+        public T NewtonMillimetersPerMeter => As(TorquePerLengthUnit.NewtonMillimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in PoundForceFeetPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> in PoundForceFeetPerFoot.
         /// </summary>
-        public double PoundForceFeetPerFoot => As(TorquePerLengthUnit.PoundForceFootPerFoot);
+        public T PoundForceFeetPerFoot => As(TorquePerLengthUnit.PoundForceFootPerFoot);
 
         /// <summary>
-        ///     Get TorquePerLength in PoundForceInchesPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> in PoundForceInchesPerFoot.
         /// </summary>
-        public double PoundForceInchesPerFoot => As(TorquePerLengthUnit.PoundForceInchPerFoot);
+        public T PoundForceInchesPerFoot => As(TorquePerLengthUnit.PoundForceInchPerFoot);
 
         /// <summary>
-        ///     Get TorquePerLength in TonneForceCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in TonneForceCentimetersPerMeter.
         /// </summary>
-        public double TonneForceCentimetersPerMeter => As(TorquePerLengthUnit.TonneForceCentimeterPerMeter);
+        public T TonneForceCentimetersPerMeter => As(TorquePerLengthUnit.TonneForceCentimeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in TonneForceMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in TonneForceMetersPerMeter.
         /// </summary>
-        public double TonneForceMetersPerMeter => As(TorquePerLengthUnit.TonneForceMeterPerMeter);
+        public T TonneForceMetersPerMeter => As(TorquePerLengthUnit.TonneForceMeterPerMeter);
 
         /// <summary>
-        ///     Get TorquePerLength in TonneForceMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> in TonneForceMillimetersPerMeter.
         /// </summary>
-        public double TonneForceMillimetersPerMeter => As(TorquePerLengthUnit.TonneForceMillimeterPerMeter);
+        public T TonneForceMillimetersPerMeter => As(TorquePerLengthUnit.TonneForceMillimeterPerMeter);
 
         #endregion
 
@@ -321,204 +319,183 @@ public static string GetAbbreviation(TorquePerLengthUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get TorquePerLength from KilogramForceCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilogramForceCentimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceCentimetersPerMeter(QuantityValue kilogramforcecentimeterspermeter)
+        public static TorquePerLength<T> FromKilogramForceCentimetersPerMeter(T kilogramforcecentimeterspermeter)
         {
-            double value = (double) kilogramforcecentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
+            return new TorquePerLength<T>(kilogramforcecentimeterspermeter, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from KilogramForceMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilogramForceMetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceMetersPerMeter(QuantityValue kilogramforcemeterspermeter)
+        public static TorquePerLength<T> FromKilogramForceMetersPerMeter(T kilogramforcemeterspermeter)
         {
-            double value = (double) kilogramforcemeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMeterPerMeter);
+            return new TorquePerLength<T>(kilogramforcemeterspermeter, TorquePerLengthUnit.KilogramForceMeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from KilogramForceMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilogramForceMillimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceMillimetersPerMeter(QuantityValue kilogramforcemillimeterspermeter)
+        public static TorquePerLength<T> FromKilogramForceMillimetersPerMeter(T kilogramforcemillimeterspermeter)
         {
-            double value = (double) kilogramforcemillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
+            return new TorquePerLength<T>(kilogramforcemillimeterspermeter, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from KilonewtonCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilonewtonCentimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonCentimetersPerMeter(QuantityValue kilonewtoncentimeterspermeter)
+        public static TorquePerLength<T> FromKilonewtonCentimetersPerMeter(T kilonewtoncentimeterspermeter)
         {
-            double value = (double) kilonewtoncentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
+            return new TorquePerLength<T>(kilonewtoncentimeterspermeter, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from KilonewtonMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilonewtonMetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonMetersPerMeter(QuantityValue kilonewtonmeterspermeter)
+        public static TorquePerLength<T> FromKilonewtonMetersPerMeter(T kilonewtonmeterspermeter)
         {
-            double value = (double) kilonewtonmeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMeterPerMeter);
+            return new TorquePerLength<T>(kilonewtonmeterspermeter, TorquePerLengthUnit.KilonewtonMeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from KilonewtonMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilonewtonMillimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonMillimetersPerMeter(QuantityValue kilonewtonmillimeterspermeter)
+        public static TorquePerLength<T> FromKilonewtonMillimetersPerMeter(T kilonewtonmillimeterspermeter)
         {
-            double value = (double) kilonewtonmillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
+            return new TorquePerLength<T>(kilonewtonmillimeterspermeter, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from KilopoundForceFeetPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilopoundForceFeetPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilopoundForceFeetPerFoot(QuantityValue kilopoundforcefeetperfoot)
+        public static TorquePerLength<T> FromKilopoundForceFeetPerFoot(T kilopoundforcefeetperfoot)
         {
-            double value = (double) kilopoundforcefeetperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceFootPerFoot);
+            return new TorquePerLength<T>(kilopoundforcefeetperfoot, TorquePerLengthUnit.KilopoundForceFootPerFoot);
         }
         /// <summary>
-        ///     Get TorquePerLength from KilopoundForceInchesPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> from KilopoundForceInchesPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilopoundForceInchesPerFoot(QuantityValue kilopoundforceinchesperfoot)
+        public static TorquePerLength<T> FromKilopoundForceInchesPerFoot(T kilopoundforceinchesperfoot)
         {
-            double value = (double) kilopoundforceinchesperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceInchPerFoot);
+            return new TorquePerLength<T>(kilopoundforceinchesperfoot, TorquePerLengthUnit.KilopoundForceInchPerFoot);
         }
         /// <summary>
-        ///     Get TorquePerLength from MeganewtonCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from MeganewtonCentimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonCentimetersPerMeter(QuantityValue meganewtoncentimeterspermeter)
+        public static TorquePerLength<T> FromMeganewtonCentimetersPerMeter(T meganewtoncentimeterspermeter)
         {
-            double value = (double) meganewtoncentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
+            return new TorquePerLength<T>(meganewtoncentimeterspermeter, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from MeganewtonMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from MeganewtonMetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonMetersPerMeter(QuantityValue meganewtonmeterspermeter)
+        public static TorquePerLength<T> FromMeganewtonMetersPerMeter(T meganewtonmeterspermeter)
         {
-            double value = (double) meganewtonmeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMeterPerMeter);
+            return new TorquePerLength<T>(meganewtonmeterspermeter, TorquePerLengthUnit.MeganewtonMeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from MeganewtonMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from MeganewtonMillimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonMillimetersPerMeter(QuantityValue meganewtonmillimeterspermeter)
+        public static TorquePerLength<T> FromMeganewtonMillimetersPerMeter(T meganewtonmillimeterspermeter)
         {
-            double value = (double) meganewtonmillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
+            return new TorquePerLength<T>(meganewtonmillimeterspermeter, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from MegapoundForceFeetPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> from MegapoundForceFeetPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMegapoundForceFeetPerFoot(QuantityValue megapoundforcefeetperfoot)
+        public static TorquePerLength<T> FromMegapoundForceFeetPerFoot(T megapoundforcefeetperfoot)
         {
-            double value = (double) megapoundforcefeetperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceFootPerFoot);
+            return new TorquePerLength<T>(megapoundforcefeetperfoot, TorquePerLengthUnit.MegapoundForceFootPerFoot);
         }
         /// <summary>
-        ///     Get TorquePerLength from MegapoundForceInchesPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> from MegapoundForceInchesPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMegapoundForceInchesPerFoot(QuantityValue megapoundforceinchesperfoot)
+        public static TorquePerLength<T> FromMegapoundForceInchesPerFoot(T megapoundforceinchesperfoot)
         {
-            double value = (double) megapoundforceinchesperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceInchPerFoot);
+            return new TorquePerLength<T>(megapoundforceinchesperfoot, TorquePerLengthUnit.MegapoundForceInchPerFoot);
         }
         /// <summary>
-        ///     Get TorquePerLength from NewtonCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from NewtonCentimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonCentimetersPerMeter(QuantityValue newtoncentimeterspermeter)
+        public static TorquePerLength<T> FromNewtonCentimetersPerMeter(T newtoncentimeterspermeter)
         {
-            double value = (double) newtoncentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.NewtonCentimeterPerMeter);
+            return new TorquePerLength<T>(newtoncentimeterspermeter, TorquePerLengthUnit.NewtonCentimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from NewtonMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from NewtonMetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonMetersPerMeter(QuantityValue newtonmeterspermeter)
+        public static TorquePerLength<T> FromNewtonMetersPerMeter(T newtonmeterspermeter)
         {
-            double value = (double) newtonmeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.NewtonMeterPerMeter);
+            return new TorquePerLength<T>(newtonmeterspermeter, TorquePerLengthUnit.NewtonMeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from NewtonMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from NewtonMillimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonMillimetersPerMeter(QuantityValue newtonmillimeterspermeter)
+        public static TorquePerLength<T> FromNewtonMillimetersPerMeter(T newtonmillimeterspermeter)
         {
-            double value = (double) newtonmillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.NewtonMillimeterPerMeter);
+            return new TorquePerLength<T>(newtonmillimeterspermeter, TorquePerLengthUnit.NewtonMillimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from PoundForceFeetPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> from PoundForceFeetPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromPoundForceFeetPerFoot(QuantityValue poundforcefeetperfoot)
+        public static TorquePerLength<T> FromPoundForceFeetPerFoot(T poundforcefeetperfoot)
         {
-            double value = (double) poundforcefeetperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.PoundForceFootPerFoot);
+            return new TorquePerLength<T>(poundforcefeetperfoot, TorquePerLengthUnit.PoundForceFootPerFoot);
         }
         /// <summary>
-        ///     Get TorquePerLength from PoundForceInchesPerFoot.
+        ///     Get <see cref="TorquePerLength{T}" /> from PoundForceInchesPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromPoundForceInchesPerFoot(QuantityValue poundforceinchesperfoot)
+        public static TorquePerLength<T> FromPoundForceInchesPerFoot(T poundforceinchesperfoot)
         {
-            double value = (double) poundforceinchesperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.PoundForceInchPerFoot);
+            return new TorquePerLength<T>(poundforceinchesperfoot, TorquePerLengthUnit.PoundForceInchPerFoot);
         }
         /// <summary>
-        ///     Get TorquePerLength from TonneForceCentimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from TonneForceCentimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceCentimetersPerMeter(QuantityValue tonneforcecentimeterspermeter)
+        public static TorquePerLength<T> FromTonneForceCentimetersPerMeter(T tonneforcecentimeterspermeter)
         {
-            double value = (double) tonneforcecentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
+            return new TorquePerLength<T>(tonneforcecentimeterspermeter, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from TonneForceMetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from TonneForceMetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceMetersPerMeter(QuantityValue tonneforcemeterspermeter)
+        public static TorquePerLength<T> FromTonneForceMetersPerMeter(T tonneforcemeterspermeter)
         {
-            double value = (double) tonneforcemeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMeterPerMeter);
+            return new TorquePerLength<T>(tonneforcemeterspermeter, TorquePerLengthUnit.TonneForceMeterPerMeter);
         }
         /// <summary>
-        ///     Get TorquePerLength from TonneForceMillimetersPerMeter.
+        ///     Get <see cref="TorquePerLength{T}" /> from TonneForceMillimetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceMillimetersPerMeter(QuantityValue tonneforcemillimeterspermeter)
+        public static TorquePerLength<T> FromTonneForceMillimetersPerMeter(T tonneforcemillimeterspermeter)
         {
-            double value = (double) tonneforcemillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
+            return new TorquePerLength<T>(tonneforcemillimeterspermeter, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TorquePerLengthUnit" /> to <see cref="TorquePerLength" />.
+        ///     Dynamically convert from value and unit enum <see cref="TorquePerLengthUnit" /> to <see cref="TorquePerLength{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>TorquePerLength unit value.</returns>
-        public static TorquePerLength From(QuantityValue value, TorquePerLengthUnit fromUnit)
+        /// <returns><see cref="TorquePerLength{T}" /> unit value.</returns>
+        public static TorquePerLength<T> From(T value, TorquePerLengthUnit fromUnit)
         {
-            return new TorquePerLength((double)value, fromUnit);
+            return new TorquePerLength<T>(value, fromUnit);
         }
 
         #endregion
@@ -547,7 +524,7 @@ public static TorquePerLength From(QuantityValue value, TorquePerLengthUnit from
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static TorquePerLength Parse(string str)
+        public static TorquePerLength<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -575,9 +552,9 @@ public static TorquePerLength Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static TorquePerLength Parse(string str, IFormatProvider? provider)
+        public static TorquePerLength<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<TorquePerLength, TorquePerLengthUnit>(
+            return QuantityParser.Default.Parse<T, TorquePerLength<T>, TorquePerLengthUnit>(
                 str,
                 provider,
                 From);
@@ -591,7 +568,7 @@ public static TorquePerLength Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out TorquePerLength result)
+        public static bool TryParse(string? str, out TorquePerLength<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -606,9 +583,9 @@ public static bool TryParse(string? str, out TorquePerLength result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out TorquePerLength result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out TorquePerLength<T> result)
         {
-            return QuantityParser.Default.TryParse<TorquePerLength, TorquePerLengthUnit>(
+            return QuantityParser.Default.TryParse<T, TorquePerLength<T>, TorquePerLengthUnit>(
                 str,
                 provider,
                 From,
@@ -670,45 +647,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Torqu
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static TorquePerLength operator -(TorquePerLength right)
+        public static TorquePerLength<T> operator -(TorquePerLength<T> right)
         {
-            return new TorquePerLength(-right.Value, right.Unit);
+            return new TorquePerLength<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="TorquePerLength"/> from adding two <see cref="TorquePerLength"/>.</summary>
-        public static TorquePerLength operator +(TorquePerLength left, TorquePerLength right)
+        /// <summary>Get <see cref="TorquePerLength{T}"/> from adding two <see cref="TorquePerLength{T}"/>.</summary>
+        public static TorquePerLength<T> operator +(TorquePerLength<T> left, TorquePerLength<T> right)
         {
-            return new TorquePerLength(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new TorquePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TorquePerLength"/> from subtracting two <see cref="TorquePerLength"/>.</summary>
-        public static TorquePerLength operator -(TorquePerLength left, TorquePerLength right)
+        /// <summary>Get <see cref="TorquePerLength{T}"/> from subtracting two <see cref="TorquePerLength{T}"/>.</summary>
+        public static TorquePerLength<T> operator -(TorquePerLength<T> left, TorquePerLength<T> right)
         {
-            return new TorquePerLength(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new TorquePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TorquePerLength"/> from multiplying value and <see cref="TorquePerLength"/>.</summary>
-        public static TorquePerLength operator *(double left, TorquePerLength right)
+        /// <summary>Get <see cref="TorquePerLength{T}"/> from multiplying value and <see cref="TorquePerLength{T}"/>.</summary>
+        public static TorquePerLength<T> operator *(T left, TorquePerLength<T> right)
         {
-            return new TorquePerLength(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new TorquePerLength<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="TorquePerLength"/> from multiplying value and <see cref="TorquePerLength"/>.</summary>
-        public static TorquePerLength operator *(TorquePerLength left, double right)
+        /// <summary>Get <see cref="TorquePerLength{T}"/> from multiplying value and <see cref="TorquePerLength{T}"/>.</summary>
+        public static TorquePerLength<T> operator *(TorquePerLength<T> left, T right)
         {
-            return new TorquePerLength(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new TorquePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="TorquePerLength"/> from dividing <see cref="TorquePerLength"/> by value.</summary>
-        public static TorquePerLength operator /(TorquePerLength left, double right)
+        /// <summary>Get <see cref="TorquePerLength{T}"/> from dividing <see cref="TorquePerLength{T}"/> by value.</summary>
+        public static TorquePerLength<T> operator /(TorquePerLength<T> left, T right)
         {
-            return new TorquePerLength(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new TorquePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="TorquePerLength"/> by <see cref="TorquePerLength"/>.</summary>
-        public static double operator /(TorquePerLength left, TorquePerLength right)
+        /// <summary>Get ratio value from dividing <see cref="TorquePerLength{T}"/> by <see cref="TorquePerLength{T}"/>.</summary>
+        public static T operator /(TorquePerLength<T> left, TorquePerLength<T> right)
         {
-            return left.NewtonMetersPerMeter / right.NewtonMetersPerMeter;
+            return CompiledLambdas.Divide(left.NewtonMetersPerMeter, right.NewtonMetersPerMeter);
         }
 
         #endregion
@@ -716,39 +698,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Torqu
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(TorquePerLength left, TorquePerLength right)
+        public static bool operator <=(TorquePerLength<T> left, TorquePerLength<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(TorquePerLength left, TorquePerLength right)
+        public static bool operator >=(TorquePerLength<T> left, TorquePerLength<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(TorquePerLength left, TorquePerLength right)
+        public static bool operator <(TorquePerLength<T> left, TorquePerLength<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(TorquePerLength left, TorquePerLength right)
+        public static bool operator >(TorquePerLength<T> left, TorquePerLength<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(TorquePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(TorquePerLength left, TorquePerLength right)
+        /// <remarks>Consider using <see cref="Equals(TorquePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(TorquePerLength<T> left, TorquePerLength<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(TorquePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(TorquePerLength left, TorquePerLength right)
+        /// <remarks>Consider using <see cref="Equals(TorquePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(TorquePerLength<T> left, TorquePerLength<T> right)
         {
             return !(left == right);
         }
@@ -757,37 +739,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Torqu
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is TorquePerLength objTorquePerLength)) throw new ArgumentException("Expected type TorquePerLength.", nameof(obj));
+            if(!(obj is TorquePerLength<T> objTorquePerLength)) throw new ArgumentException("Expected type TorquePerLength.", nameof(obj));
 
             return CompareTo(objTorquePerLength);
         }
 
         /// <inheritdoc />
-        public int CompareTo(TorquePerLength other)
+        public int CompareTo(TorquePerLength<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(TorquePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(TorquePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is TorquePerLength objTorquePerLength))
+            if(obj is null || !(obj is TorquePerLength<T> objTorquePerLength))
                 return false;
 
             return Equals(objTorquePerLength);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(TorquePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(TorquePerLength other)
+        /// <remarks>Consider using <see cref="Equals(TorquePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(TorquePerLength<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another TorquePerLength within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="TorquePerLength{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -825,21 +807,19 @@ public bool Equals(TorquePerLength other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(TorquePerLength other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(TorquePerLength<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current TorquePerLength.</returns>
+        /// <returns>A hash code for the current <see cref="TorquePerLength{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -853,17 +833,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(TorquePerLengthUnit unit)
+        public T As(TorquePerLengthUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -883,17 +863,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is TorquePerLengthUnit unitAsTorquePerLengthUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorquePerLengthUnit)} is supported.", nameof(unit));
 
-            return As(unitAsTorquePerLengthUnit);
+            var asValue = As(unitAsTorquePerLengthUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<TorquePerLengthUnit>.As(TorquePerLengthUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this TorquePerLength to another TorquePerLength with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="TorquePerLength{T}" /> to another <see cref="TorquePerLength{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A TorquePerLength with the specified unit.</returns>
-        public TorquePerLength ToUnit(TorquePerLengthUnit unit)
+        /// <returns>A <see cref="TorquePerLength{T}" /> with the specified unit.</returns>
+        public TorquePerLength<T> ToUnit(TorquePerLengthUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new TorquePerLength(convertedValue, unit);
+            return new TorquePerLength<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -906,7 +891,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public TorquePerLength ToUnit(UnitSystem unitSystem)
+        public TorquePerLength<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -926,39 +911,45 @@ public TorquePerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TorquePerLengthUnit> IQuantity<TorquePerLengthUnit>.ToUnit(TorquePerLengthUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<TorquePerLengthUnit, T> IQuantityT<TorquePerLengthUnit, T>.ToUnit(TorquePerLengthUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<TorquePerLengthUnit> IQuantity<TorquePerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<TorquePerLengthUnit, T> IQuantityT<TorquePerLengthUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case TorquePerLengthUnit.KilogramForceCentimeterPerMeter: return _value*0.0980665019960652;
-                case TorquePerLengthUnit.KilogramForceMeterPerMeter: return _value*9.80665019960652;
-                case TorquePerLengthUnit.KilogramForceMillimeterPerMeter: return _value*0.00980665019960652;
-                case TorquePerLengthUnit.KilonewtonCentimeterPerMeter: return (_value*0.01) * 1e3d;
-                case TorquePerLengthUnit.KilonewtonMeterPerMeter: return (_value) * 1e3d;
-                case TorquePerLengthUnit.KilonewtonMillimeterPerMeter: return (_value*0.001) * 1e3d;
-                case TorquePerLengthUnit.KilopoundForceFootPerFoot: return (_value*4.44822161526) * 1e3d;
-                case TorquePerLengthUnit.KilopoundForceInchPerFoot: return (_value*0.370685147638) * 1e3d;
-                case TorquePerLengthUnit.MeganewtonCentimeterPerMeter: return (_value*0.01) * 1e6d;
-                case TorquePerLengthUnit.MeganewtonMeterPerMeter: return (_value) * 1e6d;
-                case TorquePerLengthUnit.MeganewtonMillimeterPerMeter: return (_value*0.001) * 1e6d;
-                case TorquePerLengthUnit.MegapoundForceFootPerFoot: return (_value*4.44822161526) * 1e6d;
-                case TorquePerLengthUnit.MegapoundForceInchPerFoot: return (_value*0.370685147638) * 1e6d;
-                case TorquePerLengthUnit.NewtonCentimeterPerMeter: return _value*0.01;
-                case TorquePerLengthUnit.NewtonMeterPerMeter: return _value;
-                case TorquePerLengthUnit.NewtonMillimeterPerMeter: return _value*0.001;
-                case TorquePerLengthUnit.PoundForceFootPerFoot: return _value*4.44822161526;
-                case TorquePerLengthUnit.PoundForceInchPerFoot: return _value*0.370685147638;
-                case TorquePerLengthUnit.TonneForceCentimeterPerMeter: return _value*98.0665019960652;
-                case TorquePerLengthUnit.TonneForceMeterPerMeter: return _value*9806.65019960653;
-                case TorquePerLengthUnit.TonneForceMillimeterPerMeter: return _value*9.80665019960652;
+                case TorquePerLengthUnit.KilogramForceCentimeterPerMeter: return Value*0.0980665019960652;
+                case TorquePerLengthUnit.KilogramForceMeterPerMeter: return Value*9.80665019960652;
+                case TorquePerLengthUnit.KilogramForceMillimeterPerMeter: return Value*0.00980665019960652;
+                case TorquePerLengthUnit.KilonewtonCentimeterPerMeter: return (Value*0.01) * 1e3d;
+                case TorquePerLengthUnit.KilonewtonMeterPerMeter: return (Value) * 1e3d;
+                case TorquePerLengthUnit.KilonewtonMillimeterPerMeter: return (Value*0.001) * 1e3d;
+                case TorquePerLengthUnit.KilopoundForceFootPerFoot: return (Value*4.44822161526) * 1e3d;
+                case TorquePerLengthUnit.KilopoundForceInchPerFoot: return (Value*0.370685147638) * 1e3d;
+                case TorquePerLengthUnit.MeganewtonCentimeterPerMeter: return (Value*0.01) * 1e6d;
+                case TorquePerLengthUnit.MeganewtonMeterPerMeter: return (Value) * 1e6d;
+                case TorquePerLengthUnit.MeganewtonMillimeterPerMeter: return (Value*0.001) * 1e6d;
+                case TorquePerLengthUnit.MegapoundForceFootPerFoot: return (Value*4.44822161526) * 1e6d;
+                case TorquePerLengthUnit.MegapoundForceInchPerFoot: return (Value*0.370685147638) * 1e6d;
+                case TorquePerLengthUnit.NewtonCentimeterPerMeter: return Value*0.01;
+                case TorquePerLengthUnit.NewtonMeterPerMeter: return Value;
+                case TorquePerLengthUnit.NewtonMillimeterPerMeter: return Value*0.001;
+                case TorquePerLengthUnit.PoundForceFootPerFoot: return Value*4.44822161526;
+                case TorquePerLengthUnit.PoundForceInchPerFoot: return Value*0.370685147638;
+                case TorquePerLengthUnit.TonneForceCentimeterPerMeter: return Value*98.0665019960652;
+                case TorquePerLengthUnit.TonneForceMeterPerMeter: return Value*9806.65019960653;
+                case TorquePerLengthUnit.TonneForceMillimeterPerMeter: return Value*9.80665019960652;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -969,16 +960,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal TorquePerLength ToBaseUnit()
+        internal TorquePerLength<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new TorquePerLength(baseUnitValue, BaseUnit);
+            return new TorquePerLength<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(TorquePerLengthUnit unit)
+        private T GetValueAs(TorquePerLengthUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1101,57 +1092,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TorquePerLength)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TorquePerLength<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TorquePerLength)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TorquePerLength<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(TorquePerLength)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(TorquePerLength<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1161,33 +1152,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(TorquePerLength))
+            if(conversionType == typeof(TorquePerLength<T>))
                 return this;
             else if(conversionType == typeof(TorquePerLengthUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return TorquePerLength.QuantityType;
+                return TorquePerLength<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return TorquePerLength.Info;
+                return TorquePerLength<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return TorquePerLength.BaseDimensions;
+                return TorquePerLength<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(TorquePerLength)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(TorquePerLength<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
index 880162dbfb..d86c85db69 100644
--- a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Turbidity
     /// </remarks>
-    public partial struct Turbidity : IQuantity<TurbidityUnit>, IEquatable<Turbidity>, IComparable, IComparable<Turbidity>, IConvertible, IFormattable
+    public partial struct Turbidity<T> : IQuantityT<TurbidityUnit, T>, IEquatable<Turbidity<T>>, IComparable, IComparable<Turbidity<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -66,12 +62,12 @@ static Turbidity()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Turbidity(double value, TurbidityUnit unit)
+        public Turbidity(T value, TurbidityUnit unit)
         {
             if(unit == TurbidityUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -83,14 +79,14 @@ public Turbidity(double value, TurbidityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Turbidity(double value, UnitSystem unitSystem)
+        public Turbidity(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -105,19 +101,19 @@ public Turbidity(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Turbidity, which is NTU. All conversions go via this value.
+        ///     The base unit of <see cref="Turbidity{T}" />, which is NTU. All conversions go via this value.
         /// </summary>
         public static TurbidityUnit BaseUnit { get; } = TurbidityUnit.NTU;
 
         /// <summary>
-        /// Represents the largest possible value of Turbidity
+        /// Represents the largest possible value of <see cref="Turbidity{T}" />
         /// </summary>
-        public static Turbidity MaxValue { get; } = new Turbidity(double.MaxValue, BaseUnit);
+        public static Turbidity<T> MaxValue { get; } = new Turbidity<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Turbidity
+        /// Represents the smallest possible value of <see cref="Turbidity{T}" />
         /// </summary>
-        public static Turbidity MinValue { get; } = new Turbidity(double.MinValue, BaseUnit);
+        public static Turbidity<T> MinValue { get; } = new Turbidity<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -126,14 +122,14 @@ public Turbidity(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Turbidity;
 
         /// <summary>
-        ///     All units of measurement for the Turbidity quantity.
+        ///     All units of measurement for the <see cref="Turbidity{T}" /> quantity.
         /// </summary>
         public static TurbidityUnit[] Units { get; } = Enum.GetValues(typeof(TurbidityUnit)).Cast<TurbidityUnit>().Except(new TurbidityUnit[]{ TurbidityUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit NTU.
         /// </summary>
-        public static Turbidity Zero { get; } = new Turbidity(0, BaseUnit);
+        public static Turbidity<T> Zero { get; } = new Turbidity<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -142,7 +138,9 @@ public Turbidity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -158,21 +156,21 @@ public Turbidity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Turbidity.QuantityType;
+        public QuantityType Type => Turbidity<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Turbidity.BaseDimensions;
+        public BaseDimensions Dimensions => Turbidity<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Turbidity in NTU.
+        ///     Get <see cref="Turbidity{T}" /> in NTU.
         /// </summary>
-        public double NTU => As(TurbidityUnit.NTU);
+        public T NTU => As(TurbidityUnit.NTU);
 
         #endregion
 
@@ -204,24 +202,23 @@ public static string GetAbbreviation(TurbidityUnit unit, IFormatProvider? provid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Turbidity from NTU.
+        ///     Get <see cref="Turbidity{T}" /> from NTU.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Turbidity FromNTU(QuantityValue ntu)
+        public static Turbidity<T> FromNTU(T ntu)
         {
-            double value = (double) ntu;
-            return new Turbidity(value, TurbidityUnit.NTU);
+            return new Turbidity<T>(ntu, TurbidityUnit.NTU);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TurbidityUnit" /> to <see cref="Turbidity" />.
+        ///     Dynamically convert from value and unit enum <see cref="TurbidityUnit" /> to <see cref="Turbidity{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Turbidity unit value.</returns>
-        public static Turbidity From(QuantityValue value, TurbidityUnit fromUnit)
+        /// <returns><see cref="Turbidity{T}" /> unit value.</returns>
+        public static Turbidity<T> From(T value, TurbidityUnit fromUnit)
         {
-            return new Turbidity((double)value, fromUnit);
+            return new Turbidity<T>(value, fromUnit);
         }
 
         #endregion
@@ -250,7 +247,7 @@ public static Turbidity From(QuantityValue value, TurbidityUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Turbidity Parse(string str)
+        public static Turbidity<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -278,9 +275,9 @@ public static Turbidity Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Turbidity Parse(string str, IFormatProvider? provider)
+        public static Turbidity<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Turbidity, TurbidityUnit>(
+            return QuantityParser.Default.Parse<T, Turbidity<T>, TurbidityUnit>(
                 str,
                 provider,
                 From);
@@ -294,7 +291,7 @@ public static Turbidity Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Turbidity result)
+        public static bool TryParse(string? str, out Turbidity<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -309,9 +306,9 @@ public static bool TryParse(string? str, out Turbidity result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Turbidity result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Turbidity<T> result)
         {
-            return QuantityParser.Default.TryParse<Turbidity, TurbidityUnit>(
+            return QuantityParser.Default.TryParse<T, Turbidity<T>, TurbidityUnit>(
                 str,
                 provider,
                 From,
@@ -373,45 +370,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Turbi
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Turbidity operator -(Turbidity right)
+        public static Turbidity<T> operator -(Turbidity<T> right)
         {
-            return new Turbidity(-right.Value, right.Unit);
+            return new Turbidity<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Turbidity"/> from adding two <see cref="Turbidity"/>.</summary>
-        public static Turbidity operator +(Turbidity left, Turbidity right)
+        /// <summary>Get <see cref="Turbidity{T}"/> from adding two <see cref="Turbidity{T}"/>.</summary>
+        public static Turbidity<T> operator +(Turbidity<T> left, Turbidity<T> right)
         {
-            return new Turbidity(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Turbidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Turbidity"/> from subtracting two <see cref="Turbidity"/>.</summary>
-        public static Turbidity operator -(Turbidity left, Turbidity right)
+        /// <summary>Get <see cref="Turbidity{T}"/> from subtracting two <see cref="Turbidity{T}"/>.</summary>
+        public static Turbidity<T> operator -(Turbidity<T> left, Turbidity<T> right)
         {
-            return new Turbidity(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Turbidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Turbidity"/> from multiplying value and <see cref="Turbidity"/>.</summary>
-        public static Turbidity operator *(double left, Turbidity right)
+        /// <summary>Get <see cref="Turbidity{T}"/> from multiplying value and <see cref="Turbidity{T}"/>.</summary>
+        public static Turbidity<T> operator *(T left, Turbidity<T> right)
         {
-            return new Turbidity(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Turbidity<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Turbidity"/> from multiplying value and <see cref="Turbidity"/>.</summary>
-        public static Turbidity operator *(Turbidity left, double right)
+        /// <summary>Get <see cref="Turbidity{T}"/> from multiplying value and <see cref="Turbidity{T}"/>.</summary>
+        public static Turbidity<T> operator *(Turbidity<T> left, T right)
         {
-            return new Turbidity(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Turbidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Turbidity"/> from dividing <see cref="Turbidity"/> by value.</summary>
-        public static Turbidity operator /(Turbidity left, double right)
+        /// <summary>Get <see cref="Turbidity{T}"/> from dividing <see cref="Turbidity{T}"/> by value.</summary>
+        public static Turbidity<T> operator /(Turbidity<T> left, T right)
         {
-            return new Turbidity(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Turbidity<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Turbidity"/> by <see cref="Turbidity"/>.</summary>
-        public static double operator /(Turbidity left, Turbidity right)
+        /// <summary>Get ratio value from dividing <see cref="Turbidity{T}"/> by <see cref="Turbidity{T}"/>.</summary>
+        public static T operator /(Turbidity<T> left, Turbidity<T> right)
         {
-            return left.NTU / right.NTU;
+            return CompiledLambdas.Divide(left.NTU, right.NTU);
         }
 
         #endregion
@@ -419,39 +421,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Turbi
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Turbidity left, Turbidity right)
+        public static bool operator <=(Turbidity<T> left, Turbidity<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Turbidity left, Turbidity right)
+        public static bool operator >=(Turbidity<T> left, Turbidity<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Turbidity left, Turbidity right)
+        public static bool operator <(Turbidity<T> left, Turbidity<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Turbidity left, Turbidity right)
+        public static bool operator >(Turbidity<T> left, Turbidity<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Turbidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Turbidity left, Turbidity right)
+        /// <remarks>Consider using <see cref="Equals(Turbidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Turbidity<T> left, Turbidity<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Turbidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Turbidity left, Turbidity right)
+        /// <remarks>Consider using <see cref="Equals(Turbidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Turbidity<T> left, Turbidity<T> right)
         {
             return !(left == right);
         }
@@ -460,37 +462,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Turbi
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Turbidity objTurbidity)) throw new ArgumentException("Expected type Turbidity.", nameof(obj));
+            if(!(obj is Turbidity<T> objTurbidity)) throw new ArgumentException("Expected type Turbidity.", nameof(obj));
 
             return CompareTo(objTurbidity);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Turbidity other)
+        public int CompareTo(Turbidity<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Turbidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Turbidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Turbidity objTurbidity))
+            if(obj is null || !(obj is Turbidity<T> objTurbidity))
                 return false;
 
             return Equals(objTurbidity);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Turbidity, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Turbidity other)
+        /// <remarks>Consider using <see cref="Equals(Turbidity{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Turbidity<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Turbidity within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Turbidity{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -528,21 +530,19 @@ public bool Equals(Turbidity other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Turbidity other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Turbidity<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Turbidity.</returns>
+        /// <returns>A hash code for the current <see cref="Turbidity{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -556,17 +556,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(TurbidityUnit unit)
+        public T As(TurbidityUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -586,17 +586,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is TurbidityUnit unitAsTurbidityUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TurbidityUnit)} is supported.", nameof(unit));
 
-            return As(unitAsTurbidityUnit);
+            var asValue = As(unitAsTurbidityUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<TurbidityUnit>.As(TurbidityUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Turbidity to another Turbidity with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Turbidity{T}" /> to another <see cref="Turbidity{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Turbidity with the specified unit.</returns>
-        public Turbidity ToUnit(TurbidityUnit unit)
+        /// <returns>A <see cref="Turbidity{T}" /> with the specified unit.</returns>
+        public Turbidity<T> ToUnit(TurbidityUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Turbidity(convertedValue, unit);
+            return new Turbidity<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -609,7 +614,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Turbidity ToUnit(UnitSystem unitSystem)
+        public Turbidity<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -629,19 +634,25 @@ public Turbidity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TurbidityUnit> IQuantity<TurbidityUnit>.ToUnit(TurbidityUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<TurbidityUnit, T> IQuantityT<TurbidityUnit, T>.ToUnit(TurbidityUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<TurbidityUnit> IQuantity<TurbidityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<TurbidityUnit, T> IQuantityT<TurbidityUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case TurbidityUnit.NTU: return _value;
+                case TurbidityUnit.NTU: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -652,16 +663,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Turbidity ToBaseUnit()
+        internal Turbidity<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Turbidity(baseUnitValue, BaseUnit);
+            return new Turbidity<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(TurbidityUnit unit)
+        private T GetValueAs(TurbidityUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -764,57 +775,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Turbidity)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Turbidity<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Turbidity)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Turbidity<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Turbidity)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Turbidity<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -824,33 +835,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Turbidity))
+            if(conversionType == typeof(Turbidity<T>))
                 return this;
             else if(conversionType == typeof(TurbidityUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Turbidity.QuantityType;
+                return Turbidity<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Turbidity.Info;
+                return Turbidity<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Turbidity.BaseDimensions;
+                return Turbidity<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Turbidity)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Turbidity<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
index 38fc44918a..9b8e24d595 100644
--- a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Vitamin A: 1 IU is the biological equivalent of 0.3 µg retinol, or of 0.6 µg beta-carotene.
     /// </summary>
-    public partial struct VitaminA : IQuantity<VitaminAUnit>, IEquatable<VitaminA>, IComparable, IComparable<VitaminA>, IConvertible, IFormattable
+    public partial struct VitaminA<T> : IQuantityT<VitaminAUnit, T>, IEquatable<VitaminA<T>>, IComparable, IComparable<VitaminA<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -63,12 +59,12 @@ static VitaminA()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public VitaminA(double value, VitaminAUnit unit)
+        public VitaminA(T value, VitaminAUnit unit)
         {
             if(unit == VitaminAUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -80,14 +76,14 @@ public VitaminA(double value, VitaminAUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VitaminA(double value, UnitSystem unitSystem)
+        public VitaminA(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -102,19 +98,19 @@ public VitaminA(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of VitaminA, which is InternationalUnit. All conversions go via this value.
+        ///     The base unit of <see cref="VitaminA{T}" />, which is InternationalUnit. All conversions go via this value.
         /// </summary>
         public static VitaminAUnit BaseUnit { get; } = VitaminAUnit.InternationalUnit;
 
         /// <summary>
-        /// Represents the largest possible value of VitaminA
+        /// Represents the largest possible value of <see cref="VitaminA{T}" />
         /// </summary>
-        public static VitaminA MaxValue { get; } = new VitaminA(double.MaxValue, BaseUnit);
+        public static VitaminA<T> MaxValue { get; } = new VitaminA<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of VitaminA
+        /// Represents the smallest possible value of <see cref="VitaminA{T}" />
         /// </summary>
-        public static VitaminA MinValue { get; } = new VitaminA(double.MinValue, BaseUnit);
+        public static VitaminA<T> MinValue { get; } = new VitaminA<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -123,14 +119,14 @@ public VitaminA(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.VitaminA;
 
         /// <summary>
-        ///     All units of measurement for the VitaminA quantity.
+        ///     All units of measurement for the <see cref="VitaminA{T}" /> quantity.
         /// </summary>
         public static VitaminAUnit[] Units { get; } = Enum.GetValues(typeof(VitaminAUnit)).Cast<VitaminAUnit>().Except(new VitaminAUnit[]{ VitaminAUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit InternationalUnit.
         /// </summary>
-        public static VitaminA Zero { get; } = new VitaminA(0, BaseUnit);
+        public static VitaminA<T> Zero { get; } = new VitaminA<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -139,7 +135,9 @@ public VitaminA(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -155,21 +153,21 @@ public VitaminA(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => VitaminA.QuantityType;
+        public QuantityType Type => VitaminA<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => VitaminA.BaseDimensions;
+        public BaseDimensions Dimensions => VitaminA<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get VitaminA in InternationalUnits.
+        ///     Get <see cref="VitaminA{T}" /> in InternationalUnits.
         /// </summary>
-        public double InternationalUnits => As(VitaminAUnit.InternationalUnit);
+        public T InternationalUnits => As(VitaminAUnit.InternationalUnit);
 
         #endregion
 
@@ -201,24 +199,23 @@ public static string GetAbbreviation(VitaminAUnit unit, IFormatProvider? provide
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get VitaminA from InternationalUnits.
+        ///     Get <see cref="VitaminA{T}" /> from InternationalUnits.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VitaminA FromInternationalUnits(QuantityValue internationalunits)
+        public static VitaminA<T> FromInternationalUnits(T internationalunits)
         {
-            double value = (double) internationalunits;
-            return new VitaminA(value, VitaminAUnit.InternationalUnit);
+            return new VitaminA<T>(internationalunits, VitaminAUnit.InternationalUnit);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VitaminAUnit" /> to <see cref="VitaminA" />.
+        ///     Dynamically convert from value and unit enum <see cref="VitaminAUnit" /> to <see cref="VitaminA{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VitaminA unit value.</returns>
-        public static VitaminA From(QuantityValue value, VitaminAUnit fromUnit)
+        /// <returns><see cref="VitaminA{T}" /> unit value.</returns>
+        public static VitaminA<T> From(T value, VitaminAUnit fromUnit)
         {
-            return new VitaminA((double)value, fromUnit);
+            return new VitaminA<T>(value, fromUnit);
         }
 
         #endregion
@@ -247,7 +244,7 @@ public static VitaminA From(QuantityValue value, VitaminAUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static VitaminA Parse(string str)
+        public static VitaminA<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -275,9 +272,9 @@ public static VitaminA Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static VitaminA Parse(string str, IFormatProvider? provider)
+        public static VitaminA<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<VitaminA, VitaminAUnit>(
+            return QuantityParser.Default.Parse<T, VitaminA<T>, VitaminAUnit>(
                 str,
                 provider,
                 From);
@@ -291,7 +288,7 @@ public static VitaminA Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out VitaminA result)
+        public static bool TryParse(string? str, out VitaminA<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -306,9 +303,9 @@ public static bool TryParse(string? str, out VitaminA result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out VitaminA result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out VitaminA<T> result)
         {
-            return QuantityParser.Default.TryParse<VitaminA, VitaminAUnit>(
+            return QuantityParser.Default.TryParse<T, VitaminA<T>, VitaminAUnit>(
                 str,
                 provider,
                 From,
@@ -370,45 +367,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Vitam
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static VitaminA operator -(VitaminA right)
+        public static VitaminA<T> operator -(VitaminA<T> right)
         {
-            return new VitaminA(-right.Value, right.Unit);
+            return new VitaminA<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="VitaminA"/> from adding two <see cref="VitaminA"/>.</summary>
-        public static VitaminA operator +(VitaminA left, VitaminA right)
+        /// <summary>Get <see cref="VitaminA{T}"/> from adding two <see cref="VitaminA{T}"/>.</summary>
+        public static VitaminA<T> operator +(VitaminA<T> left, VitaminA<T> right)
         {
-            return new VitaminA(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new VitaminA<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VitaminA"/> from subtracting two <see cref="VitaminA"/>.</summary>
-        public static VitaminA operator -(VitaminA left, VitaminA right)
+        /// <summary>Get <see cref="VitaminA{T}"/> from subtracting two <see cref="VitaminA{T}"/>.</summary>
+        public static VitaminA<T> operator -(VitaminA<T> left, VitaminA<T> right)
         {
-            return new VitaminA(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new VitaminA<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VitaminA"/> from multiplying value and <see cref="VitaminA"/>.</summary>
-        public static VitaminA operator *(double left, VitaminA right)
+        /// <summary>Get <see cref="VitaminA{T}"/> from multiplying value and <see cref="VitaminA{T}"/>.</summary>
+        public static VitaminA<T> operator *(T left, VitaminA<T> right)
         {
-            return new VitaminA(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new VitaminA<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="VitaminA"/> from multiplying value and <see cref="VitaminA"/>.</summary>
-        public static VitaminA operator *(VitaminA left, double right)
+        /// <summary>Get <see cref="VitaminA{T}"/> from multiplying value and <see cref="VitaminA{T}"/>.</summary>
+        public static VitaminA<T> operator *(VitaminA<T> left, T right)
         {
-            return new VitaminA(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new VitaminA<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VitaminA"/> from dividing <see cref="VitaminA"/> by value.</summary>
-        public static VitaminA operator /(VitaminA left, double right)
+        /// <summary>Get <see cref="VitaminA{T}"/> from dividing <see cref="VitaminA{T}"/> by value.</summary>
+        public static VitaminA<T> operator /(VitaminA<T> left, T right)
         {
-            return new VitaminA(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new VitaminA<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="VitaminA"/> by <see cref="VitaminA"/>.</summary>
-        public static double operator /(VitaminA left, VitaminA right)
+        /// <summary>Get ratio value from dividing <see cref="VitaminA{T}"/> by <see cref="VitaminA{T}"/>.</summary>
+        public static T operator /(VitaminA<T> left, VitaminA<T> right)
         {
-            return left.InternationalUnits / right.InternationalUnits;
+            return CompiledLambdas.Divide(left.InternationalUnits, right.InternationalUnits);
         }
 
         #endregion
@@ -416,39 +418,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Vitam
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(VitaminA left, VitaminA right)
+        public static bool operator <=(VitaminA<T> left, VitaminA<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(VitaminA left, VitaminA right)
+        public static bool operator >=(VitaminA<T> left, VitaminA<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(VitaminA left, VitaminA right)
+        public static bool operator <(VitaminA<T> left, VitaminA<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(VitaminA left, VitaminA right)
+        public static bool operator >(VitaminA<T> left, VitaminA<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VitaminA, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(VitaminA left, VitaminA right)
+        /// <remarks>Consider using <see cref="Equals(VitaminA{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(VitaminA<T> left, VitaminA<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VitaminA, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(VitaminA left, VitaminA right)
+        /// <remarks>Consider using <see cref="Equals(VitaminA{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(VitaminA<T> left, VitaminA<T> right)
         {
             return !(left == right);
         }
@@ -457,37 +459,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Vitam
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is VitaminA objVitaminA)) throw new ArgumentException("Expected type VitaminA.", nameof(obj));
+            if(!(obj is VitaminA<T> objVitaminA)) throw new ArgumentException("Expected type VitaminA.", nameof(obj));
 
             return CompareTo(objVitaminA);
         }
 
         /// <inheritdoc />
-        public int CompareTo(VitaminA other)
+        public int CompareTo(VitaminA<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VitaminA, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(VitaminA{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is VitaminA objVitaminA))
+            if(obj is null || !(obj is VitaminA<T> objVitaminA))
                 return false;
 
             return Equals(objVitaminA);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VitaminA, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(VitaminA other)
+        /// <remarks>Consider using <see cref="Equals(VitaminA{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(VitaminA<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another VitaminA within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="VitaminA{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -525,21 +527,19 @@ public bool Equals(VitaminA other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(VitaminA other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(VitaminA<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current VitaminA.</returns>
+        /// <returns>A hash code for the current <see cref="VitaminA{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -553,17 +553,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(VitaminAUnit unit)
+        public T As(VitaminAUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -583,17 +583,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is VitaminAUnit unitAsVitaminAUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VitaminAUnit)} is supported.", nameof(unit));
 
-            return As(unitAsVitaminAUnit);
+            var asValue = As(unitAsVitaminAUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<VitaminAUnit>.As(VitaminAUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this VitaminA to another VitaminA with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="VitaminA{T}" /> to another <see cref="VitaminA{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A VitaminA with the specified unit.</returns>
-        public VitaminA ToUnit(VitaminAUnit unit)
+        /// <returns>A <see cref="VitaminA{T}" /> with the specified unit.</returns>
+        public VitaminA<T> ToUnit(VitaminAUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new VitaminA(convertedValue, unit);
+            return new VitaminA<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -606,7 +611,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public VitaminA ToUnit(UnitSystem unitSystem)
+        public VitaminA<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -626,19 +631,25 @@ public VitaminA ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VitaminAUnit> IQuantity<VitaminAUnit>.ToUnit(VitaminAUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<VitaminAUnit, T> IQuantityT<VitaminAUnit, T>.ToUnit(VitaminAUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<VitaminAUnit> IQuantity<VitaminAUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<VitaminAUnit, T> IQuantityT<VitaminAUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case VitaminAUnit.InternationalUnit: return _value;
+                case VitaminAUnit.InternationalUnit: return Value;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -649,16 +660,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal VitaminA ToBaseUnit()
+        internal VitaminA<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new VitaminA(baseUnitValue, BaseUnit);
+            return new VitaminA<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(VitaminAUnit unit)
+        private T GetValueAs(VitaminAUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -761,57 +772,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VitaminA)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VitaminA<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VitaminA)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VitaminA<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VitaminA)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VitaminA<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -821,33 +832,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(VitaminA))
+            if(conversionType == typeof(VitaminA<T>))
                 return this;
             else if(conversionType == typeof(VitaminAUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return VitaminA.QuantityType;
+                return VitaminA<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return VitaminA.Info;
+                return VitaminA<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return VitaminA.BaseDimensions;
+                return VitaminA<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(VitaminA)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(VitaminA<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
index f3f25c646f..174e0d4a26 100644
--- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Volume is the quantity of three-dimensional space enclosed by some closed boundary, for example, the space that a substance (solid, liquid, gas, or plasma) or shape occupies or contains.[1] Volume is often quantified numerically using the SI derived unit, the cubic metre. The volume of a container is generally understood to be the capacity of the container, i. e. the amount of fluid (gas or liquid) that the container could hold, rather than the amount of space the container itself displaces.
     /// </summary>
-    public partial struct Volume : IQuantity<VolumeUnit>, IEquatable<Volume>, IComparable, IComparable<Volume>, IConvertible, IFormattable
+    public partial struct Volume<T> : IQuantityT<VolumeUnit, T>, IEquatable<Volume<T>>, IComparable, IComparable<Volume<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -113,12 +109,12 @@ static Volume()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public Volume(double value, VolumeUnit unit)
+        public Volume(T value, VolumeUnit unit)
         {
             if(unit == VolumeUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -130,14 +126,14 @@ public Volume(double value, VolumeUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Volume(double value, UnitSystem unitSystem)
+        public Volume(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -152,19 +148,19 @@ public Volume(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of Volume, which is CubicMeter. All conversions go via this value.
+        ///     The base unit of <see cref="Volume{T}" />, which is CubicMeter. All conversions go via this value.
         /// </summary>
         public static VolumeUnit BaseUnit { get; } = VolumeUnit.CubicMeter;
 
         /// <summary>
-        /// Represents the largest possible value of Volume
+        /// Represents the largest possible value of <see cref="Volume{T}" />
         /// </summary>
-        public static Volume MaxValue { get; } = new Volume(double.MaxValue, BaseUnit);
+        public static Volume<T> MaxValue { get; } = new Volume<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of Volume
+        /// Represents the smallest possible value of <see cref="Volume{T}" />
         /// </summary>
-        public static Volume MinValue { get; } = new Volume(double.MinValue, BaseUnit);
+        public static Volume<T> MinValue { get; } = new Volume<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -173,14 +169,14 @@ public Volume(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.Volume;
 
         /// <summary>
-        ///     All units of measurement for the Volume quantity.
+        ///     All units of measurement for the <see cref="Volume{T}" /> quantity.
         /// </summary>
         public static VolumeUnit[] Units { get; } = Enum.GetValues(typeof(VolumeUnit)).Cast<VolumeUnit>().Except(new VolumeUnit[]{ VolumeUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit CubicMeter.
         /// </summary>
-        public static Volume Zero { get; } = new Volume(0, BaseUnit);
+        public static Volume<T> Zero { get; } = new Volume<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -189,7 +185,9 @@ public Volume(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -205,271 +203,271 @@ public Volume(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => Volume.QuantityType;
+        public QuantityType Type => Volume<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => Volume.BaseDimensions;
+        public BaseDimensions Dimensions => Volume<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get Volume in AcreFeet.
+        ///     Get <see cref="Volume{T}" /> in AcreFeet.
         /// </summary>
-        public double AcreFeet => As(VolumeUnit.AcreFoot);
+        public T AcreFeet => As(VolumeUnit.AcreFoot);
 
         /// <summary>
-        ///     Get Volume in AuTablespoons.
+        ///     Get <see cref="Volume{T}" /> in AuTablespoons.
         /// </summary>
-        public double AuTablespoons => As(VolumeUnit.AuTablespoon);
+        public T AuTablespoons => As(VolumeUnit.AuTablespoon);
 
         /// <summary>
-        ///     Get Volume in BoardFeet.
+        ///     Get <see cref="Volume{T}" /> in BoardFeet.
         /// </summary>
-        public double BoardFeet => As(VolumeUnit.BoardFoot);
+        public T BoardFeet => As(VolumeUnit.BoardFoot);
 
         /// <summary>
-        ///     Get Volume in Centiliters.
+        ///     Get <see cref="Volume{T}" /> in Centiliters.
         /// </summary>
-        public double Centiliters => As(VolumeUnit.Centiliter);
+        public T Centiliters => As(VolumeUnit.Centiliter);
 
         /// <summary>
-        ///     Get Volume in CubicCentimeters.
+        ///     Get <see cref="Volume{T}" /> in CubicCentimeters.
         /// </summary>
-        public double CubicCentimeters => As(VolumeUnit.CubicCentimeter);
+        public T CubicCentimeters => As(VolumeUnit.CubicCentimeter);
 
         /// <summary>
-        ///     Get Volume in CubicDecimeters.
+        ///     Get <see cref="Volume{T}" /> in CubicDecimeters.
         /// </summary>
-        public double CubicDecimeters => As(VolumeUnit.CubicDecimeter);
+        public T CubicDecimeters => As(VolumeUnit.CubicDecimeter);
 
         /// <summary>
-        ///     Get Volume in CubicFeet.
+        ///     Get <see cref="Volume{T}" /> in CubicFeet.
         /// </summary>
-        public double CubicFeet => As(VolumeUnit.CubicFoot);
+        public T CubicFeet => As(VolumeUnit.CubicFoot);
 
         /// <summary>
-        ///     Get Volume in CubicHectometers.
+        ///     Get <see cref="Volume{T}" /> in CubicHectometers.
         /// </summary>
-        public double CubicHectometers => As(VolumeUnit.CubicHectometer);
+        public T CubicHectometers => As(VolumeUnit.CubicHectometer);
 
         /// <summary>
-        ///     Get Volume in CubicInches.
+        ///     Get <see cref="Volume{T}" /> in CubicInches.
         /// </summary>
-        public double CubicInches => As(VolumeUnit.CubicInch);
+        public T CubicInches => As(VolumeUnit.CubicInch);
 
         /// <summary>
-        ///     Get Volume in CubicKilometers.
+        ///     Get <see cref="Volume{T}" /> in CubicKilometers.
         /// </summary>
-        public double CubicKilometers => As(VolumeUnit.CubicKilometer);
+        public T CubicKilometers => As(VolumeUnit.CubicKilometer);
 
         /// <summary>
-        ///     Get Volume in CubicMeters.
+        ///     Get <see cref="Volume{T}" /> in CubicMeters.
         /// </summary>
-        public double CubicMeters => As(VolumeUnit.CubicMeter);
+        public T CubicMeters => As(VolumeUnit.CubicMeter);
 
         /// <summary>
-        ///     Get Volume in CubicMicrometers.
+        ///     Get <see cref="Volume{T}" /> in CubicMicrometers.
         /// </summary>
-        public double CubicMicrometers => As(VolumeUnit.CubicMicrometer);
+        public T CubicMicrometers => As(VolumeUnit.CubicMicrometer);
 
         /// <summary>
-        ///     Get Volume in CubicMiles.
+        ///     Get <see cref="Volume{T}" /> in CubicMiles.
         /// </summary>
-        public double CubicMiles => As(VolumeUnit.CubicMile);
+        public T CubicMiles => As(VolumeUnit.CubicMile);
 
         /// <summary>
-        ///     Get Volume in CubicMillimeters.
+        ///     Get <see cref="Volume{T}" /> in CubicMillimeters.
         /// </summary>
-        public double CubicMillimeters => As(VolumeUnit.CubicMillimeter);
+        public T CubicMillimeters => As(VolumeUnit.CubicMillimeter);
 
         /// <summary>
-        ///     Get Volume in CubicYards.
+        ///     Get <see cref="Volume{T}" /> in CubicYards.
         /// </summary>
-        public double CubicYards => As(VolumeUnit.CubicYard);
+        public T CubicYards => As(VolumeUnit.CubicYard);
 
         /// <summary>
-        ///     Get Volume in DecausGallons.
+        ///     Get <see cref="Volume{T}" /> in DecausGallons.
         /// </summary>
-        public double DecausGallons => As(VolumeUnit.DecausGallon);
+        public T DecausGallons => As(VolumeUnit.DecausGallon);
 
         /// <summary>
-        ///     Get Volume in Deciliters.
+        ///     Get <see cref="Volume{T}" /> in Deciliters.
         /// </summary>
-        public double Deciliters => As(VolumeUnit.Deciliter);
+        public T Deciliters => As(VolumeUnit.Deciliter);
 
         /// <summary>
-        ///     Get Volume in DeciusGallons.
+        ///     Get <see cref="Volume{T}" /> in DeciusGallons.
         /// </summary>
-        public double DeciusGallons => As(VolumeUnit.DeciusGallon);
+        public T DeciusGallons => As(VolumeUnit.DeciusGallon);
 
         /// <summary>
-        ///     Get Volume in HectocubicFeet.
+        ///     Get <see cref="Volume{T}" /> in HectocubicFeet.
         /// </summary>
-        public double HectocubicFeet => As(VolumeUnit.HectocubicFoot);
+        public T HectocubicFeet => As(VolumeUnit.HectocubicFoot);
 
         /// <summary>
-        ///     Get Volume in HectocubicMeters.
+        ///     Get <see cref="Volume{T}" /> in HectocubicMeters.
         /// </summary>
-        public double HectocubicMeters => As(VolumeUnit.HectocubicMeter);
+        public T HectocubicMeters => As(VolumeUnit.HectocubicMeter);
 
         /// <summary>
-        ///     Get Volume in Hectoliters.
+        ///     Get <see cref="Volume{T}" /> in Hectoliters.
         /// </summary>
-        public double Hectoliters => As(VolumeUnit.Hectoliter);
+        public T Hectoliters => As(VolumeUnit.Hectoliter);
 
         /// <summary>
-        ///     Get Volume in HectousGallons.
+        ///     Get <see cref="Volume{T}" /> in HectousGallons.
         /// </summary>
-        public double HectousGallons => As(VolumeUnit.HectousGallon);
+        public T HectousGallons => As(VolumeUnit.HectousGallon);
 
         /// <summary>
-        ///     Get Volume in ImperialBeerBarrels.
+        ///     Get <see cref="Volume{T}" /> in ImperialBeerBarrels.
         /// </summary>
-        public double ImperialBeerBarrels => As(VolumeUnit.ImperialBeerBarrel);
+        public T ImperialBeerBarrels => As(VolumeUnit.ImperialBeerBarrel);
 
         /// <summary>
-        ///     Get Volume in ImperialGallons.
+        ///     Get <see cref="Volume{T}" /> in ImperialGallons.
         /// </summary>
-        public double ImperialGallons => As(VolumeUnit.ImperialGallon);
+        public T ImperialGallons => As(VolumeUnit.ImperialGallon);
 
         /// <summary>
-        ///     Get Volume in ImperialOunces.
+        ///     Get <see cref="Volume{T}" /> in ImperialOunces.
         /// </summary>
-        public double ImperialOunces => As(VolumeUnit.ImperialOunce);
+        public T ImperialOunces => As(VolumeUnit.ImperialOunce);
 
         /// <summary>
-        ///     Get Volume in ImperialPints.
+        ///     Get <see cref="Volume{T}" /> in ImperialPints.
         /// </summary>
-        public double ImperialPints => As(VolumeUnit.ImperialPint);
+        public T ImperialPints => As(VolumeUnit.ImperialPint);
 
         /// <summary>
-        ///     Get Volume in KilocubicFeet.
+        ///     Get <see cref="Volume{T}" /> in KilocubicFeet.
         /// </summary>
-        public double KilocubicFeet => As(VolumeUnit.KilocubicFoot);
+        public T KilocubicFeet => As(VolumeUnit.KilocubicFoot);
 
         /// <summary>
-        ///     Get Volume in KilocubicMeters.
+        ///     Get <see cref="Volume{T}" /> in KilocubicMeters.
         /// </summary>
-        public double KilocubicMeters => As(VolumeUnit.KilocubicMeter);
+        public T KilocubicMeters => As(VolumeUnit.KilocubicMeter);
 
         /// <summary>
-        ///     Get Volume in KiloimperialGallons.
+        ///     Get <see cref="Volume{T}" /> in KiloimperialGallons.
         /// </summary>
-        public double KiloimperialGallons => As(VolumeUnit.KiloimperialGallon);
+        public T KiloimperialGallons => As(VolumeUnit.KiloimperialGallon);
 
         /// <summary>
-        ///     Get Volume in Kiloliters.
+        ///     Get <see cref="Volume{T}" /> in Kiloliters.
         /// </summary>
-        public double Kiloliters => As(VolumeUnit.Kiloliter);
+        public T Kiloliters => As(VolumeUnit.Kiloliter);
 
         /// <summary>
-        ///     Get Volume in KilousGallons.
+        ///     Get <see cref="Volume{T}" /> in KilousGallons.
         /// </summary>
-        public double KilousGallons => As(VolumeUnit.KilousGallon);
+        public T KilousGallons => As(VolumeUnit.KilousGallon);
 
         /// <summary>
-        ///     Get Volume in Liters.
+        ///     Get <see cref="Volume{T}" /> in Liters.
         /// </summary>
-        public double Liters => As(VolumeUnit.Liter);
+        public T Liters => As(VolumeUnit.Liter);
 
         /// <summary>
-        ///     Get Volume in MegacubicFeet.
+        ///     Get <see cref="Volume{T}" /> in MegacubicFeet.
         /// </summary>
-        public double MegacubicFeet => As(VolumeUnit.MegacubicFoot);
+        public T MegacubicFeet => As(VolumeUnit.MegacubicFoot);
 
         /// <summary>
-        ///     Get Volume in MegaimperialGallons.
+        ///     Get <see cref="Volume{T}" /> in MegaimperialGallons.
         /// </summary>
-        public double MegaimperialGallons => As(VolumeUnit.MegaimperialGallon);
+        public T MegaimperialGallons => As(VolumeUnit.MegaimperialGallon);
 
         /// <summary>
-        ///     Get Volume in Megaliters.
+        ///     Get <see cref="Volume{T}" /> in Megaliters.
         /// </summary>
-        public double Megaliters => As(VolumeUnit.Megaliter);
+        public T Megaliters => As(VolumeUnit.Megaliter);
 
         /// <summary>
-        ///     Get Volume in MegausGallons.
+        ///     Get <see cref="Volume{T}" /> in MegausGallons.
         /// </summary>
-        public double MegausGallons => As(VolumeUnit.MegausGallon);
+        public T MegausGallons => As(VolumeUnit.MegausGallon);
 
         /// <summary>
-        ///     Get Volume in MetricCups.
+        ///     Get <see cref="Volume{T}" /> in MetricCups.
         /// </summary>
-        public double MetricCups => As(VolumeUnit.MetricCup);
+        public T MetricCups => As(VolumeUnit.MetricCup);
 
         /// <summary>
-        ///     Get Volume in MetricTeaspoons.
+        ///     Get <see cref="Volume{T}" /> in MetricTeaspoons.
         /// </summary>
-        public double MetricTeaspoons => As(VolumeUnit.MetricTeaspoon);
+        public T MetricTeaspoons => As(VolumeUnit.MetricTeaspoon);
 
         /// <summary>
-        ///     Get Volume in Microliters.
+        ///     Get <see cref="Volume{T}" /> in Microliters.
         /// </summary>
-        public double Microliters => As(VolumeUnit.Microliter);
+        public T Microliters => As(VolumeUnit.Microliter);
 
         /// <summary>
-        ///     Get Volume in Milliliters.
+        ///     Get <see cref="Volume{T}" /> in Milliliters.
         /// </summary>
-        public double Milliliters => As(VolumeUnit.Milliliter);
+        public T Milliliters => As(VolumeUnit.Milliliter);
 
         /// <summary>
-        ///     Get Volume in OilBarrels.
+        ///     Get <see cref="Volume{T}" /> in OilBarrels.
         /// </summary>
-        public double OilBarrels => As(VolumeUnit.OilBarrel);
+        public T OilBarrels => As(VolumeUnit.OilBarrel);
 
         /// <summary>
-        ///     Get Volume in UkTablespoons.
+        ///     Get <see cref="Volume{T}" /> in UkTablespoons.
         /// </summary>
-        public double UkTablespoons => As(VolumeUnit.UkTablespoon);
+        public T UkTablespoons => As(VolumeUnit.UkTablespoon);
 
         /// <summary>
-        ///     Get Volume in UsBeerBarrels.
+        ///     Get <see cref="Volume{T}" /> in UsBeerBarrels.
         /// </summary>
-        public double UsBeerBarrels => As(VolumeUnit.UsBeerBarrel);
+        public T UsBeerBarrels => As(VolumeUnit.UsBeerBarrel);
 
         /// <summary>
-        ///     Get Volume in UsCustomaryCups.
+        ///     Get <see cref="Volume{T}" /> in UsCustomaryCups.
         /// </summary>
-        public double UsCustomaryCups => As(VolumeUnit.UsCustomaryCup);
+        public T UsCustomaryCups => As(VolumeUnit.UsCustomaryCup);
 
         /// <summary>
-        ///     Get Volume in UsGallons.
+        ///     Get <see cref="Volume{T}" /> in UsGallons.
         /// </summary>
-        public double UsGallons => As(VolumeUnit.UsGallon);
+        public T UsGallons => As(VolumeUnit.UsGallon);
 
         /// <summary>
-        ///     Get Volume in UsLegalCups.
+        ///     Get <see cref="Volume{T}" /> in UsLegalCups.
         /// </summary>
-        public double UsLegalCups => As(VolumeUnit.UsLegalCup);
+        public T UsLegalCups => As(VolumeUnit.UsLegalCup);
 
         /// <summary>
-        ///     Get Volume in UsOunces.
+        ///     Get <see cref="Volume{T}" /> in UsOunces.
         /// </summary>
-        public double UsOunces => As(VolumeUnit.UsOunce);
+        public T UsOunces => As(VolumeUnit.UsOunce);
 
         /// <summary>
-        ///     Get Volume in UsPints.
+        ///     Get <see cref="Volume{T}" /> in UsPints.
         /// </summary>
-        public double UsPints => As(VolumeUnit.UsPint);
+        public T UsPints => As(VolumeUnit.UsPint);
 
         /// <summary>
-        ///     Get Volume in UsQuarts.
+        ///     Get <see cref="Volume{T}" /> in UsQuarts.
         /// </summary>
-        public double UsQuarts => As(VolumeUnit.UsQuart);
+        public T UsQuarts => As(VolumeUnit.UsQuart);
 
         /// <summary>
-        ///     Get Volume in UsTablespoons.
+        ///     Get <see cref="Volume{T}" /> in UsTablespoons.
         /// </summary>
-        public double UsTablespoons => As(VolumeUnit.UsTablespoon);
+        public T UsTablespoons => As(VolumeUnit.UsTablespoon);
 
         /// <summary>
-        ///     Get Volume in UsTeaspoons.
+        ///     Get <see cref="Volume{T}" /> in UsTeaspoons.
         /// </summary>
-        public double UsTeaspoons => As(VolumeUnit.UsTeaspoon);
+        public T UsTeaspoons => As(VolumeUnit.UsTeaspoon);
 
         #endregion
 
@@ -501,474 +499,423 @@ public static string GetAbbreviation(VolumeUnit unit, IFormatProvider? provider)
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get Volume from AcreFeet.
+        ///     Get <see cref="Volume{T}" /> from AcreFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromAcreFeet(QuantityValue acrefeet)
+        public static Volume<T> FromAcreFeet(T acrefeet)
         {
-            double value = (double) acrefeet;
-            return new Volume(value, VolumeUnit.AcreFoot);
+            return new Volume<T>(acrefeet, VolumeUnit.AcreFoot);
         }
         /// <summary>
-        ///     Get Volume from AuTablespoons.
+        ///     Get <see cref="Volume{T}" /> from AuTablespoons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromAuTablespoons(QuantityValue autablespoons)
+        public static Volume<T> FromAuTablespoons(T autablespoons)
         {
-            double value = (double) autablespoons;
-            return new Volume(value, VolumeUnit.AuTablespoon);
+            return new Volume<T>(autablespoons, VolumeUnit.AuTablespoon);
         }
         /// <summary>
-        ///     Get Volume from BoardFeet.
+        ///     Get <see cref="Volume{T}" /> from BoardFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromBoardFeet(QuantityValue boardfeet)
+        public static Volume<T> FromBoardFeet(T boardfeet)
         {
-            double value = (double) boardfeet;
-            return new Volume(value, VolumeUnit.BoardFoot);
+            return new Volume<T>(boardfeet, VolumeUnit.BoardFoot);
         }
         /// <summary>
-        ///     Get Volume from Centiliters.
+        ///     Get <see cref="Volume{T}" /> from Centiliters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCentiliters(QuantityValue centiliters)
+        public static Volume<T> FromCentiliters(T centiliters)
         {
-            double value = (double) centiliters;
-            return new Volume(value, VolumeUnit.Centiliter);
+            return new Volume<T>(centiliters, VolumeUnit.Centiliter);
         }
         /// <summary>
-        ///     Get Volume from CubicCentimeters.
+        ///     Get <see cref="Volume{T}" /> from CubicCentimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicCentimeters(QuantityValue cubiccentimeters)
+        public static Volume<T> FromCubicCentimeters(T cubiccentimeters)
         {
-            double value = (double) cubiccentimeters;
-            return new Volume(value, VolumeUnit.CubicCentimeter);
+            return new Volume<T>(cubiccentimeters, VolumeUnit.CubicCentimeter);
         }
         /// <summary>
-        ///     Get Volume from CubicDecimeters.
+        ///     Get <see cref="Volume{T}" /> from CubicDecimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicDecimeters(QuantityValue cubicdecimeters)
+        public static Volume<T> FromCubicDecimeters(T cubicdecimeters)
         {
-            double value = (double) cubicdecimeters;
-            return new Volume(value, VolumeUnit.CubicDecimeter);
+            return new Volume<T>(cubicdecimeters, VolumeUnit.CubicDecimeter);
         }
         /// <summary>
-        ///     Get Volume from CubicFeet.
+        ///     Get <see cref="Volume{T}" /> from CubicFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicFeet(QuantityValue cubicfeet)
+        public static Volume<T> FromCubicFeet(T cubicfeet)
         {
-            double value = (double) cubicfeet;
-            return new Volume(value, VolumeUnit.CubicFoot);
+            return new Volume<T>(cubicfeet, VolumeUnit.CubicFoot);
         }
         /// <summary>
-        ///     Get Volume from CubicHectometers.
+        ///     Get <see cref="Volume{T}" /> from CubicHectometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicHectometers(QuantityValue cubichectometers)
+        public static Volume<T> FromCubicHectometers(T cubichectometers)
         {
-            double value = (double) cubichectometers;
-            return new Volume(value, VolumeUnit.CubicHectometer);
+            return new Volume<T>(cubichectometers, VolumeUnit.CubicHectometer);
         }
         /// <summary>
-        ///     Get Volume from CubicInches.
+        ///     Get <see cref="Volume{T}" /> from CubicInches.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicInches(QuantityValue cubicinches)
+        public static Volume<T> FromCubicInches(T cubicinches)
         {
-            double value = (double) cubicinches;
-            return new Volume(value, VolumeUnit.CubicInch);
+            return new Volume<T>(cubicinches, VolumeUnit.CubicInch);
         }
         /// <summary>
-        ///     Get Volume from CubicKilometers.
+        ///     Get <see cref="Volume{T}" /> from CubicKilometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicKilometers(QuantityValue cubickilometers)
+        public static Volume<T> FromCubicKilometers(T cubickilometers)
         {
-            double value = (double) cubickilometers;
-            return new Volume(value, VolumeUnit.CubicKilometer);
+            return new Volume<T>(cubickilometers, VolumeUnit.CubicKilometer);
         }
         /// <summary>
-        ///     Get Volume from CubicMeters.
+        ///     Get <see cref="Volume{T}" /> from CubicMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMeters(QuantityValue cubicmeters)
+        public static Volume<T> FromCubicMeters(T cubicmeters)
         {
-            double value = (double) cubicmeters;
-            return new Volume(value, VolumeUnit.CubicMeter);
+            return new Volume<T>(cubicmeters, VolumeUnit.CubicMeter);
         }
         /// <summary>
-        ///     Get Volume from CubicMicrometers.
+        ///     Get <see cref="Volume{T}" /> from CubicMicrometers.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMicrometers(QuantityValue cubicmicrometers)
+        public static Volume<T> FromCubicMicrometers(T cubicmicrometers)
         {
-            double value = (double) cubicmicrometers;
-            return new Volume(value, VolumeUnit.CubicMicrometer);
+            return new Volume<T>(cubicmicrometers, VolumeUnit.CubicMicrometer);
         }
         /// <summary>
-        ///     Get Volume from CubicMiles.
+        ///     Get <see cref="Volume{T}" /> from CubicMiles.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMiles(QuantityValue cubicmiles)
+        public static Volume<T> FromCubicMiles(T cubicmiles)
         {
-            double value = (double) cubicmiles;
-            return new Volume(value, VolumeUnit.CubicMile);
+            return new Volume<T>(cubicmiles, VolumeUnit.CubicMile);
         }
         /// <summary>
-        ///     Get Volume from CubicMillimeters.
+        ///     Get <see cref="Volume{T}" /> from CubicMillimeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMillimeters(QuantityValue cubicmillimeters)
+        public static Volume<T> FromCubicMillimeters(T cubicmillimeters)
         {
-            double value = (double) cubicmillimeters;
-            return new Volume(value, VolumeUnit.CubicMillimeter);
+            return new Volume<T>(cubicmillimeters, VolumeUnit.CubicMillimeter);
         }
         /// <summary>
-        ///     Get Volume from CubicYards.
+        ///     Get <see cref="Volume{T}" /> from CubicYards.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicYards(QuantityValue cubicyards)
+        public static Volume<T> FromCubicYards(T cubicyards)
         {
-            double value = (double) cubicyards;
-            return new Volume(value, VolumeUnit.CubicYard);
+            return new Volume<T>(cubicyards, VolumeUnit.CubicYard);
         }
         /// <summary>
-        ///     Get Volume from DecausGallons.
+        ///     Get <see cref="Volume{T}" /> from DecausGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDecausGallons(QuantityValue decausgallons)
+        public static Volume<T> FromDecausGallons(T decausgallons)
         {
-            double value = (double) decausgallons;
-            return new Volume(value, VolumeUnit.DecausGallon);
+            return new Volume<T>(decausgallons, VolumeUnit.DecausGallon);
         }
         /// <summary>
-        ///     Get Volume from Deciliters.
+        ///     Get <see cref="Volume{T}" /> from Deciliters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDeciliters(QuantityValue deciliters)
+        public static Volume<T> FromDeciliters(T deciliters)
         {
-            double value = (double) deciliters;
-            return new Volume(value, VolumeUnit.Deciliter);
+            return new Volume<T>(deciliters, VolumeUnit.Deciliter);
         }
         /// <summary>
-        ///     Get Volume from DeciusGallons.
+        ///     Get <see cref="Volume{T}" /> from DeciusGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDeciusGallons(QuantityValue deciusgallons)
+        public static Volume<T> FromDeciusGallons(T deciusgallons)
         {
-            double value = (double) deciusgallons;
-            return new Volume(value, VolumeUnit.DeciusGallon);
+            return new Volume<T>(deciusgallons, VolumeUnit.DeciusGallon);
         }
         /// <summary>
-        ///     Get Volume from HectocubicFeet.
+        ///     Get <see cref="Volume{T}" /> from HectocubicFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectocubicFeet(QuantityValue hectocubicfeet)
+        public static Volume<T> FromHectocubicFeet(T hectocubicfeet)
         {
-            double value = (double) hectocubicfeet;
-            return new Volume(value, VolumeUnit.HectocubicFoot);
+            return new Volume<T>(hectocubicfeet, VolumeUnit.HectocubicFoot);
         }
         /// <summary>
-        ///     Get Volume from HectocubicMeters.
+        ///     Get <see cref="Volume{T}" /> from HectocubicMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectocubicMeters(QuantityValue hectocubicmeters)
+        public static Volume<T> FromHectocubicMeters(T hectocubicmeters)
         {
-            double value = (double) hectocubicmeters;
-            return new Volume(value, VolumeUnit.HectocubicMeter);
+            return new Volume<T>(hectocubicmeters, VolumeUnit.HectocubicMeter);
         }
         /// <summary>
-        ///     Get Volume from Hectoliters.
+        ///     Get <see cref="Volume{T}" /> from Hectoliters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectoliters(QuantityValue hectoliters)
+        public static Volume<T> FromHectoliters(T hectoliters)
         {
-            double value = (double) hectoliters;
-            return new Volume(value, VolumeUnit.Hectoliter);
+            return new Volume<T>(hectoliters, VolumeUnit.Hectoliter);
         }
         /// <summary>
-        ///     Get Volume from HectousGallons.
+        ///     Get <see cref="Volume{T}" /> from HectousGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectousGallons(QuantityValue hectousgallons)
+        public static Volume<T> FromHectousGallons(T hectousgallons)
         {
-            double value = (double) hectousgallons;
-            return new Volume(value, VolumeUnit.HectousGallon);
+            return new Volume<T>(hectousgallons, VolumeUnit.HectousGallon);
         }
         /// <summary>
-        ///     Get Volume from ImperialBeerBarrels.
+        ///     Get <see cref="Volume{T}" /> from ImperialBeerBarrels.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialBeerBarrels(QuantityValue imperialbeerbarrels)
+        public static Volume<T> FromImperialBeerBarrels(T imperialbeerbarrels)
         {
-            double value = (double) imperialbeerbarrels;
-            return new Volume(value, VolumeUnit.ImperialBeerBarrel);
+            return new Volume<T>(imperialbeerbarrels, VolumeUnit.ImperialBeerBarrel);
         }
         /// <summary>
-        ///     Get Volume from ImperialGallons.
+        ///     Get <see cref="Volume{T}" /> from ImperialGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialGallons(QuantityValue imperialgallons)
+        public static Volume<T> FromImperialGallons(T imperialgallons)
         {
-            double value = (double) imperialgallons;
-            return new Volume(value, VolumeUnit.ImperialGallon);
+            return new Volume<T>(imperialgallons, VolumeUnit.ImperialGallon);
         }
         /// <summary>
-        ///     Get Volume from ImperialOunces.
+        ///     Get <see cref="Volume{T}" /> from ImperialOunces.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialOunces(QuantityValue imperialounces)
+        public static Volume<T> FromImperialOunces(T imperialounces)
         {
-            double value = (double) imperialounces;
-            return new Volume(value, VolumeUnit.ImperialOunce);
+            return new Volume<T>(imperialounces, VolumeUnit.ImperialOunce);
         }
         /// <summary>
-        ///     Get Volume from ImperialPints.
+        ///     Get <see cref="Volume{T}" /> from ImperialPints.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialPints(QuantityValue imperialpints)
+        public static Volume<T> FromImperialPints(T imperialpints)
         {
-            double value = (double) imperialpints;
-            return new Volume(value, VolumeUnit.ImperialPint);
+            return new Volume<T>(imperialpints, VolumeUnit.ImperialPint);
         }
         /// <summary>
-        ///     Get Volume from KilocubicFeet.
+        ///     Get <see cref="Volume{T}" /> from KilocubicFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilocubicFeet(QuantityValue kilocubicfeet)
+        public static Volume<T> FromKilocubicFeet(T kilocubicfeet)
         {
-            double value = (double) kilocubicfeet;
-            return new Volume(value, VolumeUnit.KilocubicFoot);
+            return new Volume<T>(kilocubicfeet, VolumeUnit.KilocubicFoot);
         }
         /// <summary>
-        ///     Get Volume from KilocubicMeters.
+        ///     Get <see cref="Volume{T}" /> from KilocubicMeters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilocubicMeters(QuantityValue kilocubicmeters)
+        public static Volume<T> FromKilocubicMeters(T kilocubicmeters)
         {
-            double value = (double) kilocubicmeters;
-            return new Volume(value, VolumeUnit.KilocubicMeter);
+            return new Volume<T>(kilocubicmeters, VolumeUnit.KilocubicMeter);
         }
         /// <summary>
-        ///     Get Volume from KiloimperialGallons.
+        ///     Get <see cref="Volume{T}" /> from KiloimperialGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKiloimperialGallons(QuantityValue kiloimperialgallons)
+        public static Volume<T> FromKiloimperialGallons(T kiloimperialgallons)
         {
-            double value = (double) kiloimperialgallons;
-            return new Volume(value, VolumeUnit.KiloimperialGallon);
+            return new Volume<T>(kiloimperialgallons, VolumeUnit.KiloimperialGallon);
         }
         /// <summary>
-        ///     Get Volume from Kiloliters.
+        ///     Get <see cref="Volume{T}" /> from Kiloliters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKiloliters(QuantityValue kiloliters)
+        public static Volume<T> FromKiloliters(T kiloliters)
         {
-            double value = (double) kiloliters;
-            return new Volume(value, VolumeUnit.Kiloliter);
+            return new Volume<T>(kiloliters, VolumeUnit.Kiloliter);
         }
         /// <summary>
-        ///     Get Volume from KilousGallons.
+        ///     Get <see cref="Volume{T}" /> from KilousGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilousGallons(QuantityValue kilousgallons)
+        public static Volume<T> FromKilousGallons(T kilousgallons)
         {
-            double value = (double) kilousgallons;
-            return new Volume(value, VolumeUnit.KilousGallon);
+            return new Volume<T>(kilousgallons, VolumeUnit.KilousGallon);
         }
         /// <summary>
-        ///     Get Volume from Liters.
+        ///     Get <see cref="Volume{T}" /> from Liters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromLiters(QuantityValue liters)
+        public static Volume<T> FromLiters(T liters)
         {
-            double value = (double) liters;
-            return new Volume(value, VolumeUnit.Liter);
+            return new Volume<T>(liters, VolumeUnit.Liter);
         }
         /// <summary>
-        ///     Get Volume from MegacubicFeet.
+        ///     Get <see cref="Volume{T}" /> from MegacubicFeet.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegacubicFeet(QuantityValue megacubicfeet)
+        public static Volume<T> FromMegacubicFeet(T megacubicfeet)
         {
-            double value = (double) megacubicfeet;
-            return new Volume(value, VolumeUnit.MegacubicFoot);
+            return new Volume<T>(megacubicfeet, VolumeUnit.MegacubicFoot);
         }
         /// <summary>
-        ///     Get Volume from MegaimperialGallons.
+        ///     Get <see cref="Volume{T}" /> from MegaimperialGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegaimperialGallons(QuantityValue megaimperialgallons)
+        public static Volume<T> FromMegaimperialGallons(T megaimperialgallons)
         {
-            double value = (double) megaimperialgallons;
-            return new Volume(value, VolumeUnit.MegaimperialGallon);
+            return new Volume<T>(megaimperialgallons, VolumeUnit.MegaimperialGallon);
         }
         /// <summary>
-        ///     Get Volume from Megaliters.
+        ///     Get <see cref="Volume{T}" /> from Megaliters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegaliters(QuantityValue megaliters)
+        public static Volume<T> FromMegaliters(T megaliters)
         {
-            double value = (double) megaliters;
-            return new Volume(value, VolumeUnit.Megaliter);
+            return new Volume<T>(megaliters, VolumeUnit.Megaliter);
         }
         /// <summary>
-        ///     Get Volume from MegausGallons.
+        ///     Get <see cref="Volume{T}" /> from MegausGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegausGallons(QuantityValue megausgallons)
+        public static Volume<T> FromMegausGallons(T megausgallons)
         {
-            double value = (double) megausgallons;
-            return new Volume(value, VolumeUnit.MegausGallon);
+            return new Volume<T>(megausgallons, VolumeUnit.MegausGallon);
         }
         /// <summary>
-        ///     Get Volume from MetricCups.
+        ///     Get <see cref="Volume{T}" /> from MetricCups.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMetricCups(QuantityValue metriccups)
+        public static Volume<T> FromMetricCups(T metriccups)
         {
-            double value = (double) metriccups;
-            return new Volume(value, VolumeUnit.MetricCup);
+            return new Volume<T>(metriccups, VolumeUnit.MetricCup);
         }
         /// <summary>
-        ///     Get Volume from MetricTeaspoons.
+        ///     Get <see cref="Volume{T}" /> from MetricTeaspoons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMetricTeaspoons(QuantityValue metricteaspoons)
+        public static Volume<T> FromMetricTeaspoons(T metricteaspoons)
         {
-            double value = (double) metricteaspoons;
-            return new Volume(value, VolumeUnit.MetricTeaspoon);
+            return new Volume<T>(metricteaspoons, VolumeUnit.MetricTeaspoon);
         }
         /// <summary>
-        ///     Get Volume from Microliters.
+        ///     Get <see cref="Volume{T}" /> from Microliters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMicroliters(QuantityValue microliters)
+        public static Volume<T> FromMicroliters(T microliters)
         {
-            double value = (double) microliters;
-            return new Volume(value, VolumeUnit.Microliter);
+            return new Volume<T>(microliters, VolumeUnit.Microliter);
         }
         /// <summary>
-        ///     Get Volume from Milliliters.
+        ///     Get <see cref="Volume{T}" /> from Milliliters.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMilliliters(QuantityValue milliliters)
+        public static Volume<T> FromMilliliters(T milliliters)
         {
-            double value = (double) milliliters;
-            return new Volume(value, VolumeUnit.Milliliter);
+            return new Volume<T>(milliliters, VolumeUnit.Milliliter);
         }
         /// <summary>
-        ///     Get Volume from OilBarrels.
+        ///     Get <see cref="Volume{T}" /> from OilBarrels.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromOilBarrels(QuantityValue oilbarrels)
+        public static Volume<T> FromOilBarrels(T oilbarrels)
         {
-            double value = (double) oilbarrels;
-            return new Volume(value, VolumeUnit.OilBarrel);
+            return new Volume<T>(oilbarrels, VolumeUnit.OilBarrel);
         }
         /// <summary>
-        ///     Get Volume from UkTablespoons.
+        ///     Get <see cref="Volume{T}" /> from UkTablespoons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUkTablespoons(QuantityValue uktablespoons)
+        public static Volume<T> FromUkTablespoons(T uktablespoons)
         {
-            double value = (double) uktablespoons;
-            return new Volume(value, VolumeUnit.UkTablespoon);
+            return new Volume<T>(uktablespoons, VolumeUnit.UkTablespoon);
         }
         /// <summary>
-        ///     Get Volume from UsBeerBarrels.
+        ///     Get <see cref="Volume{T}" /> from UsBeerBarrels.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsBeerBarrels(QuantityValue usbeerbarrels)
+        public static Volume<T> FromUsBeerBarrels(T usbeerbarrels)
         {
-            double value = (double) usbeerbarrels;
-            return new Volume(value, VolumeUnit.UsBeerBarrel);
+            return new Volume<T>(usbeerbarrels, VolumeUnit.UsBeerBarrel);
         }
         /// <summary>
-        ///     Get Volume from UsCustomaryCups.
+        ///     Get <see cref="Volume{T}" /> from UsCustomaryCups.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsCustomaryCups(QuantityValue uscustomarycups)
+        public static Volume<T> FromUsCustomaryCups(T uscustomarycups)
         {
-            double value = (double) uscustomarycups;
-            return new Volume(value, VolumeUnit.UsCustomaryCup);
+            return new Volume<T>(uscustomarycups, VolumeUnit.UsCustomaryCup);
         }
         /// <summary>
-        ///     Get Volume from UsGallons.
+        ///     Get <see cref="Volume{T}" /> from UsGallons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsGallons(QuantityValue usgallons)
+        public static Volume<T> FromUsGallons(T usgallons)
         {
-            double value = (double) usgallons;
-            return new Volume(value, VolumeUnit.UsGallon);
+            return new Volume<T>(usgallons, VolumeUnit.UsGallon);
         }
         /// <summary>
-        ///     Get Volume from UsLegalCups.
+        ///     Get <see cref="Volume{T}" /> from UsLegalCups.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsLegalCups(QuantityValue uslegalcups)
+        public static Volume<T> FromUsLegalCups(T uslegalcups)
         {
-            double value = (double) uslegalcups;
-            return new Volume(value, VolumeUnit.UsLegalCup);
+            return new Volume<T>(uslegalcups, VolumeUnit.UsLegalCup);
         }
         /// <summary>
-        ///     Get Volume from UsOunces.
+        ///     Get <see cref="Volume{T}" /> from UsOunces.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsOunces(QuantityValue usounces)
+        public static Volume<T> FromUsOunces(T usounces)
         {
-            double value = (double) usounces;
-            return new Volume(value, VolumeUnit.UsOunce);
+            return new Volume<T>(usounces, VolumeUnit.UsOunce);
         }
         /// <summary>
-        ///     Get Volume from UsPints.
+        ///     Get <see cref="Volume{T}" /> from UsPints.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsPints(QuantityValue uspints)
+        public static Volume<T> FromUsPints(T uspints)
         {
-            double value = (double) uspints;
-            return new Volume(value, VolumeUnit.UsPint);
+            return new Volume<T>(uspints, VolumeUnit.UsPint);
         }
         /// <summary>
-        ///     Get Volume from UsQuarts.
+        ///     Get <see cref="Volume{T}" /> from UsQuarts.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsQuarts(QuantityValue usquarts)
+        public static Volume<T> FromUsQuarts(T usquarts)
         {
-            double value = (double) usquarts;
-            return new Volume(value, VolumeUnit.UsQuart);
+            return new Volume<T>(usquarts, VolumeUnit.UsQuart);
         }
         /// <summary>
-        ///     Get Volume from UsTablespoons.
+        ///     Get <see cref="Volume{T}" /> from UsTablespoons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsTablespoons(QuantityValue ustablespoons)
+        public static Volume<T> FromUsTablespoons(T ustablespoons)
         {
-            double value = (double) ustablespoons;
-            return new Volume(value, VolumeUnit.UsTablespoon);
+            return new Volume<T>(ustablespoons, VolumeUnit.UsTablespoon);
         }
         /// <summary>
-        ///     Get Volume from UsTeaspoons.
+        ///     Get <see cref="Volume{T}" /> from UsTeaspoons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsTeaspoons(QuantityValue usteaspoons)
+        public static Volume<T> FromUsTeaspoons(T usteaspoons)
         {
-            double value = (double) usteaspoons;
-            return new Volume(value, VolumeUnit.UsTeaspoon);
+            return new Volume<T>(usteaspoons, VolumeUnit.UsTeaspoon);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumeUnit" /> to <see cref="Volume" />.
+        ///     Dynamically convert from value and unit enum <see cref="VolumeUnit" /> to <see cref="Volume{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Volume unit value.</returns>
-        public static Volume From(QuantityValue value, VolumeUnit fromUnit)
+        /// <returns><see cref="Volume{T}" /> unit value.</returns>
+        public static Volume<T> From(T value, VolumeUnit fromUnit)
         {
-            return new Volume((double)value, fromUnit);
+            return new Volume<T>(value, fromUnit);
         }
 
         #endregion
@@ -997,7 +944,7 @@ public static Volume From(QuantityValue value, VolumeUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static Volume Parse(string str)
+        public static Volume<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -1025,9 +972,9 @@ public static Volume Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static Volume Parse(string str, IFormatProvider? provider)
+        public static Volume<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<Volume, VolumeUnit>(
+            return QuantityParser.Default.Parse<T, Volume<T>, VolumeUnit>(
                 str,
                 provider,
                 From);
@@ -1041,7 +988,7 @@ public static Volume Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out Volume result)
+        public static bool TryParse(string? str, out Volume<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -1056,9 +1003,9 @@ public static bool TryParse(string? str, out Volume result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out Volume result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out Volume<T> result)
         {
-            return QuantityParser.Default.TryParse<Volume, VolumeUnit>(
+            return QuantityParser.Default.TryParse<T, Volume<T>, VolumeUnit>(
                 str,
                 provider,
                 From,
@@ -1120,45 +1067,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Volume operator -(Volume right)
+        public static Volume<T> operator -(Volume<T> right)
         {
-            return new Volume(-right.Value, right.Unit);
+            return new Volume<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="Volume"/> from adding two <see cref="Volume"/>.</summary>
-        public static Volume operator +(Volume left, Volume right)
+        /// <summary>Get <see cref="Volume{T}"/> from adding two <see cref="Volume{T}"/>.</summary>
+        public static Volume<T> operator +(Volume<T> left, Volume<T> right)
         {
-            return new Volume(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new Volume<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Volume"/> from subtracting two <see cref="Volume"/>.</summary>
-        public static Volume operator -(Volume left, Volume right)
+        /// <summary>Get <see cref="Volume{T}"/> from subtracting two <see cref="Volume{T}"/>.</summary>
+        public static Volume<T> operator -(Volume<T> left, Volume<T> right)
         {
-            return new Volume(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new Volume<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Volume"/> from multiplying value and <see cref="Volume"/>.</summary>
-        public static Volume operator *(double left, Volume right)
+        /// <summary>Get <see cref="Volume{T}"/> from multiplying value and <see cref="Volume{T}"/>.</summary>
+        public static Volume<T> operator *(T left, Volume<T> right)
         {
-            return new Volume(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new Volume<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="Volume"/> from multiplying value and <see cref="Volume"/>.</summary>
-        public static Volume operator *(Volume left, double right)
+        /// <summary>Get <see cref="Volume{T}"/> from multiplying value and <see cref="Volume{T}"/>.</summary>
+        public static Volume<T> operator *(Volume<T> left, T right)
         {
-            return new Volume(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new Volume<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="Volume"/> from dividing <see cref="Volume"/> by value.</summary>
-        public static Volume operator /(Volume left, double right)
+        /// <summary>Get <see cref="Volume{T}"/> from dividing <see cref="Volume{T}"/> by value.</summary>
+        public static Volume<T> operator /(Volume<T> left, T right)
         {
-            return new Volume(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new Volume<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="Volume"/> by <see cref="Volume"/>.</summary>
-        public static double operator /(Volume left, Volume right)
+        /// <summary>Get ratio value from dividing <see cref="Volume{T}"/> by <see cref="Volume{T}"/>.</summary>
+        public static T operator /(Volume<T> left, Volume<T> right)
         {
-            return left.CubicMeters / right.CubicMeters;
+            return CompiledLambdas.Divide(left.CubicMeters, right.CubicMeters);
         }
 
         #endregion
@@ -1166,39 +1118,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(Volume left, Volume right)
+        public static bool operator <=(Volume<T> left, Volume<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(Volume left, Volume right)
+        public static bool operator >=(Volume<T> left, Volume<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(Volume left, Volume right)
+        public static bool operator <(Volume<T> left, Volume<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(Volume left, Volume right)
+        public static bool operator >(Volume<T> left, Volume<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Volume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(Volume left, Volume right)
+        /// <remarks>Consider using <see cref="Equals(Volume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(Volume<T> left, Volume<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(Volume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(Volume left, Volume right)
+        /// <remarks>Consider using <see cref="Equals(Volume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(Volume<T> left, Volume<T> right)
         {
             return !(left == right);
         }
@@ -1207,37 +1159,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is Volume objVolume)) throw new ArgumentException("Expected type Volume.", nameof(obj));
+            if(!(obj is Volume<T> objVolume)) throw new ArgumentException("Expected type Volume.", nameof(obj));
 
             return CompareTo(objVolume);
         }
 
         /// <inheritdoc />
-        public int CompareTo(Volume other)
+        public int CompareTo(Volume<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Volume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(Volume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is Volume objVolume))
+            if(obj is null || !(obj is Volume<T> objVolume))
                 return false;
 
             return Equals(objVolume);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(Volume, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(Volume other)
+        /// <remarks>Consider using <see cref="Equals(Volume{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(Volume<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another Volume within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="Volume{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1275,21 +1227,19 @@ public bool Equals(Volume other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(Volume other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(Volume<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current Volume.</returns>
+        /// <returns>A hash code for the current <see cref="Volume{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1303,17 +1253,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumeUnit unit)
+        public T As(VolumeUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1333,17 +1283,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is VolumeUnit unitAsVolumeUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeUnit)} is supported.", nameof(unit));
 
-            return As(unitAsVolumeUnit);
+            var asValue = As(unitAsVolumeUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<VolumeUnit>.As(VolumeUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this Volume to another Volume with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="Volume{T}" /> to another <see cref="Volume{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A Volume with the specified unit.</returns>
-        public Volume ToUnit(VolumeUnit unit)
+        /// <returns>A <see cref="Volume{T}" /> with the specified unit.</returns>
+        public Volume<T> ToUnit(VolumeUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new Volume(convertedValue, unit);
+            return new Volume<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1356,7 +1311,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public Volume ToUnit(UnitSystem unitSystem)
+        public Volume<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1376,69 +1331,75 @@ public Volume ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumeUnit> IQuantity<VolumeUnit>.ToUnit(VolumeUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<VolumeUnit, T> IQuantityT<VolumeUnit, T>.ToUnit(VolumeUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<VolumeUnit> IQuantity<VolumeUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<VolumeUnit, T> IQuantityT<VolumeUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case VolumeUnit.AcreFoot: return _value/0.000810714;
-                case VolumeUnit.AuTablespoon: return _value*2e-5;
-                case VolumeUnit.BoardFoot: return _value*2.3597372158e-3;
-                case VolumeUnit.Centiliter: return (_value/1e3) * 1e-2d;
-                case VolumeUnit.CubicCentimeter: return _value/1e6;
-                case VolumeUnit.CubicDecimeter: return _value/1e3;
-                case VolumeUnit.CubicFoot: return _value*0.0283168;
-                case VolumeUnit.CubicHectometer: return _value*1e6;
-                case VolumeUnit.CubicInch: return _value*1.6387*1e-5;
-                case VolumeUnit.CubicKilometer: return _value*1e9;
-                case VolumeUnit.CubicMeter: return _value;
-                case VolumeUnit.CubicMicrometer: return _value/1e18;
-                case VolumeUnit.CubicMile: return _value*4.16818182544058e9;
-                case VolumeUnit.CubicMillimeter: return _value/1e9;
-                case VolumeUnit.CubicYard: return _value*0.764554858;
-                case VolumeUnit.DecausGallon: return (_value*0.00378541) * 1e1d;
-                case VolumeUnit.Deciliter: return (_value/1e3) * 1e-1d;
-                case VolumeUnit.DeciusGallon: return (_value*0.00378541) * 1e-1d;
-                case VolumeUnit.HectocubicFoot: return (_value*0.0283168) * 1e2d;
-                case VolumeUnit.HectocubicMeter: return (_value) * 1e2d;
-                case VolumeUnit.Hectoliter: return (_value/1e3) * 1e2d;
-                case VolumeUnit.HectousGallon: return (_value*0.00378541) * 1e2d;
-                case VolumeUnit.ImperialBeerBarrel: return _value*0.16365924;
-                case VolumeUnit.ImperialGallon: return _value*0.00454609000000181429905810072407;
-                case VolumeUnit.ImperialOunce: return _value*2.8413062499962901241875439064617e-5;
-                case VolumeUnit.ImperialPint: return _value * 5.6826125e-4;
-                case VolumeUnit.KilocubicFoot: return (_value*0.0283168) * 1e3d;
-                case VolumeUnit.KilocubicMeter: return (_value) * 1e3d;
-                case VolumeUnit.KiloimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e3d;
-                case VolumeUnit.Kiloliter: return (_value/1e3) * 1e3d;
-                case VolumeUnit.KilousGallon: return (_value*0.00378541) * 1e3d;
-                case VolumeUnit.Liter: return _value/1e3;
-                case VolumeUnit.MegacubicFoot: return (_value*0.0283168) * 1e6d;
-                case VolumeUnit.MegaimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e6d;
-                case VolumeUnit.Megaliter: return (_value/1e3) * 1e6d;
-                case VolumeUnit.MegausGallon: return (_value*0.00378541) * 1e6d;
-                case VolumeUnit.MetricCup: return _value*0.00025;
-                case VolumeUnit.MetricTeaspoon: return _value*0.5e-5;
-                case VolumeUnit.Microliter: return (_value/1e3) * 1e-6d;
-                case VolumeUnit.Milliliter: return (_value/1e3) * 1e-3d;
-                case VolumeUnit.OilBarrel: return _value*0.158987294928;
-                case VolumeUnit.UkTablespoon: return _value*1.5e-5;
-                case VolumeUnit.UsBeerBarrel: return _value*0.1173477658;
-                case VolumeUnit.UsCustomaryCup: return _value*0.0002365882365;
-                case VolumeUnit.UsGallon: return _value*0.00378541;
-                case VolumeUnit.UsLegalCup: return _value*0.00024;
-                case VolumeUnit.UsOunce: return _value*2.957352956253760505068307980135e-5;
-                case VolumeUnit.UsPint: return _value*4.73176473e-4;
-                case VolumeUnit.UsQuart: return _value*9.46352946e-4;
-                case VolumeUnit.UsTablespoon: return _value*1.478676478125e-5;
-                case VolumeUnit.UsTeaspoon: return _value*4.92892159375e-6;
+                case VolumeUnit.AcreFoot: return Value/0.000810714;
+                case VolumeUnit.AuTablespoon: return Value*2e-5;
+                case VolumeUnit.BoardFoot: return Value*2.3597372158e-3;
+                case VolumeUnit.Centiliter: return (Value/1e3) * 1e-2d;
+                case VolumeUnit.CubicCentimeter: return Value/1e6;
+                case VolumeUnit.CubicDecimeter: return Value/1e3;
+                case VolumeUnit.CubicFoot: return Value*0.0283168;
+                case VolumeUnit.CubicHectometer: return Value*1e6;
+                case VolumeUnit.CubicInch: return Value*1.6387*1e-5;
+                case VolumeUnit.CubicKilometer: return Value*1e9;
+                case VolumeUnit.CubicMeter: return Value;
+                case VolumeUnit.CubicMicrometer: return Value/1e18;
+                case VolumeUnit.CubicMile: return Value*4.16818182544058e9;
+                case VolumeUnit.CubicMillimeter: return Value/1e9;
+                case VolumeUnit.CubicYard: return Value*0.764554858;
+                case VolumeUnit.DecausGallon: return (Value*0.00378541) * 1e1d;
+                case VolumeUnit.Deciliter: return (Value/1e3) * 1e-1d;
+                case VolumeUnit.DeciusGallon: return (Value*0.00378541) * 1e-1d;
+                case VolumeUnit.HectocubicFoot: return (Value*0.0283168) * 1e2d;
+                case VolumeUnit.HectocubicMeter: return (Value) * 1e2d;
+                case VolumeUnit.Hectoliter: return (Value/1e3) * 1e2d;
+                case VolumeUnit.HectousGallon: return (Value*0.00378541) * 1e2d;
+                case VolumeUnit.ImperialBeerBarrel: return Value*0.16365924;
+                case VolumeUnit.ImperialGallon: return Value*0.00454609000000181429905810072407;
+                case VolumeUnit.ImperialOunce: return Value*2.8413062499962901241875439064617e-5;
+                case VolumeUnit.ImperialPint: return Value * 5.6826125e-4;
+                case VolumeUnit.KilocubicFoot: return (Value*0.0283168) * 1e3d;
+                case VolumeUnit.KilocubicMeter: return (Value) * 1e3d;
+                case VolumeUnit.KiloimperialGallon: return (Value*0.00454609000000181429905810072407) * 1e3d;
+                case VolumeUnit.Kiloliter: return (Value/1e3) * 1e3d;
+                case VolumeUnit.KilousGallon: return (Value*0.00378541) * 1e3d;
+                case VolumeUnit.Liter: return Value/1e3;
+                case VolumeUnit.MegacubicFoot: return (Value*0.0283168) * 1e6d;
+                case VolumeUnit.MegaimperialGallon: return (Value*0.00454609000000181429905810072407) * 1e6d;
+                case VolumeUnit.Megaliter: return (Value/1e3) * 1e6d;
+                case VolumeUnit.MegausGallon: return (Value*0.00378541) * 1e6d;
+                case VolumeUnit.MetricCup: return Value*0.00025;
+                case VolumeUnit.MetricTeaspoon: return Value*0.5e-5;
+                case VolumeUnit.Microliter: return (Value/1e3) * 1e-6d;
+                case VolumeUnit.Milliliter: return (Value/1e3) * 1e-3d;
+                case VolumeUnit.OilBarrel: return Value*0.158987294928;
+                case VolumeUnit.UkTablespoon: return Value*1.5e-5;
+                case VolumeUnit.UsBeerBarrel: return Value*0.1173477658;
+                case VolumeUnit.UsCustomaryCup: return Value*0.0002365882365;
+                case VolumeUnit.UsGallon: return Value*0.00378541;
+                case VolumeUnit.UsLegalCup: return Value*0.00024;
+                case VolumeUnit.UsOunce: return Value*2.957352956253760505068307980135e-5;
+                case VolumeUnit.UsPint: return Value*4.73176473e-4;
+                case VolumeUnit.UsQuart: return Value*9.46352946e-4;
+                case VolumeUnit.UsTablespoon: return Value*1.478676478125e-5;
+                case VolumeUnit.UsTeaspoon: return Value*4.92892159375e-6;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1449,16 +1410,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal Volume ToBaseUnit()
+        internal Volume<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new Volume(baseUnitValue, BaseUnit);
+            return new Volume<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(VolumeUnit unit)
+        private T GetValueAs(VolumeUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1611,57 +1572,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Volume)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Volume<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Volume)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Volume<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(Volume)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(Volume<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1671,33 +1632,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(Volume))
+            if(conversionType == typeof(Volume<T>))
                 return this;
             else if(conversionType == typeof(VolumeUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return Volume.QuantityType;
+                return Volume<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return Volume.Info;
+                return Volume<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return Volume.BaseDimensions;
+                return Volume<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(Volume)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(Volume<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
index 482aca1587..b51f87f739 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
@@ -37,13 +37,9 @@ namespace UnitsNet
     /// <remarks>
     ///     https://en.wikipedia.org/wiki/Concentration#Volume_concentration
     /// </remarks>
-    public partial struct VolumeConcentration : IQuantity<VolumeConcentrationUnit>, IEquatable<VolumeConcentration>, IComparable, IComparable<VolumeConcentration>, IConvertible, IFormattable
+    public partial struct VolumeConcentration<T> : IQuantityT<VolumeConcentrationUnit, T>, IEquatable<VolumeConcentration<T>>, IComparable, IComparable<VolumeConcentration<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -85,12 +81,12 @@ static VolumeConcentration()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public VolumeConcentration(double value, VolumeConcentrationUnit unit)
+        public VolumeConcentration(T value, VolumeConcentrationUnit unit)
         {
             if(unit == VolumeConcentrationUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -102,14 +98,14 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VolumeConcentration(double value, UnitSystem unitSystem)
+        public VolumeConcentration(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -124,19 +120,19 @@ public VolumeConcentration(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of VolumeConcentration, which is DecimalFraction. All conversions go via this value.
+        ///     The base unit of <see cref="VolumeConcentration{T}" />, which is DecimalFraction. All conversions go via this value.
         /// </summary>
         public static VolumeConcentrationUnit BaseUnit { get; } = VolumeConcentrationUnit.DecimalFraction;
 
         /// <summary>
-        /// Represents the largest possible value of VolumeConcentration
+        /// Represents the largest possible value of <see cref="VolumeConcentration{T}" />
         /// </summary>
-        public static VolumeConcentration MaxValue { get; } = new VolumeConcentration(double.MaxValue, BaseUnit);
+        public static VolumeConcentration<T> MaxValue { get; } = new VolumeConcentration<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of VolumeConcentration
+        /// Represents the smallest possible value of <see cref="VolumeConcentration{T}" />
         /// </summary>
-        public static VolumeConcentration MinValue { get; } = new VolumeConcentration(double.MinValue, BaseUnit);
+        public static VolumeConcentration<T> MinValue { get; } = new VolumeConcentration<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -145,14 +141,14 @@ public VolumeConcentration(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.VolumeConcentration;
 
         /// <summary>
-        ///     All units of measurement for the VolumeConcentration quantity.
+        ///     All units of measurement for the <see cref="VolumeConcentration{T}" /> quantity.
         /// </summary>
         public static VolumeConcentrationUnit[] Units { get; } = Enum.GetValues(typeof(VolumeConcentrationUnit)).Cast<VolumeConcentrationUnit>().Except(new VolumeConcentrationUnit[]{ VolumeConcentrationUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit DecimalFraction.
         /// </summary>
-        public static VolumeConcentration Zero { get; } = new VolumeConcentration(0, BaseUnit);
+        public static VolumeConcentration<T> Zero { get; } = new VolumeConcentration<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -161,7 +157,9 @@ public VolumeConcentration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -177,116 +175,116 @@ public VolumeConcentration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => VolumeConcentration.QuantityType;
+        public QuantityType Type => VolumeConcentration<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => VolumeConcentration.BaseDimensions;
+        public BaseDimensions Dimensions => VolumeConcentration<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get VolumeConcentration in CentilitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in CentilitersPerLiter.
         /// </summary>
-        public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentilitersPerLiter);
+        public T CentilitersPerLiter => As(VolumeConcentrationUnit.CentilitersPerLiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in CentilitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in CentilitersPerMililiter.
         /// </summary>
-        public double CentilitersPerMililiter => As(VolumeConcentrationUnit.CentilitersPerMililiter);
+        public T CentilitersPerMililiter => As(VolumeConcentrationUnit.CentilitersPerMililiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in DecilitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in DecilitersPerLiter.
         /// </summary>
-        public double DecilitersPerLiter => As(VolumeConcentrationUnit.DecilitersPerLiter);
+        public T DecilitersPerLiter => As(VolumeConcentrationUnit.DecilitersPerLiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in DecilitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in DecilitersPerMililiter.
         /// </summary>
-        public double DecilitersPerMililiter => As(VolumeConcentrationUnit.DecilitersPerMililiter);
+        public T DecilitersPerMililiter => As(VolumeConcentrationUnit.DecilitersPerMililiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in DecimalFractions.
+        ///     Get <see cref="VolumeConcentration{T}" /> in DecimalFractions.
         /// </summary>
-        public double DecimalFractions => As(VolumeConcentrationUnit.DecimalFraction);
+        public T DecimalFractions => As(VolumeConcentrationUnit.DecimalFraction);
 
         /// <summary>
-        ///     Get VolumeConcentration in LitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in LitersPerLiter.
         /// </summary>
-        public double LitersPerLiter => As(VolumeConcentrationUnit.LitersPerLiter);
+        public T LitersPerLiter => As(VolumeConcentrationUnit.LitersPerLiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in LitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in LitersPerMililiter.
         /// </summary>
-        public double LitersPerMililiter => As(VolumeConcentrationUnit.LitersPerMililiter);
+        public T LitersPerMililiter => As(VolumeConcentrationUnit.LitersPerMililiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in MicrolitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in MicrolitersPerLiter.
         /// </summary>
-        public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicrolitersPerLiter);
+        public T MicrolitersPerLiter => As(VolumeConcentrationUnit.MicrolitersPerLiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in MicrolitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in MicrolitersPerMililiter.
         /// </summary>
-        public double MicrolitersPerMililiter => As(VolumeConcentrationUnit.MicrolitersPerMililiter);
+        public T MicrolitersPerMililiter => As(VolumeConcentrationUnit.MicrolitersPerMililiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in MillilitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in MillilitersPerLiter.
         /// </summary>
-        public double MillilitersPerLiter => As(VolumeConcentrationUnit.MillilitersPerLiter);
+        public T MillilitersPerLiter => As(VolumeConcentrationUnit.MillilitersPerLiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in MillilitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in MillilitersPerMililiter.
         /// </summary>
-        public double MillilitersPerMililiter => As(VolumeConcentrationUnit.MillilitersPerMililiter);
+        public T MillilitersPerMililiter => As(VolumeConcentrationUnit.MillilitersPerMililiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in NanolitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in NanolitersPerLiter.
         /// </summary>
-        public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanolitersPerLiter);
+        public T NanolitersPerLiter => As(VolumeConcentrationUnit.NanolitersPerLiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in NanolitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in NanolitersPerMililiter.
         /// </summary>
-        public double NanolitersPerMililiter => As(VolumeConcentrationUnit.NanolitersPerMililiter);
+        public T NanolitersPerMililiter => As(VolumeConcentrationUnit.NanolitersPerMililiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in PartsPerBillion.
+        ///     Get <see cref="VolumeConcentration{T}" /> in PartsPerBillion.
         /// </summary>
-        public double PartsPerBillion => As(VolumeConcentrationUnit.PartPerBillion);
+        public T PartsPerBillion => As(VolumeConcentrationUnit.PartPerBillion);
 
         /// <summary>
-        ///     Get VolumeConcentration in PartsPerMillion.
+        ///     Get <see cref="VolumeConcentration{T}" /> in PartsPerMillion.
         /// </summary>
-        public double PartsPerMillion => As(VolumeConcentrationUnit.PartPerMillion);
+        public T PartsPerMillion => As(VolumeConcentrationUnit.PartPerMillion);
 
         /// <summary>
-        ///     Get VolumeConcentration in PartsPerThousand.
+        ///     Get <see cref="VolumeConcentration{T}" /> in PartsPerThousand.
         /// </summary>
-        public double PartsPerThousand => As(VolumeConcentrationUnit.PartPerThousand);
+        public T PartsPerThousand => As(VolumeConcentrationUnit.PartPerThousand);
 
         /// <summary>
-        ///     Get VolumeConcentration in PartsPerTrillion.
+        ///     Get <see cref="VolumeConcentration{T}" /> in PartsPerTrillion.
         /// </summary>
-        public double PartsPerTrillion => As(VolumeConcentrationUnit.PartPerTrillion);
+        public T PartsPerTrillion => As(VolumeConcentrationUnit.PartPerTrillion);
 
         /// <summary>
-        ///     Get VolumeConcentration in Percent.
+        ///     Get <see cref="VolumeConcentration{T}" /> in Percent.
         /// </summary>
-        public double Percent => As(VolumeConcentrationUnit.Percent);
+        public T Percent => As(VolumeConcentrationUnit.Percent);
 
         /// <summary>
-        ///     Get VolumeConcentration in PicolitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in PicolitersPerLiter.
         /// </summary>
-        public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicolitersPerLiter);
+        public T PicolitersPerLiter => As(VolumeConcentrationUnit.PicolitersPerLiter);
 
         /// <summary>
-        ///     Get VolumeConcentration in PicolitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> in PicolitersPerMililiter.
         /// </summary>
-        public double PicolitersPerMililiter => As(VolumeConcentrationUnit.PicolitersPerMililiter);
+        public T PicolitersPerMililiter => As(VolumeConcentrationUnit.PicolitersPerMililiter);
 
         #endregion
 
@@ -318,195 +316,175 @@ public static string GetAbbreviation(VolumeConcentrationUnit unit, IFormatProvid
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get VolumeConcentration from CentilitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from CentilitersPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromCentilitersPerLiter(QuantityValue centilitersperliter)
+        public static VolumeConcentration<T> FromCentilitersPerLiter(T centilitersperliter)
         {
-            double value = (double) centilitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter);
+            return new VolumeConcentration<T>(centilitersperliter, VolumeConcentrationUnit.CentilitersPerLiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from CentilitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from CentilitersPerMililiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromCentilitersPerMililiter(QuantityValue centiliterspermililiter)
+        public static VolumeConcentration<T> FromCentilitersPerMililiter(T centiliterspermililiter)
         {
-            double value = (double) centiliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter);
+            return new VolumeConcentration<T>(centiliterspermililiter, VolumeConcentrationUnit.CentilitersPerMililiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from DecilitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from DecilitersPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecilitersPerLiter(QuantityValue decilitersperliter)
+        public static VolumeConcentration<T> FromDecilitersPerLiter(T decilitersperliter)
         {
-            double value = (double) decilitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter);
+            return new VolumeConcentration<T>(decilitersperliter, VolumeConcentrationUnit.DecilitersPerLiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from DecilitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from DecilitersPerMililiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecilitersPerMililiter(QuantityValue deciliterspermililiter)
+        public static VolumeConcentration<T> FromDecilitersPerMililiter(T deciliterspermililiter)
         {
-            double value = (double) deciliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter);
+            return new VolumeConcentration<T>(deciliterspermililiter, VolumeConcentrationUnit.DecilitersPerMililiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from DecimalFractions.
+        ///     Get <see cref="VolumeConcentration{T}" /> from DecimalFractions.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecimalFractions(QuantityValue decimalfractions)
+        public static VolumeConcentration<T> FromDecimalFractions(T decimalfractions)
         {
-            double value = (double) decimalfractions;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction);
+            return new VolumeConcentration<T>(decimalfractions, VolumeConcentrationUnit.DecimalFraction);
         }
         /// <summary>
-        ///     Get VolumeConcentration from LitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from LitersPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromLitersPerLiter(QuantityValue litersperliter)
+        public static VolumeConcentration<T> FromLitersPerLiter(T litersperliter)
         {
-            double value = (double) litersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter);
+            return new VolumeConcentration<T>(litersperliter, VolumeConcentrationUnit.LitersPerLiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from LitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from LitersPerMililiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromLitersPerMililiter(QuantityValue literspermililiter)
+        public static VolumeConcentration<T> FromLitersPerMililiter(T literspermililiter)
         {
-            double value = (double) literspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter);
+            return new VolumeConcentration<T>(literspermililiter, VolumeConcentrationUnit.LitersPerMililiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from MicrolitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from MicrolitersPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMicrolitersPerLiter(QuantityValue microlitersperliter)
+        public static VolumeConcentration<T> FromMicrolitersPerLiter(T microlitersperliter)
         {
-            double value = (double) microlitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter);
+            return new VolumeConcentration<T>(microlitersperliter, VolumeConcentrationUnit.MicrolitersPerLiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from MicrolitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from MicrolitersPerMililiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMicrolitersPerMililiter(QuantityValue microliterspermililiter)
+        public static VolumeConcentration<T> FromMicrolitersPerMililiter(T microliterspermililiter)
         {
-            double value = (double) microliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter);
+            return new VolumeConcentration<T>(microliterspermililiter, VolumeConcentrationUnit.MicrolitersPerMililiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from MillilitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from MillilitersPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMillilitersPerLiter(QuantityValue millilitersperliter)
+        public static VolumeConcentration<T> FromMillilitersPerLiter(T millilitersperliter)
         {
-            double value = (double) millilitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter);
+            return new VolumeConcentration<T>(millilitersperliter, VolumeConcentrationUnit.MillilitersPerLiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from MillilitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from MillilitersPerMililiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMillilitersPerMililiter(QuantityValue milliliterspermililiter)
+        public static VolumeConcentration<T> FromMillilitersPerMililiter(T milliliterspermililiter)
         {
-            double value = (double) milliliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter);
+            return new VolumeConcentration<T>(milliliterspermililiter, VolumeConcentrationUnit.MillilitersPerMililiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from NanolitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from NanolitersPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromNanolitersPerLiter(QuantityValue nanolitersperliter)
+        public static VolumeConcentration<T> FromNanolitersPerLiter(T nanolitersperliter)
         {
-            double value = (double) nanolitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter);
+            return new VolumeConcentration<T>(nanolitersperliter, VolumeConcentrationUnit.NanolitersPerLiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from NanolitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from NanolitersPerMililiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromNanolitersPerMililiter(QuantityValue nanoliterspermililiter)
+        public static VolumeConcentration<T> FromNanolitersPerMililiter(T nanoliterspermililiter)
         {
-            double value = (double) nanoliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter);
+            return new VolumeConcentration<T>(nanoliterspermililiter, VolumeConcentrationUnit.NanolitersPerMililiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from PartsPerBillion.
+        ///     Get <see cref="VolumeConcentration{T}" /> from PartsPerBillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerBillion(QuantityValue partsperbillion)
+        public static VolumeConcentration<T> FromPartsPerBillion(T partsperbillion)
         {
-            double value = (double) partsperbillion;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion);
+            return new VolumeConcentration<T>(partsperbillion, VolumeConcentrationUnit.PartPerBillion);
         }
         /// <summary>
-        ///     Get VolumeConcentration from PartsPerMillion.
+        ///     Get <see cref="VolumeConcentration{T}" /> from PartsPerMillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerMillion(QuantityValue partspermillion)
+        public static VolumeConcentration<T> FromPartsPerMillion(T partspermillion)
         {
-            double value = (double) partspermillion;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion);
+            return new VolumeConcentration<T>(partspermillion, VolumeConcentrationUnit.PartPerMillion);
         }
         /// <summary>
-        ///     Get VolumeConcentration from PartsPerThousand.
+        ///     Get <see cref="VolumeConcentration{T}" /> from PartsPerThousand.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerThousand(QuantityValue partsperthousand)
+        public static VolumeConcentration<T> FromPartsPerThousand(T partsperthousand)
         {
-            double value = (double) partsperthousand;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand);
+            return new VolumeConcentration<T>(partsperthousand, VolumeConcentrationUnit.PartPerThousand);
         }
         /// <summary>
-        ///     Get VolumeConcentration from PartsPerTrillion.
+        ///     Get <see cref="VolumeConcentration{T}" /> from PartsPerTrillion.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerTrillion(QuantityValue partspertrillion)
+        public static VolumeConcentration<T> FromPartsPerTrillion(T partspertrillion)
         {
-            double value = (double) partspertrillion;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion);
+            return new VolumeConcentration<T>(partspertrillion, VolumeConcentrationUnit.PartPerTrillion);
         }
         /// <summary>
-        ///     Get VolumeConcentration from Percent.
+        ///     Get <see cref="VolumeConcentration{T}" /> from Percent.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPercent(QuantityValue percent)
+        public static VolumeConcentration<T> FromPercent(T percent)
         {
-            double value = (double) percent;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.Percent);
+            return new VolumeConcentration<T>(percent, VolumeConcentrationUnit.Percent);
         }
         /// <summary>
-        ///     Get VolumeConcentration from PicolitersPerLiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from PicolitersPerLiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPicolitersPerLiter(QuantityValue picolitersperliter)
+        public static VolumeConcentration<T> FromPicolitersPerLiter(T picolitersperliter)
         {
-            double value = (double) picolitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter);
+            return new VolumeConcentration<T>(picolitersperliter, VolumeConcentrationUnit.PicolitersPerLiter);
         }
         /// <summary>
-        ///     Get VolumeConcentration from PicolitersPerMililiter.
+        ///     Get <see cref="VolumeConcentration{T}" /> from PicolitersPerMililiter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPicolitersPerMililiter(QuantityValue picoliterspermililiter)
+        public static VolumeConcentration<T> FromPicolitersPerMililiter(T picoliterspermililiter)
         {
-            double value = (double) picoliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter);
+            return new VolumeConcentration<T>(picoliterspermililiter, VolumeConcentrationUnit.PicolitersPerMililiter);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumeConcentrationUnit" /> to <see cref="VolumeConcentration" />.
+        ///     Dynamically convert from value and unit enum <see cref="VolumeConcentrationUnit" /> to <see cref="VolumeConcentration{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumeConcentration unit value.</returns>
-        public static VolumeConcentration From(QuantityValue value, VolumeConcentrationUnit fromUnit)
+        /// <returns><see cref="VolumeConcentration{T}" /> unit value.</returns>
+        public static VolumeConcentration<T> From(T value, VolumeConcentrationUnit fromUnit)
         {
-            return new VolumeConcentration((double)value, fromUnit);
+            return new VolumeConcentration<T>(value, fromUnit);
         }
 
         #endregion
@@ -535,7 +513,7 @@ public static VolumeConcentration From(QuantityValue value, VolumeConcentrationU
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static VolumeConcentration Parse(string str)
+        public static VolumeConcentration<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -563,9 +541,9 @@ public static VolumeConcentration Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static VolumeConcentration Parse(string str, IFormatProvider? provider)
+        public static VolumeConcentration<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<VolumeConcentration, VolumeConcentrationUnit>(
+            return QuantityParser.Default.Parse<T, VolumeConcentration<T>, VolumeConcentrationUnit>(
                 str,
                 provider,
                 From);
@@ -579,7 +557,7 @@ public static VolumeConcentration Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out VolumeConcentration result)
+        public static bool TryParse(string? str, out VolumeConcentration<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -594,9 +572,9 @@ public static bool TryParse(string? str, out VolumeConcentration result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out VolumeConcentration result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out VolumeConcentration<T> result)
         {
-            return QuantityParser.Default.TryParse<VolumeConcentration, VolumeConcentrationUnit>(
+            return QuantityParser.Default.TryParse<T, VolumeConcentration<T>, VolumeConcentrationUnit>(
                 str,
                 provider,
                 From,
@@ -658,45 +636,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static VolumeConcentration operator -(VolumeConcentration right)
+        public static VolumeConcentration<T> operator -(VolumeConcentration<T> right)
         {
-            return new VolumeConcentration(-right.Value, right.Unit);
+            return new VolumeConcentration<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeConcentration"/> from adding two <see cref="VolumeConcentration"/>.</summary>
-        public static VolumeConcentration operator +(VolumeConcentration left, VolumeConcentration right)
+        /// <summary>Get <see cref="VolumeConcentration{T}"/> from adding two <see cref="VolumeConcentration{T}"/>.</summary>
+        public static VolumeConcentration<T> operator +(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
-            return new VolumeConcentration(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new VolumeConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeConcentration"/> from subtracting two <see cref="VolumeConcentration"/>.</summary>
-        public static VolumeConcentration operator -(VolumeConcentration left, VolumeConcentration right)
+        /// <summary>Get <see cref="VolumeConcentration{T}"/> from subtracting two <see cref="VolumeConcentration{T}"/>.</summary>
+        public static VolumeConcentration<T> operator -(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
-            return new VolumeConcentration(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new VolumeConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeConcentration"/> from multiplying value and <see cref="VolumeConcentration"/>.</summary>
-        public static VolumeConcentration operator *(double left, VolumeConcentration right)
+        /// <summary>Get <see cref="VolumeConcentration{T}"/> from multiplying value and <see cref="VolumeConcentration{T}"/>.</summary>
+        public static VolumeConcentration<T> operator *(T left, VolumeConcentration<T> right)
         {
-            return new VolumeConcentration(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new VolumeConcentration<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeConcentration"/> from multiplying value and <see cref="VolumeConcentration"/>.</summary>
-        public static VolumeConcentration operator *(VolumeConcentration left, double right)
+        /// <summary>Get <see cref="VolumeConcentration{T}"/> from multiplying value and <see cref="VolumeConcentration{T}"/>.</summary>
+        public static VolumeConcentration<T> operator *(VolumeConcentration<T> left, T right)
         {
-            return new VolumeConcentration(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new VolumeConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeConcentration"/> from dividing <see cref="VolumeConcentration"/> by value.</summary>
-        public static VolumeConcentration operator /(VolumeConcentration left, double right)
+        /// <summary>Get <see cref="VolumeConcentration{T}"/> from dividing <see cref="VolumeConcentration{T}"/> by value.</summary>
+        public static VolumeConcentration<T> operator /(VolumeConcentration<T> left, T right)
         {
-            return new VolumeConcentration(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new VolumeConcentration<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="VolumeConcentration"/> by <see cref="VolumeConcentration"/>.</summary>
-        public static double operator /(VolumeConcentration left, VolumeConcentration right)
+        /// <summary>Get ratio value from dividing <see cref="VolumeConcentration{T}"/> by <see cref="VolumeConcentration{T}"/>.</summary>
+        public static T operator /(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
-            return left.DecimalFractions / right.DecimalFractions;
+            return CompiledLambdas.Divide(left.DecimalFractions, right.DecimalFractions);
         }
 
         #endregion
@@ -704,39 +687,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(VolumeConcentration left, VolumeConcentration right)
+        public static bool operator <=(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(VolumeConcentration left, VolumeConcentration right)
+        public static bool operator >=(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(VolumeConcentration left, VolumeConcentration right)
+        public static bool operator <(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(VolumeConcentration left, VolumeConcentration right)
+        public static bool operator >(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VolumeConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(VolumeConcentration left, VolumeConcentration right)
+        /// <remarks>Consider using <see cref="Equals(VolumeConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VolumeConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(VolumeConcentration left, VolumeConcentration right)
+        /// <remarks>Consider using <see cref="Equals(VolumeConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(VolumeConcentration<T> left, VolumeConcentration<T> right)
         {
             return !(left == right);
         }
@@ -745,37 +728,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is VolumeConcentration objVolumeConcentration)) throw new ArgumentException("Expected type VolumeConcentration.", nameof(obj));
+            if(!(obj is VolumeConcentration<T> objVolumeConcentration)) throw new ArgumentException("Expected type VolumeConcentration.", nameof(obj));
 
             return CompareTo(objVolumeConcentration);
         }
 
         /// <inheritdoc />
-        public int CompareTo(VolumeConcentration other)
+        public int CompareTo(VolumeConcentration<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VolumeConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(VolumeConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is VolumeConcentration objVolumeConcentration))
+            if(obj is null || !(obj is VolumeConcentration<T> objVolumeConcentration))
                 return false;
 
             return Equals(objVolumeConcentration);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VolumeConcentration, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(VolumeConcentration other)
+        /// <remarks>Consider using <see cref="Equals(VolumeConcentration{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(VolumeConcentration<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another VolumeConcentration within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="VolumeConcentration{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -813,21 +796,19 @@ public bool Equals(VolumeConcentration other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(VolumeConcentration other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(VolumeConcentration<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current VolumeConcentration.</returns>
+        /// <returns>A hash code for the current <see cref="VolumeConcentration{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -841,17 +822,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumeConcentrationUnit unit)
+        public T As(VolumeConcentrationUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -871,17 +852,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is VolumeConcentrationUnit unitAsVolumeConcentrationUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeConcentrationUnit)} is supported.", nameof(unit));
 
-            return As(unitAsVolumeConcentrationUnit);
+            var asValue = As(unitAsVolumeConcentrationUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<VolumeConcentrationUnit>.As(VolumeConcentrationUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this VolumeConcentration to another VolumeConcentration with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="VolumeConcentration{T}" /> to another <see cref="VolumeConcentration{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A VolumeConcentration with the specified unit.</returns>
-        public VolumeConcentration ToUnit(VolumeConcentrationUnit unit)
+        /// <returns>A <see cref="VolumeConcentration{T}" /> with the specified unit.</returns>
+        public VolumeConcentration<T> ToUnit(VolumeConcentrationUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new VolumeConcentration(convertedValue, unit);
+            return new VolumeConcentration<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -894,7 +880,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public VolumeConcentration ToUnit(UnitSystem unitSystem)
+        public VolumeConcentration<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -914,38 +900,44 @@ public VolumeConcentration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumeConcentrationUnit> IQuantity<VolumeConcentrationUnit>.ToUnit(VolumeConcentrationUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<VolumeConcentrationUnit, T> IQuantityT<VolumeConcentrationUnit, T>.ToUnit(VolumeConcentrationUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<VolumeConcentrationUnit> IQuantity<VolumeConcentrationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<VolumeConcentrationUnit, T> IQuantityT<VolumeConcentrationUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case VolumeConcentrationUnit.CentilitersPerLiter: return (_value) * 1e-2d;
-                case VolumeConcentrationUnit.CentilitersPerMililiter: return (_value/1e-3) * 1e-2d;
-                case VolumeConcentrationUnit.DecilitersPerLiter: return (_value) * 1e-1d;
-                case VolumeConcentrationUnit.DecilitersPerMililiter: return (_value/1e-3) * 1e-1d;
-                case VolumeConcentrationUnit.DecimalFraction: return _value;
-                case VolumeConcentrationUnit.LitersPerLiter: return _value;
-                case VolumeConcentrationUnit.LitersPerMililiter: return _value/1e-3;
-                case VolumeConcentrationUnit.MicrolitersPerLiter: return (_value) * 1e-6d;
-                case VolumeConcentrationUnit.MicrolitersPerMililiter: return (_value/1e-3) * 1e-6d;
-                case VolumeConcentrationUnit.MillilitersPerLiter: return (_value) * 1e-3d;
-                case VolumeConcentrationUnit.MillilitersPerMililiter: return (_value/1e-3) * 1e-3d;
-                case VolumeConcentrationUnit.NanolitersPerLiter: return (_value) * 1e-9d;
-                case VolumeConcentrationUnit.NanolitersPerMililiter: return (_value/1e-3) * 1e-9d;
-                case VolumeConcentrationUnit.PartPerBillion: return _value/1e9;
-                case VolumeConcentrationUnit.PartPerMillion: return _value/1e6;
-                case VolumeConcentrationUnit.PartPerThousand: return _value/1e3;
-                case VolumeConcentrationUnit.PartPerTrillion: return _value/1e12;
-                case VolumeConcentrationUnit.Percent: return _value/1e2;
-                case VolumeConcentrationUnit.PicolitersPerLiter: return (_value) * 1e-12d;
-                case VolumeConcentrationUnit.PicolitersPerMililiter: return (_value/1e-3) * 1e-12d;
+                case VolumeConcentrationUnit.CentilitersPerLiter: return (Value) * 1e-2d;
+                case VolumeConcentrationUnit.CentilitersPerMililiter: return (Value/1e-3) * 1e-2d;
+                case VolumeConcentrationUnit.DecilitersPerLiter: return (Value) * 1e-1d;
+                case VolumeConcentrationUnit.DecilitersPerMililiter: return (Value/1e-3) * 1e-1d;
+                case VolumeConcentrationUnit.DecimalFraction: return Value;
+                case VolumeConcentrationUnit.LitersPerLiter: return Value;
+                case VolumeConcentrationUnit.LitersPerMililiter: return Value/1e-3;
+                case VolumeConcentrationUnit.MicrolitersPerLiter: return (Value) * 1e-6d;
+                case VolumeConcentrationUnit.MicrolitersPerMililiter: return (Value/1e-3) * 1e-6d;
+                case VolumeConcentrationUnit.MillilitersPerLiter: return (Value) * 1e-3d;
+                case VolumeConcentrationUnit.MillilitersPerMililiter: return (Value/1e-3) * 1e-3d;
+                case VolumeConcentrationUnit.NanolitersPerLiter: return (Value) * 1e-9d;
+                case VolumeConcentrationUnit.NanolitersPerMililiter: return (Value/1e-3) * 1e-9d;
+                case VolumeConcentrationUnit.PartPerBillion: return Value/1e9;
+                case VolumeConcentrationUnit.PartPerMillion: return Value/1e6;
+                case VolumeConcentrationUnit.PartPerThousand: return Value/1e3;
+                case VolumeConcentrationUnit.PartPerTrillion: return Value/1e12;
+                case VolumeConcentrationUnit.Percent: return Value/1e2;
+                case VolumeConcentrationUnit.PicolitersPerLiter: return (Value) * 1e-12d;
+                case VolumeConcentrationUnit.PicolitersPerMililiter: return (Value/1e-3) * 1e-12d;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -956,16 +948,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal VolumeConcentration ToBaseUnit()
+        internal VolumeConcentration<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new VolumeConcentration(baseUnitValue, BaseUnit);
+            return new VolumeConcentration<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(VolumeConcentrationUnit unit)
+        private T GetValueAs(VolumeConcentrationUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1087,57 +1079,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumeConcentration)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumeConcentration<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumeConcentration)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumeConcentration<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumeConcentration)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumeConcentration<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1147,33 +1139,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(VolumeConcentration))
+            if(conversionType == typeof(VolumeConcentration<T>))
                 return this;
             else if(conversionType == typeof(VolumeConcentrationUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return VolumeConcentration.QuantityType;
+                return VolumeConcentration<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return VolumeConcentration.Info;
+                return VolumeConcentration<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return VolumeConcentration.BaseDimensions;
+                return VolumeConcentration<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(VolumeConcentration)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(VolumeConcentration<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
index a07744f116..96df812aa1 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     In physics and engineering, in particular fluid dynamics and hydrometry, the volumetric flow rate, (also known as volume flow rate, rate of fluid flow or volume velocity) is the volume of fluid which passes through a given surface per unit time. The SI unit is m³/s (cubic meters per second). In US Customary Units and British Imperial Units, volumetric flow rate is often expressed as ft³/s (cubic feet per second). It is usually represented by the symbol Q.
     /// </summary>
-    public partial struct VolumeFlow : IQuantity<VolumeFlowUnit>, IEquatable<VolumeFlow>, IComparable, IComparable<VolumeFlow>, IConvertible, IFormattable
+    public partial struct VolumeFlow<T> : IQuantityT<VolumeFlowUnit, T>, IEquatable<VolumeFlow<T>>, IComparable, IComparable<VolumeFlow<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -118,12 +114,12 @@ static VolumeFlow()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public VolumeFlow(double value, VolumeFlowUnit unit)
+        public VolumeFlow(T value, VolumeFlowUnit unit)
         {
             if(unit == VolumeFlowUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -135,14 +131,14 @@ public VolumeFlow(double value, VolumeFlowUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VolumeFlow(double value, UnitSystem unitSystem)
+        public VolumeFlow(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -157,19 +153,19 @@ public VolumeFlow(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of VolumeFlow, which is CubicMeterPerSecond. All conversions go via this value.
+        ///     The base unit of <see cref="VolumeFlow{T}" />, which is CubicMeterPerSecond. All conversions go via this value.
         /// </summary>
         public static VolumeFlowUnit BaseUnit { get; } = VolumeFlowUnit.CubicMeterPerSecond;
 
         /// <summary>
-        /// Represents the largest possible value of VolumeFlow
+        /// Represents the largest possible value of <see cref="VolumeFlow{T}" />
         /// </summary>
-        public static VolumeFlow MaxValue { get; } = new VolumeFlow(double.MaxValue, BaseUnit);
+        public static VolumeFlow<T> MaxValue { get; } = new VolumeFlow<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of VolumeFlow
+        /// Represents the smallest possible value of <see cref="VolumeFlow{T}" />
         /// </summary>
-        public static VolumeFlow MinValue { get; } = new VolumeFlow(double.MinValue, BaseUnit);
+        public static VolumeFlow<T> MinValue { get; } = new VolumeFlow<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -178,14 +174,14 @@ public VolumeFlow(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.VolumeFlow;
 
         /// <summary>
-        ///     All units of measurement for the VolumeFlow quantity.
+        ///     All units of measurement for the <see cref="VolumeFlow{T}" /> quantity.
         /// </summary>
         public static VolumeFlowUnit[] Units { get; } = Enum.GetValues(typeof(VolumeFlowUnit)).Cast<VolumeFlowUnit>().Except(new VolumeFlowUnit[]{ VolumeFlowUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit CubicMeterPerSecond.
         /// </summary>
-        public static VolumeFlow Zero { get; } = new VolumeFlow(0, BaseUnit);
+        public static VolumeFlow<T> Zero { get; } = new VolumeFlow<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -194,7 +190,9 @@ public VolumeFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -210,296 +208,296 @@ public VolumeFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => VolumeFlow.QuantityType;
+        public QuantityType Type => VolumeFlow<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => VolumeFlow.BaseDimensions;
+        public BaseDimensions Dimensions => VolumeFlow<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get VolumeFlow in AcreFeetPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in AcreFeetPerDay.
         /// </summary>
-        public double AcreFeetPerDay => As(VolumeFlowUnit.AcreFootPerDay);
+        public T AcreFeetPerDay => As(VolumeFlowUnit.AcreFootPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in AcreFeetPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in AcreFeetPerHour.
         /// </summary>
-        public double AcreFeetPerHour => As(VolumeFlowUnit.AcreFootPerHour);
+        public T AcreFeetPerHour => As(VolumeFlowUnit.AcreFootPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in AcreFeetPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in AcreFeetPerMinute.
         /// </summary>
-        public double AcreFeetPerMinute => As(VolumeFlowUnit.AcreFootPerMinute);
+        public T AcreFeetPerMinute => As(VolumeFlowUnit.AcreFootPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in AcreFeetPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in AcreFeetPerSecond.
         /// </summary>
-        public double AcreFeetPerSecond => As(VolumeFlowUnit.AcreFootPerSecond);
+        public T AcreFeetPerSecond => As(VolumeFlowUnit.AcreFootPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in CentilitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in CentilitersPerDay.
         /// </summary>
-        public double CentilitersPerDay => As(VolumeFlowUnit.CentiliterPerDay);
+        public T CentilitersPerDay => As(VolumeFlowUnit.CentiliterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in CentilitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in CentilitersPerMinute.
         /// </summary>
-        public double CentilitersPerMinute => As(VolumeFlowUnit.CentiliterPerMinute);
+        public T CentilitersPerMinute => As(VolumeFlowUnit.CentiliterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in CentilitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in CentilitersPerSecond.
         /// </summary>
-        public double CentilitersPerSecond => As(VolumeFlowUnit.CentiliterPerSecond);
+        public T CentilitersPerSecond => As(VolumeFlowUnit.CentiliterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicCentimetersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicCentimetersPerMinute.
         /// </summary>
-        public double CubicCentimetersPerMinute => As(VolumeFlowUnit.CubicCentimeterPerMinute);
+        public T CubicCentimetersPerMinute => As(VolumeFlowUnit.CubicCentimeterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicDecimetersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicDecimetersPerMinute.
         /// </summary>
-        public double CubicDecimetersPerMinute => As(VolumeFlowUnit.CubicDecimeterPerMinute);
+        public T CubicDecimetersPerMinute => As(VolumeFlowUnit.CubicDecimeterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicFeetPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicFeetPerHour.
         /// </summary>
-        public double CubicFeetPerHour => As(VolumeFlowUnit.CubicFootPerHour);
+        public T CubicFeetPerHour => As(VolumeFlowUnit.CubicFootPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicFeetPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicFeetPerMinute.
         /// </summary>
-        public double CubicFeetPerMinute => As(VolumeFlowUnit.CubicFootPerMinute);
+        public T CubicFeetPerMinute => As(VolumeFlowUnit.CubicFootPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicFeetPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicFeetPerSecond.
         /// </summary>
-        public double CubicFeetPerSecond => As(VolumeFlowUnit.CubicFootPerSecond);
+        public T CubicFeetPerSecond => As(VolumeFlowUnit.CubicFootPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicMetersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicMetersPerDay.
         /// </summary>
-        public double CubicMetersPerDay => As(VolumeFlowUnit.CubicMeterPerDay);
+        public T CubicMetersPerDay => As(VolumeFlowUnit.CubicMeterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicMetersPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicMetersPerHour.
         /// </summary>
-        public double CubicMetersPerHour => As(VolumeFlowUnit.CubicMeterPerHour);
+        public T CubicMetersPerHour => As(VolumeFlowUnit.CubicMeterPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicMetersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicMetersPerMinute.
         /// </summary>
-        public double CubicMetersPerMinute => As(VolumeFlowUnit.CubicMeterPerMinute);
+        public T CubicMetersPerMinute => As(VolumeFlowUnit.CubicMeterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicMetersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicMetersPerSecond.
         /// </summary>
-        public double CubicMetersPerSecond => As(VolumeFlowUnit.CubicMeterPerSecond);
+        public T CubicMetersPerSecond => As(VolumeFlowUnit.CubicMeterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicMillimetersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicMillimetersPerSecond.
         /// </summary>
-        public double CubicMillimetersPerSecond => As(VolumeFlowUnit.CubicMillimeterPerSecond);
+        public T CubicMillimetersPerSecond => As(VolumeFlowUnit.CubicMillimeterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicYardsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicYardsPerDay.
         /// </summary>
-        public double CubicYardsPerDay => As(VolumeFlowUnit.CubicYardPerDay);
+        public T CubicYardsPerDay => As(VolumeFlowUnit.CubicYardPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicYardsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicYardsPerHour.
         /// </summary>
-        public double CubicYardsPerHour => As(VolumeFlowUnit.CubicYardPerHour);
+        public T CubicYardsPerHour => As(VolumeFlowUnit.CubicYardPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicYardsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicYardsPerMinute.
         /// </summary>
-        public double CubicYardsPerMinute => As(VolumeFlowUnit.CubicYardPerMinute);
+        public T CubicYardsPerMinute => As(VolumeFlowUnit.CubicYardPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in CubicYardsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in CubicYardsPerSecond.
         /// </summary>
-        public double CubicYardsPerSecond => As(VolumeFlowUnit.CubicYardPerSecond);
+        public T CubicYardsPerSecond => As(VolumeFlowUnit.CubicYardPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in DecilitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in DecilitersPerDay.
         /// </summary>
-        public double DecilitersPerDay => As(VolumeFlowUnit.DeciliterPerDay);
+        public T DecilitersPerDay => As(VolumeFlowUnit.DeciliterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in DecilitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in DecilitersPerMinute.
         /// </summary>
-        public double DecilitersPerMinute => As(VolumeFlowUnit.DeciliterPerMinute);
+        public T DecilitersPerMinute => As(VolumeFlowUnit.DeciliterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in DecilitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in DecilitersPerSecond.
         /// </summary>
-        public double DecilitersPerSecond => As(VolumeFlowUnit.DeciliterPerSecond);
+        public T DecilitersPerSecond => As(VolumeFlowUnit.DeciliterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in KilolitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in KilolitersPerDay.
         /// </summary>
-        public double KilolitersPerDay => As(VolumeFlowUnit.KiloliterPerDay);
+        public T KilolitersPerDay => As(VolumeFlowUnit.KiloliterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in KilolitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in KilolitersPerMinute.
         /// </summary>
-        public double KilolitersPerMinute => As(VolumeFlowUnit.KiloliterPerMinute);
+        public T KilolitersPerMinute => As(VolumeFlowUnit.KiloliterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in KilolitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in KilolitersPerSecond.
         /// </summary>
-        public double KilolitersPerSecond => As(VolumeFlowUnit.KiloliterPerSecond);
+        public T KilolitersPerSecond => As(VolumeFlowUnit.KiloliterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in KilousGallonsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in KilousGallonsPerMinute.
         /// </summary>
-        public double KilousGallonsPerMinute => As(VolumeFlowUnit.KilousGallonPerMinute);
+        public T KilousGallonsPerMinute => As(VolumeFlowUnit.KilousGallonPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in LitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in LitersPerDay.
         /// </summary>
-        public double LitersPerDay => As(VolumeFlowUnit.LiterPerDay);
+        public T LitersPerDay => As(VolumeFlowUnit.LiterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in LitersPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in LitersPerHour.
         /// </summary>
-        public double LitersPerHour => As(VolumeFlowUnit.LiterPerHour);
+        public T LitersPerHour => As(VolumeFlowUnit.LiterPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in LitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in LitersPerMinute.
         /// </summary>
-        public double LitersPerMinute => As(VolumeFlowUnit.LiterPerMinute);
+        public T LitersPerMinute => As(VolumeFlowUnit.LiterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in LitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in LitersPerSecond.
         /// </summary>
-        public double LitersPerSecond => As(VolumeFlowUnit.LiterPerSecond);
+        public T LitersPerSecond => As(VolumeFlowUnit.LiterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in MegalitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in MegalitersPerDay.
         /// </summary>
-        public double MegalitersPerDay => As(VolumeFlowUnit.MegaliterPerDay);
+        public T MegalitersPerDay => As(VolumeFlowUnit.MegaliterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in MegaukGallonsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in MegaukGallonsPerSecond.
         /// </summary>
-        public double MegaukGallonsPerSecond => As(VolumeFlowUnit.MegaukGallonPerSecond);
+        public T MegaukGallonsPerSecond => As(VolumeFlowUnit.MegaukGallonPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in MicrolitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in MicrolitersPerDay.
         /// </summary>
-        public double MicrolitersPerDay => As(VolumeFlowUnit.MicroliterPerDay);
+        public T MicrolitersPerDay => As(VolumeFlowUnit.MicroliterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in MicrolitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in MicrolitersPerMinute.
         /// </summary>
-        public double MicrolitersPerMinute => As(VolumeFlowUnit.MicroliterPerMinute);
+        public T MicrolitersPerMinute => As(VolumeFlowUnit.MicroliterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in MicrolitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in MicrolitersPerSecond.
         /// </summary>
-        public double MicrolitersPerSecond => As(VolumeFlowUnit.MicroliterPerSecond);
+        public T MicrolitersPerSecond => As(VolumeFlowUnit.MicroliterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in MillilitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in MillilitersPerDay.
         /// </summary>
-        public double MillilitersPerDay => As(VolumeFlowUnit.MilliliterPerDay);
+        public T MillilitersPerDay => As(VolumeFlowUnit.MilliliterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in MillilitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in MillilitersPerMinute.
         /// </summary>
-        public double MillilitersPerMinute => As(VolumeFlowUnit.MilliliterPerMinute);
+        public T MillilitersPerMinute => As(VolumeFlowUnit.MilliliterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in MillilitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in MillilitersPerSecond.
         /// </summary>
-        public double MillilitersPerSecond => As(VolumeFlowUnit.MilliliterPerSecond);
+        public T MillilitersPerSecond => As(VolumeFlowUnit.MilliliterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in MillionUsGallonsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in MillionUsGallonsPerDay.
         /// </summary>
-        public double MillionUsGallonsPerDay => As(VolumeFlowUnit.MillionUsGallonsPerDay);
+        public T MillionUsGallonsPerDay => As(VolumeFlowUnit.MillionUsGallonsPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in NanolitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in NanolitersPerDay.
         /// </summary>
-        public double NanolitersPerDay => As(VolumeFlowUnit.NanoliterPerDay);
+        public T NanolitersPerDay => As(VolumeFlowUnit.NanoliterPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in NanolitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in NanolitersPerMinute.
         /// </summary>
-        public double NanolitersPerMinute => As(VolumeFlowUnit.NanoliterPerMinute);
+        public T NanolitersPerMinute => As(VolumeFlowUnit.NanoliterPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in NanolitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in NanolitersPerSecond.
         /// </summary>
-        public double NanolitersPerSecond => As(VolumeFlowUnit.NanoliterPerSecond);
+        public T NanolitersPerSecond => As(VolumeFlowUnit.NanoliterPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in OilBarrelsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in OilBarrelsPerDay.
         /// </summary>
-        public double OilBarrelsPerDay => As(VolumeFlowUnit.OilBarrelPerDay);
+        public T OilBarrelsPerDay => As(VolumeFlowUnit.OilBarrelPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in OilBarrelsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in OilBarrelsPerHour.
         /// </summary>
-        public double OilBarrelsPerHour => As(VolumeFlowUnit.OilBarrelPerHour);
+        public T OilBarrelsPerHour => As(VolumeFlowUnit.OilBarrelPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in OilBarrelsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in OilBarrelsPerMinute.
         /// </summary>
-        public double OilBarrelsPerMinute => As(VolumeFlowUnit.OilBarrelPerMinute);
+        public T OilBarrelsPerMinute => As(VolumeFlowUnit.OilBarrelPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in OilBarrelsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in OilBarrelsPerSecond.
         /// </summary>
-        public double OilBarrelsPerSecond => As(VolumeFlowUnit.OilBarrelPerSecond);
+        public T OilBarrelsPerSecond => As(VolumeFlowUnit.OilBarrelPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in UkGallonsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in UkGallonsPerDay.
         /// </summary>
-        public double UkGallonsPerDay => As(VolumeFlowUnit.UkGallonPerDay);
+        public T UkGallonsPerDay => As(VolumeFlowUnit.UkGallonPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in UkGallonsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in UkGallonsPerHour.
         /// </summary>
-        public double UkGallonsPerHour => As(VolumeFlowUnit.UkGallonPerHour);
+        public T UkGallonsPerHour => As(VolumeFlowUnit.UkGallonPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in UkGallonsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in UkGallonsPerMinute.
         /// </summary>
-        public double UkGallonsPerMinute => As(VolumeFlowUnit.UkGallonPerMinute);
+        public T UkGallonsPerMinute => As(VolumeFlowUnit.UkGallonPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in UkGallonsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in UkGallonsPerSecond.
         /// </summary>
-        public double UkGallonsPerSecond => As(VolumeFlowUnit.UkGallonPerSecond);
+        public T UkGallonsPerSecond => As(VolumeFlowUnit.UkGallonPerSecond);
 
         /// <summary>
-        ///     Get VolumeFlow in UsGallonsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> in UsGallonsPerDay.
         /// </summary>
-        public double UsGallonsPerDay => As(VolumeFlowUnit.UsGallonPerDay);
+        public T UsGallonsPerDay => As(VolumeFlowUnit.UsGallonPerDay);
 
         /// <summary>
-        ///     Get VolumeFlow in UsGallonsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> in UsGallonsPerHour.
         /// </summary>
-        public double UsGallonsPerHour => As(VolumeFlowUnit.UsGallonPerHour);
+        public T UsGallonsPerHour => As(VolumeFlowUnit.UsGallonPerHour);
 
         /// <summary>
-        ///     Get VolumeFlow in UsGallonsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> in UsGallonsPerMinute.
         /// </summary>
-        public double UsGallonsPerMinute => As(VolumeFlowUnit.UsGallonPerMinute);
+        public T UsGallonsPerMinute => As(VolumeFlowUnit.UsGallonPerMinute);
 
         /// <summary>
-        ///     Get VolumeFlow in UsGallonsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> in UsGallonsPerSecond.
         /// </summary>
-        public double UsGallonsPerSecond => As(VolumeFlowUnit.UsGallonPerSecond);
+        public T UsGallonsPerSecond => As(VolumeFlowUnit.UsGallonPerSecond);
 
         #endregion
 
@@ -531,519 +529,463 @@ public static string GetAbbreviation(VolumeFlowUnit unit, IFormatProvider? provi
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get VolumeFlow from AcreFeetPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from AcreFeetPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerDay(QuantityValue acrefeetperday)
+        public static VolumeFlow<T> FromAcreFeetPerDay(T acrefeetperday)
         {
-            double value = (double) acrefeetperday;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay);
+            return new VolumeFlow<T>(acrefeetperday, VolumeFlowUnit.AcreFootPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from AcreFeetPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from AcreFeetPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerHour(QuantityValue acrefeetperhour)
+        public static VolumeFlow<T> FromAcreFeetPerHour(T acrefeetperhour)
         {
-            double value = (double) acrefeetperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour);
+            return new VolumeFlow<T>(acrefeetperhour, VolumeFlowUnit.AcreFootPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from AcreFeetPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from AcreFeetPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerMinute(QuantityValue acrefeetperminute)
+        public static VolumeFlow<T> FromAcreFeetPerMinute(T acrefeetperminute)
         {
-            double value = (double) acrefeetperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute);
+            return new VolumeFlow<T>(acrefeetperminute, VolumeFlowUnit.AcreFootPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from AcreFeetPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from AcreFeetPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerSecond(QuantityValue acrefeetpersecond)
+        public static VolumeFlow<T> FromAcreFeetPerSecond(T acrefeetpersecond)
         {
-            double value = (double) acrefeetpersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond);
+            return new VolumeFlow<T>(acrefeetpersecond, VolumeFlowUnit.AcreFootPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from CentilitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from CentilitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerDay(QuantityValue centilitersperday)
+        public static VolumeFlow<T> FromCentilitersPerDay(T centilitersperday)
         {
-            double value = (double) centilitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay);
+            return new VolumeFlow<T>(centilitersperday, VolumeFlowUnit.CentiliterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from CentilitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from CentilitersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerMinute(QuantityValue centilitersperminute)
+        public static VolumeFlow<T> FromCentilitersPerMinute(T centilitersperminute)
         {
-            double value = (double) centilitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute);
+            return new VolumeFlow<T>(centilitersperminute, VolumeFlowUnit.CentiliterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from CentilitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from CentilitersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerSecond(QuantityValue centiliterspersecond)
+        public static VolumeFlow<T> FromCentilitersPerSecond(T centiliterspersecond)
         {
-            double value = (double) centiliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond);
+            return new VolumeFlow<T>(centiliterspersecond, VolumeFlowUnit.CentiliterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicCentimetersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicCentimetersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicCentimetersPerMinute(QuantityValue cubiccentimetersperminute)
+        public static VolumeFlow<T> FromCubicCentimetersPerMinute(T cubiccentimetersperminute)
         {
-            double value = (double) cubiccentimetersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute);
+            return new VolumeFlow<T>(cubiccentimetersperminute, VolumeFlowUnit.CubicCentimeterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicDecimetersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicDecimetersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicDecimetersPerMinute(QuantityValue cubicdecimetersperminute)
+        public static VolumeFlow<T> FromCubicDecimetersPerMinute(T cubicdecimetersperminute)
         {
-            double value = (double) cubicdecimetersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute);
+            return new VolumeFlow<T>(cubicdecimetersperminute, VolumeFlowUnit.CubicDecimeterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicFeetPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicFeetPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerHour(QuantityValue cubicfeetperhour)
+        public static VolumeFlow<T> FromCubicFeetPerHour(T cubicfeetperhour)
         {
-            double value = (double) cubicfeetperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour);
+            return new VolumeFlow<T>(cubicfeetperhour, VolumeFlowUnit.CubicFootPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicFeetPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicFeetPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerMinute(QuantityValue cubicfeetperminute)
+        public static VolumeFlow<T> FromCubicFeetPerMinute(T cubicfeetperminute)
         {
-            double value = (double) cubicfeetperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute);
+            return new VolumeFlow<T>(cubicfeetperminute, VolumeFlowUnit.CubicFootPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicFeetPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicFeetPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerSecond(QuantityValue cubicfeetpersecond)
+        public static VolumeFlow<T> FromCubicFeetPerSecond(T cubicfeetpersecond)
         {
-            double value = (double) cubicfeetpersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond);
+            return new VolumeFlow<T>(cubicfeetpersecond, VolumeFlowUnit.CubicFootPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicMetersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicMetersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerDay(QuantityValue cubicmetersperday)
+        public static VolumeFlow<T> FromCubicMetersPerDay(T cubicmetersperday)
         {
-            double value = (double) cubicmetersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay);
+            return new VolumeFlow<T>(cubicmetersperday, VolumeFlowUnit.CubicMeterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicMetersPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicMetersPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerHour(QuantityValue cubicmetersperhour)
+        public static VolumeFlow<T> FromCubicMetersPerHour(T cubicmetersperhour)
         {
-            double value = (double) cubicmetersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour);
+            return new VolumeFlow<T>(cubicmetersperhour, VolumeFlowUnit.CubicMeterPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicMetersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicMetersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerMinute(QuantityValue cubicmetersperminute)
+        public static VolumeFlow<T> FromCubicMetersPerMinute(T cubicmetersperminute)
         {
-            double value = (double) cubicmetersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute);
+            return new VolumeFlow<T>(cubicmetersperminute, VolumeFlowUnit.CubicMeterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicMetersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicMetersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerSecond(QuantityValue cubicmeterspersecond)
+        public static VolumeFlow<T> FromCubicMetersPerSecond(T cubicmeterspersecond)
         {
-            double value = (double) cubicmeterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond);
+            return new VolumeFlow<T>(cubicmeterspersecond, VolumeFlowUnit.CubicMeterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicMillimetersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicMillimetersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMillimetersPerSecond(QuantityValue cubicmillimeterspersecond)
+        public static VolumeFlow<T> FromCubicMillimetersPerSecond(T cubicmillimeterspersecond)
         {
-            double value = (double) cubicmillimeterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond);
+            return new VolumeFlow<T>(cubicmillimeterspersecond, VolumeFlowUnit.CubicMillimeterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicYardsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicYardsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerDay(QuantityValue cubicyardsperday)
+        public static VolumeFlow<T> FromCubicYardsPerDay(T cubicyardsperday)
         {
-            double value = (double) cubicyardsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay);
+            return new VolumeFlow<T>(cubicyardsperday, VolumeFlowUnit.CubicYardPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicYardsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicYardsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerHour(QuantityValue cubicyardsperhour)
+        public static VolumeFlow<T> FromCubicYardsPerHour(T cubicyardsperhour)
         {
-            double value = (double) cubicyardsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour);
+            return new VolumeFlow<T>(cubicyardsperhour, VolumeFlowUnit.CubicYardPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicYardsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicYardsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerMinute(QuantityValue cubicyardsperminute)
+        public static VolumeFlow<T> FromCubicYardsPerMinute(T cubicyardsperminute)
         {
-            double value = (double) cubicyardsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute);
+            return new VolumeFlow<T>(cubicyardsperminute, VolumeFlowUnit.CubicYardPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from CubicYardsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from CubicYardsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerSecond(QuantityValue cubicyardspersecond)
+        public static VolumeFlow<T> FromCubicYardsPerSecond(T cubicyardspersecond)
         {
-            double value = (double) cubicyardspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond);
+            return new VolumeFlow<T>(cubicyardspersecond, VolumeFlowUnit.CubicYardPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from DecilitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from DecilitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerDay(QuantityValue decilitersperday)
+        public static VolumeFlow<T> FromDecilitersPerDay(T decilitersperday)
         {
-            double value = (double) decilitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay);
+            return new VolumeFlow<T>(decilitersperday, VolumeFlowUnit.DeciliterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from DecilitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from DecilitersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerMinute(QuantityValue decilitersperminute)
+        public static VolumeFlow<T> FromDecilitersPerMinute(T decilitersperminute)
         {
-            double value = (double) decilitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute);
+            return new VolumeFlow<T>(decilitersperminute, VolumeFlowUnit.DeciliterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from DecilitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from DecilitersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerSecond(QuantityValue deciliterspersecond)
+        public static VolumeFlow<T> FromDecilitersPerSecond(T deciliterspersecond)
         {
-            double value = (double) deciliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond);
+            return new VolumeFlow<T>(deciliterspersecond, VolumeFlowUnit.DeciliterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from KilolitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from KilolitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerDay(QuantityValue kilolitersperday)
+        public static VolumeFlow<T> FromKilolitersPerDay(T kilolitersperday)
         {
-            double value = (double) kilolitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay);
+            return new VolumeFlow<T>(kilolitersperday, VolumeFlowUnit.KiloliterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from KilolitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from KilolitersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerMinute(QuantityValue kilolitersperminute)
+        public static VolumeFlow<T> FromKilolitersPerMinute(T kilolitersperminute)
         {
-            double value = (double) kilolitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute);
+            return new VolumeFlow<T>(kilolitersperminute, VolumeFlowUnit.KiloliterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from KilolitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from KilolitersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerSecond(QuantityValue kiloliterspersecond)
+        public static VolumeFlow<T> FromKilolitersPerSecond(T kiloliterspersecond)
         {
-            double value = (double) kiloliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond);
+            return new VolumeFlow<T>(kiloliterspersecond, VolumeFlowUnit.KiloliterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from KilousGallonsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from KilousGallonsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilousGallonsPerMinute(QuantityValue kilousgallonsperminute)
+        public static VolumeFlow<T> FromKilousGallonsPerMinute(T kilousgallonsperminute)
         {
-            double value = (double) kilousgallonsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute);
+            return new VolumeFlow<T>(kilousgallonsperminute, VolumeFlowUnit.KilousGallonPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from LitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from LitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerDay(QuantityValue litersperday)
+        public static VolumeFlow<T> FromLitersPerDay(T litersperday)
         {
-            double value = (double) litersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay);
+            return new VolumeFlow<T>(litersperday, VolumeFlowUnit.LiterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from LitersPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from LitersPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerHour(QuantityValue litersperhour)
+        public static VolumeFlow<T> FromLitersPerHour(T litersperhour)
         {
-            double value = (double) litersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour);
+            return new VolumeFlow<T>(litersperhour, VolumeFlowUnit.LiterPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from LitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from LitersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerMinute(QuantityValue litersperminute)
+        public static VolumeFlow<T> FromLitersPerMinute(T litersperminute)
         {
-            double value = (double) litersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute);
+            return new VolumeFlow<T>(litersperminute, VolumeFlowUnit.LiterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from LitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from LitersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerSecond(QuantityValue literspersecond)
+        public static VolumeFlow<T> FromLitersPerSecond(T literspersecond)
         {
-            double value = (double) literspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond);
+            return new VolumeFlow<T>(literspersecond, VolumeFlowUnit.LiterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from MegalitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from MegalitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerDay(QuantityValue megalitersperday)
+        public static VolumeFlow<T> FromMegalitersPerDay(T megalitersperday)
         {
-            double value = (double) megalitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay);
+            return new VolumeFlow<T>(megalitersperday, VolumeFlowUnit.MegaliterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from MegaukGallonsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from MegaukGallonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegaukGallonsPerSecond(QuantityValue megaukgallonspersecond)
+        public static VolumeFlow<T> FromMegaukGallonsPerSecond(T megaukgallonspersecond)
         {
-            double value = (double) megaukgallonspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond);
+            return new VolumeFlow<T>(megaukgallonspersecond, VolumeFlowUnit.MegaukGallonPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from MicrolitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from MicrolitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerDay(QuantityValue microlitersperday)
+        public static VolumeFlow<T> FromMicrolitersPerDay(T microlitersperday)
         {
-            double value = (double) microlitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay);
+            return new VolumeFlow<T>(microlitersperday, VolumeFlowUnit.MicroliterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from MicrolitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from MicrolitersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerMinute(QuantityValue microlitersperminute)
+        public static VolumeFlow<T> FromMicrolitersPerMinute(T microlitersperminute)
         {
-            double value = (double) microlitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute);
+            return new VolumeFlow<T>(microlitersperminute, VolumeFlowUnit.MicroliterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from MicrolitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from MicrolitersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerSecond(QuantityValue microliterspersecond)
+        public static VolumeFlow<T> FromMicrolitersPerSecond(T microliterspersecond)
         {
-            double value = (double) microliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond);
+            return new VolumeFlow<T>(microliterspersecond, VolumeFlowUnit.MicroliterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from MillilitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from MillilitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerDay(QuantityValue millilitersperday)
+        public static VolumeFlow<T> FromMillilitersPerDay(T millilitersperday)
         {
-            double value = (double) millilitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay);
+            return new VolumeFlow<T>(millilitersperday, VolumeFlowUnit.MilliliterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from MillilitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from MillilitersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerMinute(QuantityValue millilitersperminute)
+        public static VolumeFlow<T> FromMillilitersPerMinute(T millilitersperminute)
         {
-            double value = (double) millilitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute);
+            return new VolumeFlow<T>(millilitersperminute, VolumeFlowUnit.MilliliterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from MillilitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from MillilitersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerSecond(QuantityValue milliliterspersecond)
+        public static VolumeFlow<T> FromMillilitersPerSecond(T milliliterspersecond)
         {
-            double value = (double) milliliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond);
+            return new VolumeFlow<T>(milliliterspersecond, VolumeFlowUnit.MilliliterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from MillionUsGallonsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from MillionUsGallonsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillionUsGallonsPerDay(QuantityValue millionusgallonsperday)
+        public static VolumeFlow<T> FromMillionUsGallonsPerDay(T millionusgallonsperday)
         {
-            double value = (double) millionusgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonsPerDay);
+            return new VolumeFlow<T>(millionusgallonsperday, VolumeFlowUnit.MillionUsGallonsPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from NanolitersPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from NanolitersPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerDay(QuantityValue nanolitersperday)
+        public static VolumeFlow<T> FromNanolitersPerDay(T nanolitersperday)
         {
-            double value = (double) nanolitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay);
+            return new VolumeFlow<T>(nanolitersperday, VolumeFlowUnit.NanoliterPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from NanolitersPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from NanolitersPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerMinute(QuantityValue nanolitersperminute)
+        public static VolumeFlow<T> FromNanolitersPerMinute(T nanolitersperminute)
         {
-            double value = (double) nanolitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute);
+            return new VolumeFlow<T>(nanolitersperminute, VolumeFlowUnit.NanoliterPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from NanolitersPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from NanolitersPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerSecond(QuantityValue nanoliterspersecond)
+        public static VolumeFlow<T> FromNanolitersPerSecond(T nanoliterspersecond)
         {
-            double value = (double) nanoliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond);
+            return new VolumeFlow<T>(nanoliterspersecond, VolumeFlowUnit.NanoliterPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from OilBarrelsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from OilBarrelsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerDay(QuantityValue oilbarrelsperday)
+        public static VolumeFlow<T> FromOilBarrelsPerDay(T oilbarrelsperday)
         {
-            double value = (double) oilbarrelsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay);
+            return new VolumeFlow<T>(oilbarrelsperday, VolumeFlowUnit.OilBarrelPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from OilBarrelsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from OilBarrelsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerHour(QuantityValue oilbarrelsperhour)
+        public static VolumeFlow<T> FromOilBarrelsPerHour(T oilbarrelsperhour)
         {
-            double value = (double) oilbarrelsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour);
+            return new VolumeFlow<T>(oilbarrelsperhour, VolumeFlowUnit.OilBarrelPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from OilBarrelsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from OilBarrelsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerMinute(QuantityValue oilbarrelsperminute)
+        public static VolumeFlow<T> FromOilBarrelsPerMinute(T oilbarrelsperminute)
         {
-            double value = (double) oilbarrelsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute);
+            return new VolumeFlow<T>(oilbarrelsperminute, VolumeFlowUnit.OilBarrelPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from OilBarrelsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from OilBarrelsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerSecond(QuantityValue oilbarrelspersecond)
+        public static VolumeFlow<T> FromOilBarrelsPerSecond(T oilbarrelspersecond)
         {
-            double value = (double) oilbarrelspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond);
+            return new VolumeFlow<T>(oilbarrelspersecond, VolumeFlowUnit.OilBarrelPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from UkGallonsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from UkGallonsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerDay(QuantityValue ukgallonsperday)
+        public static VolumeFlow<T> FromUkGallonsPerDay(T ukgallonsperday)
         {
-            double value = (double) ukgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay);
+            return new VolumeFlow<T>(ukgallonsperday, VolumeFlowUnit.UkGallonPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from UkGallonsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from UkGallonsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerHour(QuantityValue ukgallonsperhour)
+        public static VolumeFlow<T> FromUkGallonsPerHour(T ukgallonsperhour)
         {
-            double value = (double) ukgallonsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour);
+            return new VolumeFlow<T>(ukgallonsperhour, VolumeFlowUnit.UkGallonPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from UkGallonsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from UkGallonsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerMinute(QuantityValue ukgallonsperminute)
+        public static VolumeFlow<T> FromUkGallonsPerMinute(T ukgallonsperminute)
         {
-            double value = (double) ukgallonsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute);
+            return new VolumeFlow<T>(ukgallonsperminute, VolumeFlowUnit.UkGallonPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from UkGallonsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from UkGallonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerSecond(QuantityValue ukgallonspersecond)
+        public static VolumeFlow<T> FromUkGallonsPerSecond(T ukgallonspersecond)
         {
-            double value = (double) ukgallonspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond);
+            return new VolumeFlow<T>(ukgallonspersecond, VolumeFlowUnit.UkGallonPerSecond);
         }
         /// <summary>
-        ///     Get VolumeFlow from UsGallonsPerDay.
+        ///     Get <see cref="VolumeFlow{T}" /> from UsGallonsPerDay.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerDay(QuantityValue usgallonsperday)
+        public static VolumeFlow<T> FromUsGallonsPerDay(T usgallonsperday)
         {
-            double value = (double) usgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay);
+            return new VolumeFlow<T>(usgallonsperday, VolumeFlowUnit.UsGallonPerDay);
         }
         /// <summary>
-        ///     Get VolumeFlow from UsGallonsPerHour.
+        ///     Get <see cref="VolumeFlow{T}" /> from UsGallonsPerHour.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerHour(QuantityValue usgallonsperhour)
+        public static VolumeFlow<T> FromUsGallonsPerHour(T usgallonsperhour)
         {
-            double value = (double) usgallonsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour);
+            return new VolumeFlow<T>(usgallonsperhour, VolumeFlowUnit.UsGallonPerHour);
         }
         /// <summary>
-        ///     Get VolumeFlow from UsGallonsPerMinute.
+        ///     Get <see cref="VolumeFlow{T}" /> from UsGallonsPerMinute.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerMinute(QuantityValue usgallonsperminute)
+        public static VolumeFlow<T> FromUsGallonsPerMinute(T usgallonsperminute)
         {
-            double value = (double) usgallonsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute);
+            return new VolumeFlow<T>(usgallonsperminute, VolumeFlowUnit.UsGallonPerMinute);
         }
         /// <summary>
-        ///     Get VolumeFlow from UsGallonsPerSecond.
+        ///     Get <see cref="VolumeFlow{T}" /> from UsGallonsPerSecond.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerSecond(QuantityValue usgallonspersecond)
+        public static VolumeFlow<T> FromUsGallonsPerSecond(T usgallonspersecond)
         {
-            double value = (double) usgallonspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond);
+            return new VolumeFlow<T>(usgallonspersecond, VolumeFlowUnit.UsGallonPerSecond);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumeFlowUnit" /> to <see cref="VolumeFlow" />.
+        ///     Dynamically convert from value and unit enum <see cref="VolumeFlowUnit" /> to <see cref="VolumeFlow{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumeFlow unit value.</returns>
-        public static VolumeFlow From(QuantityValue value, VolumeFlowUnit fromUnit)
+        /// <returns><see cref="VolumeFlow{T}" /> unit value.</returns>
+        public static VolumeFlow<T> From(T value, VolumeFlowUnit fromUnit)
         {
-            return new VolumeFlow((double)value, fromUnit);
+            return new VolumeFlow<T>(value, fromUnit);
         }
 
         #endregion
@@ -1072,7 +1014,7 @@ public static VolumeFlow From(QuantityValue value, VolumeFlowUnit fromUnit)
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static VolumeFlow Parse(string str)
+        public static VolumeFlow<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -1100,9 +1042,9 @@ public static VolumeFlow Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static VolumeFlow Parse(string str, IFormatProvider? provider)
+        public static VolumeFlow<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<VolumeFlow, VolumeFlowUnit>(
+            return QuantityParser.Default.Parse<T, VolumeFlow<T>, VolumeFlowUnit>(
                 str,
                 provider,
                 From);
@@ -1116,7 +1058,7 @@ public static VolumeFlow Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out VolumeFlow result)
+        public static bool TryParse(string? str, out VolumeFlow<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -1131,9 +1073,9 @@ public static bool TryParse(string? str, out VolumeFlow result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out VolumeFlow result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out VolumeFlow<T> result)
         {
-            return QuantityParser.Default.TryParse<VolumeFlow, VolumeFlowUnit>(
+            return QuantityParser.Default.TryParse<T, VolumeFlow<T>, VolumeFlowUnit>(
                 str,
                 provider,
                 From,
@@ -1195,45 +1137,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static VolumeFlow operator -(VolumeFlow right)
+        public static VolumeFlow<T> operator -(VolumeFlow<T> right)
         {
-            return new VolumeFlow(-right.Value, right.Unit);
+            return new VolumeFlow<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from adding two <see cref="VolumeFlow"/>.</summary>
-        public static VolumeFlow operator +(VolumeFlow left, VolumeFlow right)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from adding two <see cref="VolumeFlow{T}"/>.</summary>
+        public static VolumeFlow<T> operator +(VolumeFlow<T> left, VolumeFlow<T> right)
         {
-            return new VolumeFlow(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new VolumeFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from subtracting two <see cref="VolumeFlow"/>.</summary>
-        public static VolumeFlow operator -(VolumeFlow left, VolumeFlow right)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from subtracting two <see cref="VolumeFlow{T}"/>.</summary>
+        public static VolumeFlow<T> operator -(VolumeFlow<T> left, VolumeFlow<T> right)
         {
-            return new VolumeFlow(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new VolumeFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from multiplying value and <see cref="VolumeFlow"/>.</summary>
-        public static VolumeFlow operator *(double left, VolumeFlow right)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from multiplying value and <see cref="VolumeFlow{T}"/>.</summary>
+        public static VolumeFlow<T> operator *(T left, VolumeFlow<T> right)
         {
-            return new VolumeFlow(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new VolumeFlow<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from multiplying value and <see cref="VolumeFlow"/>.</summary>
-        public static VolumeFlow operator *(VolumeFlow left, double right)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from multiplying value and <see cref="VolumeFlow{T}"/>.</summary>
+        public static VolumeFlow<T> operator *(VolumeFlow<T> left, T right)
         {
-            return new VolumeFlow(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new VolumeFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumeFlow"/> from dividing <see cref="VolumeFlow"/> by value.</summary>
-        public static VolumeFlow operator /(VolumeFlow left, double right)
+        /// <summary>Get <see cref="VolumeFlow{T}"/> from dividing <see cref="VolumeFlow{T}"/> by value.</summary>
+        public static VolumeFlow<T> operator /(VolumeFlow<T> left, T right)
         {
-            return new VolumeFlow(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new VolumeFlow<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="VolumeFlow"/> by <see cref="VolumeFlow"/>.</summary>
-        public static double operator /(VolumeFlow left, VolumeFlow right)
+        /// <summary>Get ratio value from dividing <see cref="VolumeFlow{T}"/> by <see cref="VolumeFlow{T}"/>.</summary>
+        public static T operator /(VolumeFlow<T> left, VolumeFlow<T> right)
         {
-            return left.CubicMetersPerSecond / right.CubicMetersPerSecond;
+            return CompiledLambdas.Divide(left.CubicMetersPerSecond, right.CubicMetersPerSecond);
         }
 
         #endregion
@@ -1241,39 +1188,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(VolumeFlow left, VolumeFlow right)
+        public static bool operator <=(VolumeFlow<T> left, VolumeFlow<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(VolumeFlow left, VolumeFlow right)
+        public static bool operator >=(VolumeFlow<T> left, VolumeFlow<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(VolumeFlow left, VolumeFlow right)
+        public static bool operator <(VolumeFlow<T> left, VolumeFlow<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(VolumeFlow left, VolumeFlow right)
+        public static bool operator >(VolumeFlow<T> left, VolumeFlow<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VolumeFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(VolumeFlow left, VolumeFlow right)
+        /// <remarks>Consider using <see cref="Equals(VolumeFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(VolumeFlow<T> left, VolumeFlow<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VolumeFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(VolumeFlow left, VolumeFlow right)
+        /// <remarks>Consider using <see cref="Equals(VolumeFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(VolumeFlow<T> left, VolumeFlow<T> right)
         {
             return !(left == right);
         }
@@ -1282,37 +1229,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is VolumeFlow objVolumeFlow)) throw new ArgumentException("Expected type VolumeFlow.", nameof(obj));
+            if(!(obj is VolumeFlow<T> objVolumeFlow)) throw new ArgumentException("Expected type VolumeFlow.", nameof(obj));
 
             return CompareTo(objVolumeFlow);
         }
 
         /// <inheritdoc />
-        public int CompareTo(VolumeFlow other)
+        public int CompareTo(VolumeFlow<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VolumeFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(VolumeFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is VolumeFlow objVolumeFlow))
+            if(obj is null || !(obj is VolumeFlow<T> objVolumeFlow))
                 return false;
 
             return Equals(objVolumeFlow);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VolumeFlow, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(VolumeFlow other)
+        /// <remarks>Consider using <see cref="Equals(VolumeFlow{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(VolumeFlow<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another VolumeFlow within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="VolumeFlow{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -1350,21 +1297,19 @@ public bool Equals(VolumeFlow other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(VolumeFlow other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(VolumeFlow<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current VolumeFlow.</returns>
+        /// <returns>A hash code for the current <see cref="VolumeFlow{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -1378,17 +1323,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumeFlowUnit unit)
+        public T As(VolumeFlowUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1408,17 +1353,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is VolumeFlowUnit unitAsVolumeFlowUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowUnit)} is supported.", nameof(unit));
 
-            return As(unitAsVolumeFlowUnit);
+            var asValue = As(unitAsVolumeFlowUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<VolumeFlowUnit>.As(VolumeFlowUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this VolumeFlow to another VolumeFlow with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="VolumeFlow{T}" /> to another <see cref="VolumeFlow{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A VolumeFlow with the specified unit.</returns>
-        public VolumeFlow ToUnit(VolumeFlowUnit unit)
+        /// <returns>A <see cref="VolumeFlow{T}" /> with the specified unit.</returns>
+        public VolumeFlow<T> ToUnit(VolumeFlowUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new VolumeFlow(convertedValue, unit);
+            return new VolumeFlow<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -1431,7 +1381,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public VolumeFlow ToUnit(UnitSystem unitSystem)
+        public VolumeFlow<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1451,74 +1401,80 @@ public VolumeFlow ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumeFlowUnit> IQuantity<VolumeFlowUnit>.ToUnit(VolumeFlowUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<VolumeFlowUnit, T> IQuantityT<VolumeFlowUnit, T>.ToUnit(VolumeFlowUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<VolumeFlowUnit> IQuantity<VolumeFlowUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<VolumeFlowUnit, T> IQuantityT<VolumeFlowUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case VolumeFlowUnit.AcreFootPerDay: return _value/70.0457;
-                case VolumeFlowUnit.AcreFootPerHour: return _value/2.91857;
-                case VolumeFlowUnit.AcreFootPerMinute: return _value/0.0486427916;
-                case VolumeFlowUnit.AcreFootPerSecond: return _value/0.000810713194;
-                case VolumeFlowUnit.CentiliterPerDay: return (_value/86400000) * 1e-2d;
-                case VolumeFlowUnit.CentiliterPerMinute: return (_value/60000.00000) * 1e-2d;
-                case VolumeFlowUnit.CentiliterPerSecond: return (_value/1000) * 1e-2d;
-                case VolumeFlowUnit.CubicCentimeterPerMinute: return _value*1.6666666666667e-8;
-                case VolumeFlowUnit.CubicDecimeterPerMinute: return _value/60000.00000;
-                case VolumeFlowUnit.CubicFootPerHour: return _value*7.8657907199999087346816086183876e-6;
-                case VolumeFlowUnit.CubicFootPerMinute: return _value/2118.88000326;
-                case VolumeFlowUnit.CubicFootPerSecond: return _value/35.314666721;
-                case VolumeFlowUnit.CubicMeterPerDay: return _value/86400;
-                case VolumeFlowUnit.CubicMeterPerHour: return _value/3600;
-                case VolumeFlowUnit.CubicMeterPerMinute: return _value/60;
-                case VolumeFlowUnit.CubicMeterPerSecond: return _value;
-                case VolumeFlowUnit.CubicMillimeterPerSecond: return _value*1e-9;
-                case VolumeFlowUnit.CubicYardPerDay: return _value/113007;
-                case VolumeFlowUnit.CubicYardPerHour: return _value*2.1237634944E-4;
-                case VolumeFlowUnit.CubicYardPerMinute: return _value*0.0127425809664;
-                case VolumeFlowUnit.CubicYardPerSecond: return _value*0.764554857984;
-                case VolumeFlowUnit.DeciliterPerDay: return (_value/86400000) * 1e-1d;
-                case VolumeFlowUnit.DeciliterPerMinute: return (_value/60000.00000) * 1e-1d;
-                case VolumeFlowUnit.DeciliterPerSecond: return (_value/1000) * 1e-1d;
-                case VolumeFlowUnit.KiloliterPerDay: return (_value/86400000) * 1e3d;
-                case VolumeFlowUnit.KiloliterPerMinute: return (_value/60000.00000) * 1e3d;
-                case VolumeFlowUnit.KiloliterPerSecond: return (_value/1000) * 1e3d;
-                case VolumeFlowUnit.KilousGallonPerMinute: return _value/15.850323141489;
-                case VolumeFlowUnit.LiterPerDay: return _value/86400000;
-                case VolumeFlowUnit.LiterPerHour: return _value/3600000.000;
-                case VolumeFlowUnit.LiterPerMinute: return _value/60000.00000;
-                case VolumeFlowUnit.LiterPerSecond: return _value/1000;
-                case VolumeFlowUnit.MegaliterPerDay: return (_value/86400000) * 1e6d;
-                case VolumeFlowUnit.MegaukGallonPerSecond: return (_value/219.969) * 1e6d;
-                case VolumeFlowUnit.MicroliterPerDay: return (_value/86400000) * 1e-6d;
-                case VolumeFlowUnit.MicroliterPerMinute: return (_value/60000.00000) * 1e-6d;
-                case VolumeFlowUnit.MicroliterPerSecond: return (_value/1000) * 1e-6d;
-                case VolumeFlowUnit.MilliliterPerDay: return (_value/86400000) * 1e-3d;
-                case VolumeFlowUnit.MilliliterPerMinute: return (_value/60000.00000) * 1e-3d;
-                case VolumeFlowUnit.MilliliterPerSecond: return (_value/1000) * 1e-3d;
-                case VolumeFlowUnit.MillionUsGallonsPerDay: return _value/22.824465227;
-                case VolumeFlowUnit.NanoliterPerDay: return (_value/86400000) * 1e-9d;
-                case VolumeFlowUnit.NanoliterPerMinute: return (_value/60000.00000) * 1e-9d;
-                case VolumeFlowUnit.NanoliterPerSecond: return (_value/1000) * 1e-9d;
-                case VolumeFlowUnit.OilBarrelPerDay: return _value*1.8401307283333333333333333333333e-6;
-                case VolumeFlowUnit.OilBarrelPerHour: return _value*4.41631375e-5;
-                case VolumeFlowUnit.OilBarrelPerMinute: return _value*2.64978825e-3;
-                case VolumeFlowUnit.OilBarrelPerSecond: return _value/6.28981;
-                case VolumeFlowUnit.UkGallonPerDay: return _value/19005304;
-                case VolumeFlowUnit.UkGallonPerHour: return _value/791887.667;
-                case VolumeFlowUnit.UkGallonPerMinute: return _value/13198.2;
-                case VolumeFlowUnit.UkGallonPerSecond: return _value/219.969;
-                case VolumeFlowUnit.UsGallonPerDay: return _value/22824465.227;
-                case VolumeFlowUnit.UsGallonPerHour: return _value/951019.38848933424;
-                case VolumeFlowUnit.UsGallonPerMinute: return _value/15850.323141489;
-                case VolumeFlowUnit.UsGallonPerSecond: return _value/264.1720523581484;
+                case VolumeFlowUnit.AcreFootPerDay: return Value/70.0457;
+                case VolumeFlowUnit.AcreFootPerHour: return Value/2.91857;
+                case VolumeFlowUnit.AcreFootPerMinute: return Value/0.0486427916;
+                case VolumeFlowUnit.AcreFootPerSecond: return Value/0.000810713194;
+                case VolumeFlowUnit.CentiliterPerDay: return (Value/86400000) * 1e-2d;
+                case VolumeFlowUnit.CentiliterPerMinute: return (Value/60000.00000) * 1e-2d;
+                case VolumeFlowUnit.CentiliterPerSecond: return (Value/1000) * 1e-2d;
+                case VolumeFlowUnit.CubicCentimeterPerMinute: return Value*1.6666666666667e-8;
+                case VolumeFlowUnit.CubicDecimeterPerMinute: return Value/60000.00000;
+                case VolumeFlowUnit.CubicFootPerHour: return Value*7.8657907199999087346816086183876e-6;
+                case VolumeFlowUnit.CubicFootPerMinute: return Value/2118.88000326;
+                case VolumeFlowUnit.CubicFootPerSecond: return Value/35.314666721;
+                case VolumeFlowUnit.CubicMeterPerDay: return Value/86400;
+                case VolumeFlowUnit.CubicMeterPerHour: return Value/3600;
+                case VolumeFlowUnit.CubicMeterPerMinute: return Value/60;
+                case VolumeFlowUnit.CubicMeterPerSecond: return Value;
+                case VolumeFlowUnit.CubicMillimeterPerSecond: return Value*1e-9;
+                case VolumeFlowUnit.CubicYardPerDay: return Value/113007;
+                case VolumeFlowUnit.CubicYardPerHour: return Value*2.1237634944E-4;
+                case VolumeFlowUnit.CubicYardPerMinute: return Value*0.0127425809664;
+                case VolumeFlowUnit.CubicYardPerSecond: return Value*0.764554857984;
+                case VolumeFlowUnit.DeciliterPerDay: return (Value/86400000) * 1e-1d;
+                case VolumeFlowUnit.DeciliterPerMinute: return (Value/60000.00000) * 1e-1d;
+                case VolumeFlowUnit.DeciliterPerSecond: return (Value/1000) * 1e-1d;
+                case VolumeFlowUnit.KiloliterPerDay: return (Value/86400000) * 1e3d;
+                case VolumeFlowUnit.KiloliterPerMinute: return (Value/60000.00000) * 1e3d;
+                case VolumeFlowUnit.KiloliterPerSecond: return (Value/1000) * 1e3d;
+                case VolumeFlowUnit.KilousGallonPerMinute: return Value/15.850323141489;
+                case VolumeFlowUnit.LiterPerDay: return Value/86400000;
+                case VolumeFlowUnit.LiterPerHour: return Value/3600000.000;
+                case VolumeFlowUnit.LiterPerMinute: return Value/60000.00000;
+                case VolumeFlowUnit.LiterPerSecond: return Value/1000;
+                case VolumeFlowUnit.MegaliterPerDay: return (Value/86400000) * 1e6d;
+                case VolumeFlowUnit.MegaukGallonPerSecond: return (Value/219.969) * 1e6d;
+                case VolumeFlowUnit.MicroliterPerDay: return (Value/86400000) * 1e-6d;
+                case VolumeFlowUnit.MicroliterPerMinute: return (Value/60000.00000) * 1e-6d;
+                case VolumeFlowUnit.MicroliterPerSecond: return (Value/1000) * 1e-6d;
+                case VolumeFlowUnit.MilliliterPerDay: return (Value/86400000) * 1e-3d;
+                case VolumeFlowUnit.MilliliterPerMinute: return (Value/60000.00000) * 1e-3d;
+                case VolumeFlowUnit.MilliliterPerSecond: return (Value/1000) * 1e-3d;
+                case VolumeFlowUnit.MillionUsGallonsPerDay: return Value/22.824465227;
+                case VolumeFlowUnit.NanoliterPerDay: return (Value/86400000) * 1e-9d;
+                case VolumeFlowUnit.NanoliterPerMinute: return (Value/60000.00000) * 1e-9d;
+                case VolumeFlowUnit.NanoliterPerSecond: return (Value/1000) * 1e-9d;
+                case VolumeFlowUnit.OilBarrelPerDay: return Value*1.8401307283333333333333333333333e-6;
+                case VolumeFlowUnit.OilBarrelPerHour: return Value*4.41631375e-5;
+                case VolumeFlowUnit.OilBarrelPerMinute: return Value*2.64978825e-3;
+                case VolumeFlowUnit.OilBarrelPerSecond: return Value/6.28981;
+                case VolumeFlowUnit.UkGallonPerDay: return Value/19005304;
+                case VolumeFlowUnit.UkGallonPerHour: return Value/791887.667;
+                case VolumeFlowUnit.UkGallonPerMinute: return Value/13198.2;
+                case VolumeFlowUnit.UkGallonPerSecond: return Value/219.969;
+                case VolumeFlowUnit.UsGallonPerDay: return Value/22824465.227;
+                case VolumeFlowUnit.UsGallonPerHour: return Value/951019.38848933424;
+                case VolumeFlowUnit.UsGallonPerMinute: return Value/15850.323141489;
+                case VolumeFlowUnit.UsGallonPerSecond: return Value/264.1720523581484;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -1529,16 +1485,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal VolumeFlow ToBaseUnit()
+        internal VolumeFlow<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new VolumeFlow(baseUnitValue, BaseUnit);
+            return new VolumeFlow<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(VolumeFlowUnit unit)
+        private T GetValueAs(VolumeFlowUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -1696,57 +1652,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumeFlow)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumeFlow<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumeFlow)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumeFlow<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumeFlow)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumeFlow<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -1756,33 +1712,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(VolumeFlow))
+            if(conversionType == typeof(VolumeFlow<T>))
                 return this;
             else if(conversionType == typeof(VolumeFlowUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return VolumeFlow.QuantityType;
+                return VolumeFlow<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return VolumeFlow.Info;
+                return VolumeFlow<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return VolumeFlow.BaseDimensions;
+                return VolumeFlow<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(VolumeFlow)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(VolumeFlow<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
index b59c91d8bd..0e3d8d758c 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     Volume, typically of fluid, that a container can hold within a unit of length.
     /// </summary>
-    public partial struct VolumePerLength : IQuantity<VolumePerLengthUnit>, IEquatable<VolumePerLength>, IComparable, IComparable<VolumePerLength>, IConvertible, IFormattable
+    public partial struct VolumePerLength<T> : IQuantityT<VolumePerLengthUnit, T>, IEquatable<VolumePerLength<T>>, IComparable, IComparable<VolumePerLength<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -69,12 +65,12 @@ static VolumePerLength()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public VolumePerLength(double value, VolumePerLengthUnit unit)
+        public VolumePerLength(T value, VolumePerLengthUnit unit)
         {
             if(unit == VolumePerLengthUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -86,14 +82,14 @@ public VolumePerLength(double value, VolumePerLengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VolumePerLength(double value, UnitSystem unitSystem)
+        public VolumePerLength(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -108,19 +104,19 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of VolumePerLength, which is CubicMeterPerMeter. All conversions go via this value.
+        ///     The base unit of <see cref="VolumePerLength{T}" />, which is CubicMeterPerMeter. All conversions go via this value.
         /// </summary>
         public static VolumePerLengthUnit BaseUnit { get; } = VolumePerLengthUnit.CubicMeterPerMeter;
 
         /// <summary>
-        /// Represents the largest possible value of VolumePerLength
+        /// Represents the largest possible value of <see cref="VolumePerLength{T}" />
         /// </summary>
-        public static VolumePerLength MaxValue { get; } = new VolumePerLength(double.MaxValue, BaseUnit);
+        public static VolumePerLength<T> MaxValue { get; } = new VolumePerLength<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of VolumePerLength
+        /// Represents the smallest possible value of <see cref="VolumePerLength{T}" />
         /// </summary>
-        public static VolumePerLength MinValue { get; } = new VolumePerLength(double.MinValue, BaseUnit);
+        public static VolumePerLength<T> MinValue { get; } = new VolumePerLength<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -129,14 +125,14 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.VolumePerLength;
 
         /// <summary>
-        ///     All units of measurement for the VolumePerLength quantity.
+        ///     All units of measurement for the <see cref="VolumePerLength{T}" /> quantity.
         /// </summary>
         public static VolumePerLengthUnit[] Units { get; } = Enum.GetValues(typeof(VolumePerLengthUnit)).Cast<VolumePerLengthUnit>().Except(new VolumePerLengthUnit[]{ VolumePerLengthUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit CubicMeterPerMeter.
         /// </summary>
-        public static VolumePerLength Zero { get; } = new VolumePerLength(0, BaseUnit);
+        public static VolumePerLength<T> Zero { get; } = new VolumePerLength<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -145,7 +141,9 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -161,51 +159,51 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => VolumePerLength.QuantityType;
+        public QuantityType Type => VolumePerLength<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => VolumePerLength.BaseDimensions;
+        public BaseDimensions Dimensions => VolumePerLength<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get VolumePerLength in CubicMetersPerMeter.
+        ///     Get <see cref="VolumePerLength{T}" /> in CubicMetersPerMeter.
         /// </summary>
-        public double CubicMetersPerMeter => As(VolumePerLengthUnit.CubicMeterPerMeter);
+        public T CubicMetersPerMeter => As(VolumePerLengthUnit.CubicMeterPerMeter);
 
         /// <summary>
-        ///     Get VolumePerLength in CubicYardsPerFoot.
+        ///     Get <see cref="VolumePerLength{T}" /> in CubicYardsPerFoot.
         /// </summary>
-        public double CubicYardsPerFoot => As(VolumePerLengthUnit.CubicYardPerFoot);
+        public T CubicYardsPerFoot => As(VolumePerLengthUnit.CubicYardPerFoot);
 
         /// <summary>
-        ///     Get VolumePerLength in CubicYardsPerUsSurveyFoot.
+        ///     Get <see cref="VolumePerLength{T}" /> in CubicYardsPerUsSurveyFoot.
         /// </summary>
-        public double CubicYardsPerUsSurveyFoot => As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+        public T CubicYardsPerUsSurveyFoot => As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
 
         /// <summary>
-        ///     Get VolumePerLength in LitersPerKilometer.
+        ///     Get <see cref="VolumePerLength{T}" /> in LitersPerKilometer.
         /// </summary>
-        public double LitersPerKilometer => As(VolumePerLengthUnit.LiterPerKilometer);
+        public T LitersPerKilometer => As(VolumePerLengthUnit.LiterPerKilometer);
 
         /// <summary>
-        ///     Get VolumePerLength in LitersPerMeter.
+        ///     Get <see cref="VolumePerLength{T}" /> in LitersPerMeter.
         /// </summary>
-        public double LitersPerMeter => As(VolumePerLengthUnit.LiterPerMeter);
+        public T LitersPerMeter => As(VolumePerLengthUnit.LiterPerMeter);
 
         /// <summary>
-        ///     Get VolumePerLength in LitersPerMillimeter.
+        ///     Get <see cref="VolumePerLength{T}" /> in LitersPerMillimeter.
         /// </summary>
-        public double LitersPerMillimeter => As(VolumePerLengthUnit.LiterPerMillimeter);
+        public T LitersPerMillimeter => As(VolumePerLengthUnit.LiterPerMillimeter);
 
         /// <summary>
-        ///     Get VolumePerLength in OilBarrelsPerFoot.
+        ///     Get <see cref="VolumePerLength{T}" /> in OilBarrelsPerFoot.
         /// </summary>
-        public double OilBarrelsPerFoot => As(VolumePerLengthUnit.OilBarrelPerFoot);
+        public T OilBarrelsPerFoot => As(VolumePerLengthUnit.OilBarrelPerFoot);
 
         #endregion
 
@@ -237,78 +235,71 @@ public static string GetAbbreviation(VolumePerLengthUnit unit, IFormatProvider?
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get VolumePerLength from CubicMetersPerMeter.
+        ///     Get <see cref="VolumePerLength{T}" /> from CubicMetersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicMetersPerMeter(QuantityValue cubicmeterspermeter)
+        public static VolumePerLength<T> FromCubicMetersPerMeter(T cubicmeterspermeter)
         {
-            double value = (double) cubicmeterspermeter;
-            return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter);
+            return new VolumePerLength<T>(cubicmeterspermeter, VolumePerLengthUnit.CubicMeterPerMeter);
         }
         /// <summary>
-        ///     Get VolumePerLength from CubicYardsPerFoot.
+        ///     Get <see cref="VolumePerLength{T}" /> from CubicYardsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicYardsPerFoot(QuantityValue cubicyardsperfoot)
+        public static VolumePerLength<T> FromCubicYardsPerFoot(T cubicyardsperfoot)
         {
-            double value = (double) cubicyardsperfoot;
-            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot);
+            return new VolumePerLength<T>(cubicyardsperfoot, VolumePerLengthUnit.CubicYardPerFoot);
         }
         /// <summary>
-        ///     Get VolumePerLength from CubicYardsPerUsSurveyFoot.
+        ///     Get <see cref="VolumePerLength{T}" /> from CubicYardsPerUsSurveyFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(QuantityValue cubicyardsperussurveyfoot)
+        public static VolumePerLength<T> FromCubicYardsPerUsSurveyFoot(T cubicyardsperussurveyfoot)
         {
-            double value = (double) cubicyardsperussurveyfoot;
-            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+            return new VolumePerLength<T>(cubicyardsperussurveyfoot, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
         }
         /// <summary>
-        ///     Get VolumePerLength from LitersPerKilometer.
+        ///     Get <see cref="VolumePerLength{T}" /> from LitersPerKilometer.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerKilometer(QuantityValue litersperkilometer)
+        public static VolumePerLength<T> FromLitersPerKilometer(T litersperkilometer)
         {
-            double value = (double) litersperkilometer;
-            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer);
+            return new VolumePerLength<T>(litersperkilometer, VolumePerLengthUnit.LiterPerKilometer);
         }
         /// <summary>
-        ///     Get VolumePerLength from LitersPerMeter.
+        ///     Get <see cref="VolumePerLength{T}" /> from LitersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerMeter(QuantityValue literspermeter)
+        public static VolumePerLength<T> FromLitersPerMeter(T literspermeter)
         {
-            double value = (double) literspermeter;
-            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter);
+            return new VolumePerLength<T>(literspermeter, VolumePerLengthUnit.LiterPerMeter);
         }
         /// <summary>
-        ///     Get VolumePerLength from LitersPerMillimeter.
+        ///     Get <see cref="VolumePerLength{T}" /> from LitersPerMillimeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerMillimeter(QuantityValue literspermillimeter)
+        public static VolumePerLength<T> FromLitersPerMillimeter(T literspermillimeter)
         {
-            double value = (double) literspermillimeter;
-            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter);
+            return new VolumePerLength<T>(literspermillimeter, VolumePerLengthUnit.LiterPerMillimeter);
         }
         /// <summary>
-        ///     Get VolumePerLength from OilBarrelsPerFoot.
+        ///     Get <see cref="VolumePerLength{T}" /> from OilBarrelsPerFoot.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromOilBarrelsPerFoot(QuantityValue oilbarrelsperfoot)
+        public static VolumePerLength<T> FromOilBarrelsPerFoot(T oilbarrelsperfoot)
         {
-            double value = (double) oilbarrelsperfoot;
-            return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot);
+            return new VolumePerLength<T>(oilbarrelsperfoot, VolumePerLengthUnit.OilBarrelPerFoot);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumePerLengthUnit" /> to <see cref="VolumePerLength" />.
+        ///     Dynamically convert from value and unit enum <see cref="VolumePerLengthUnit" /> to <see cref="VolumePerLength{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumePerLength unit value.</returns>
-        public static VolumePerLength From(QuantityValue value, VolumePerLengthUnit fromUnit)
+        /// <returns><see cref="VolumePerLength{T}" /> unit value.</returns>
+        public static VolumePerLength<T> From(T value, VolumePerLengthUnit fromUnit)
         {
-            return new VolumePerLength((double)value, fromUnit);
+            return new VolumePerLength<T>(value, fromUnit);
         }
 
         #endregion
@@ -337,7 +328,7 @@ public static VolumePerLength From(QuantityValue value, VolumePerLengthUnit from
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static VolumePerLength Parse(string str)
+        public static VolumePerLength<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -365,9 +356,9 @@ public static VolumePerLength Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static VolumePerLength Parse(string str, IFormatProvider? provider)
+        public static VolumePerLength<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<VolumePerLength, VolumePerLengthUnit>(
+            return QuantityParser.Default.Parse<T, VolumePerLength<T>, VolumePerLengthUnit>(
                 str,
                 provider,
                 From);
@@ -381,7 +372,7 @@ public static VolumePerLength Parse(string str, IFormatProvider? provider)
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out VolumePerLength result)
+        public static bool TryParse(string? str, out VolumePerLength<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -396,9 +387,9 @@ public static bool TryParse(string? str, out VolumePerLength result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out VolumePerLength result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out VolumePerLength<T> result)
         {
-            return QuantityParser.Default.TryParse<VolumePerLength, VolumePerLengthUnit>(
+            return QuantityParser.Default.TryParse<T, VolumePerLength<T>, VolumePerLengthUnit>(
                 str,
                 provider,
                 From,
@@ -460,45 +451,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static VolumePerLength operator -(VolumePerLength right)
+        public static VolumePerLength<T> operator -(VolumePerLength<T> right)
         {
-            return new VolumePerLength(-right.Value, right.Unit);
+            return new VolumePerLength<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="VolumePerLength"/> from adding two <see cref="VolumePerLength"/>.</summary>
-        public static VolumePerLength operator +(VolumePerLength left, VolumePerLength right)
+        /// <summary>Get <see cref="VolumePerLength{T}"/> from adding two <see cref="VolumePerLength{T}"/>.</summary>
+        public static VolumePerLength<T> operator +(VolumePerLength<T> left, VolumePerLength<T> right)
         {
-            return new VolumePerLength(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new VolumePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumePerLength"/> from subtracting two <see cref="VolumePerLength"/>.</summary>
-        public static VolumePerLength operator -(VolumePerLength left, VolumePerLength right)
+        /// <summary>Get <see cref="VolumePerLength{T}"/> from subtracting two <see cref="VolumePerLength{T}"/>.</summary>
+        public static VolumePerLength<T> operator -(VolumePerLength<T> left, VolumePerLength<T> right)
         {
-            return new VolumePerLength(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new VolumePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumePerLength"/> from multiplying value and <see cref="VolumePerLength"/>.</summary>
-        public static VolumePerLength operator *(double left, VolumePerLength right)
+        /// <summary>Get <see cref="VolumePerLength{T}"/> from multiplying value and <see cref="VolumePerLength{T}"/>.</summary>
+        public static VolumePerLength<T> operator *(T left, VolumePerLength<T> right)
         {
-            return new VolumePerLength(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new VolumePerLength<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="VolumePerLength"/> from multiplying value and <see cref="VolumePerLength"/>.</summary>
-        public static VolumePerLength operator *(VolumePerLength left, double right)
+        /// <summary>Get <see cref="VolumePerLength{T}"/> from multiplying value and <see cref="VolumePerLength{T}"/>.</summary>
+        public static VolumePerLength<T> operator *(VolumePerLength<T> left, T right)
         {
-            return new VolumePerLength(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new VolumePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="VolumePerLength"/> from dividing <see cref="VolumePerLength"/> by value.</summary>
-        public static VolumePerLength operator /(VolumePerLength left, double right)
+        /// <summary>Get <see cref="VolumePerLength{T}"/> from dividing <see cref="VolumePerLength{T}"/> by value.</summary>
+        public static VolumePerLength<T> operator /(VolumePerLength<T> left, T right)
         {
-            return new VolumePerLength(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new VolumePerLength<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="VolumePerLength"/> by <see cref="VolumePerLength"/>.</summary>
-        public static double operator /(VolumePerLength left, VolumePerLength right)
+        /// <summary>Get ratio value from dividing <see cref="VolumePerLength{T}"/> by <see cref="VolumePerLength{T}"/>.</summary>
+        public static T operator /(VolumePerLength<T> left, VolumePerLength<T> right)
         {
-            return left.CubicMetersPerMeter / right.CubicMetersPerMeter;
+            return CompiledLambdas.Divide(left.CubicMetersPerMeter, right.CubicMetersPerMeter);
         }
 
         #endregion
@@ -506,39 +502,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(VolumePerLength left, VolumePerLength right)
+        public static bool operator <=(VolumePerLength<T> left, VolumePerLength<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(VolumePerLength left, VolumePerLength right)
+        public static bool operator >=(VolumePerLength<T> left, VolumePerLength<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(VolumePerLength left, VolumePerLength right)
+        public static bool operator <(VolumePerLength<T> left, VolumePerLength<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(VolumePerLength left, VolumePerLength right)
+        public static bool operator >(VolumePerLength<T> left, VolumePerLength<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VolumePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(VolumePerLength left, VolumePerLength right)
+        /// <remarks>Consider using <see cref="Equals(VolumePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(VolumePerLength<T> left, VolumePerLength<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(VolumePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(VolumePerLength left, VolumePerLength right)
+        /// <remarks>Consider using <see cref="Equals(VolumePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(VolumePerLength<T> left, VolumePerLength<T> right)
         {
             return !(left == right);
         }
@@ -547,37 +543,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Volum
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is VolumePerLength objVolumePerLength)) throw new ArgumentException("Expected type VolumePerLength.", nameof(obj));
+            if(!(obj is VolumePerLength<T> objVolumePerLength)) throw new ArgumentException("Expected type VolumePerLength.", nameof(obj));
 
             return CompareTo(objVolumePerLength);
         }
 
         /// <inheritdoc />
-        public int CompareTo(VolumePerLength other)
+        public int CompareTo(VolumePerLength<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VolumePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(VolumePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is VolumePerLength objVolumePerLength))
+            if(obj is null || !(obj is VolumePerLength<T> objVolumePerLength))
                 return false;
 
             return Equals(objVolumePerLength);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(VolumePerLength, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(VolumePerLength other)
+        /// <remarks>Consider using <see cref="Equals(VolumePerLength{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(VolumePerLength<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another VolumePerLength within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="VolumePerLength{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -615,21 +611,19 @@ public bool Equals(VolumePerLength other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(VolumePerLength other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(VolumePerLength<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current VolumePerLength.</returns>
+        /// <returns>A hash code for the current <see cref="VolumePerLength{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -643,17 +637,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumePerLengthUnit unit)
+        public T As(VolumePerLengthUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -673,17 +667,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is VolumePerLengthUnit unitAsVolumePerLengthUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumePerLengthUnit)} is supported.", nameof(unit));
 
-            return As(unitAsVolumePerLengthUnit);
+            var asValue = As(unitAsVolumePerLengthUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<VolumePerLengthUnit>.As(VolumePerLengthUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this VolumePerLength to another VolumePerLength with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="VolumePerLength{T}" /> to another <see cref="VolumePerLength{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A VolumePerLength with the specified unit.</returns>
-        public VolumePerLength ToUnit(VolumePerLengthUnit unit)
+        /// <returns>A <see cref="VolumePerLength{T}" /> with the specified unit.</returns>
+        public VolumePerLength<T> ToUnit(VolumePerLengthUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new VolumePerLength(convertedValue, unit);
+            return new VolumePerLength<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -696,7 +695,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public VolumePerLength ToUnit(UnitSystem unitSystem)
+        public VolumePerLength<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -716,25 +715,31 @@ public VolumePerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumePerLengthUnit> IQuantity<VolumePerLengthUnit>.ToUnit(VolumePerLengthUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<VolumePerLengthUnit, T> IQuantityT<VolumePerLengthUnit, T>.ToUnit(VolumePerLengthUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<VolumePerLengthUnit> IQuantity<VolumePerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<VolumePerLengthUnit, T> IQuantityT<VolumePerLengthUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case VolumePerLengthUnit.CubicMeterPerMeter: return _value;
-                case VolumePerLengthUnit.CubicYardPerFoot: return _value*2.50838208;
-                case VolumePerLengthUnit.CubicYardPerUsSurveyFoot: return _value*2.50837706323584;
-                case VolumePerLengthUnit.LiterPerKilometer: return _value/1e6;
-                case VolumePerLengthUnit.LiterPerMeter: return _value/1000;
-                case VolumePerLengthUnit.LiterPerMillimeter: return _value;
-                case VolumePerLengthUnit.OilBarrelPerFoot: return _value/1.91713408;
+                case VolumePerLengthUnit.CubicMeterPerMeter: return Value;
+                case VolumePerLengthUnit.CubicYardPerFoot: return Value*2.50838208;
+                case VolumePerLengthUnit.CubicYardPerUsSurveyFoot: return Value*2.50837706323584;
+                case VolumePerLengthUnit.LiterPerKilometer: return Value/1e6;
+                case VolumePerLengthUnit.LiterPerMeter: return Value/1000;
+                case VolumePerLengthUnit.LiterPerMillimeter: return Value;
+                case VolumePerLengthUnit.OilBarrelPerFoot: return Value/1.91713408;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -745,16 +750,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal VolumePerLength ToBaseUnit()
+        internal VolumePerLength<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new VolumePerLength(baseUnitValue, BaseUnit);
+            return new VolumePerLength<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(VolumePerLengthUnit unit)
+        private T GetValueAs(VolumePerLengthUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -863,57 +868,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumePerLength)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumePerLength<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumePerLength)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumePerLength<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(VolumePerLength)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(VolumePerLength<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -923,33 +928,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(VolumePerLength))
+            if(conversionType == typeof(VolumePerLength<T>))
                 return this;
             else if(conversionType == typeof(VolumePerLengthUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return VolumePerLength.QuantityType;
+                return VolumePerLength<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return VolumePerLength.Info;
+                return VolumePerLength<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return VolumePerLength.BaseDimensions;
+                return VolumePerLength<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(VolumePerLength)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(VolumePerLength<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
index 3f2ec630e1..f5f06106b7 100644
--- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
@@ -34,13 +34,9 @@ namespace UnitsNet
     /// <summary>
     ///     A geometric property of an area that is used to determine the warping stress.
     /// </summary>
-    public partial struct WarpingMomentOfInertia : IQuantity<WarpingMomentOfInertiaUnit>, IEquatable<WarpingMomentOfInertia>, IComparable, IComparable<WarpingMomentOfInertia>, IConvertible, IFormattable
+    public partial struct WarpingMomentOfInertia<T> : IQuantityT<WarpingMomentOfInertiaUnit, T>, IEquatable<WarpingMomentOfInertia<T>>, IComparable, IComparable<WarpingMomentOfInertia<T>>, IConvertible, IFormattable
+        where T : struct
     {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
         /// <summary>
         ///     The unit this quantity was constructed with.
         /// </summary>
@@ -68,12 +64,12 @@ static WarpingMomentOfInertia()
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public WarpingMomentOfInertia(double value, WarpingMomentOfInertiaUnit unit)
+        public WarpingMomentOfInertia(T value, WarpingMomentOfInertiaUnit unit)
         {
             if(unit == WarpingMomentOfInertiaUnit.Undefined)
               throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = unit;
         }
 
@@ -85,14 +81,14 @@ public WarpingMomentOfInertia(double value, WarpingMomentOfInertiaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
+        public WarpingMomentOfInertia(T value, UnitSystem unitSystem)
         {
             if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
             var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits);
             var firstUnitInfo = unitInfos.FirstOrDefault();
 
-            _value = Guard.EnsureValidNumber(value, nameof(value));
+            Value = value;
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
         }
 
@@ -107,19 +103,19 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
         public static BaseDimensions BaseDimensions { get; }
 
         /// <summary>
-        ///     The base unit of WarpingMomentOfInertia, which is MeterToTheSixth. All conversions go via this value.
+        ///     The base unit of <see cref="WarpingMomentOfInertia{T}" />, which is MeterToTheSixth. All conversions go via this value.
         /// </summary>
         public static WarpingMomentOfInertiaUnit BaseUnit { get; } = WarpingMomentOfInertiaUnit.MeterToTheSixth;
 
         /// <summary>
-        /// Represents the largest possible value of WarpingMomentOfInertia
+        /// Represents the largest possible value of <see cref="WarpingMomentOfInertia{T}" />
         /// </summary>
-        public static WarpingMomentOfInertia MaxValue { get; } = new WarpingMomentOfInertia(double.MaxValue, BaseUnit);
+        public static WarpingMomentOfInertia<T> MaxValue { get; } = new WarpingMomentOfInertia<T>(GenericNumberHelper<T>.MaxValue, BaseUnit);
 
         /// <summary>
-        /// Represents the smallest possible value of WarpingMomentOfInertia
+        /// Represents the smallest possible value of <see cref="WarpingMomentOfInertia{T}" />
         /// </summary>
-        public static WarpingMomentOfInertia MinValue { get; } = new WarpingMomentOfInertia(double.MinValue, BaseUnit);
+        public static WarpingMomentOfInertia<T> MinValue { get; } = new WarpingMomentOfInertia<T>(GenericNumberHelper<T>.MinValue, BaseUnit);
 
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
@@ -128,14 +124,14 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
         public static QuantityType QuantityType { get; } = QuantityType.WarpingMomentOfInertia;
 
         /// <summary>
-        ///     All units of measurement for the WarpingMomentOfInertia quantity.
+        ///     All units of measurement for the <see cref="WarpingMomentOfInertia{T}" /> quantity.
         /// </summary>
         public static WarpingMomentOfInertiaUnit[] Units { get; } = Enum.GetValues(typeof(WarpingMomentOfInertiaUnit)).Cast<WarpingMomentOfInertiaUnit>().Except(new WarpingMomentOfInertiaUnit[]{ WarpingMomentOfInertiaUnit.Undefined }).ToArray();
 
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit MeterToTheSixth.
         /// </summary>
-        public static WarpingMomentOfInertia Zero { get; } = new WarpingMomentOfInertia(0, BaseUnit);
+        public static WarpingMomentOfInertia<T> Zero { get; } = new WarpingMomentOfInertia<T>(default(T), BaseUnit);
 
         #endregion
 
@@ -144,7 +140,9 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public double Value => _value;
+        public T Value{ get; }
+
+        double IQuantity.Value => Convert.ToDouble(Value);
 
         Enum IQuantity.Unit => Unit;
 
@@ -160,46 +158,46 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="QuantityType" /> of this quantity.
         /// </summary>
-        public QuantityType Type => WarpingMomentOfInertia.QuantityType;
+        public QuantityType Type => WarpingMomentOfInertia<T>.QuantityType;
 
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
-        public BaseDimensions Dimensions => WarpingMomentOfInertia.BaseDimensions;
+        public BaseDimensions Dimensions => WarpingMomentOfInertia<T>.BaseDimensions;
 
         #endregion
 
         #region Conversion Properties
 
         /// <summary>
-        ///     Get WarpingMomentOfInertia in CentimetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> in CentimetersToTheSixth.
         /// </summary>
-        public double CentimetersToTheSixth => As(WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
+        public T CentimetersToTheSixth => As(WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
 
         /// <summary>
-        ///     Get WarpingMomentOfInertia in DecimetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> in DecimetersToTheSixth.
         /// </summary>
-        public double DecimetersToTheSixth => As(WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
+        public T DecimetersToTheSixth => As(WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
 
         /// <summary>
-        ///     Get WarpingMomentOfInertia in FeetToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> in FeetToTheSixth.
         /// </summary>
-        public double FeetToTheSixth => As(WarpingMomentOfInertiaUnit.FootToTheSixth);
+        public T FeetToTheSixth => As(WarpingMomentOfInertiaUnit.FootToTheSixth);
 
         /// <summary>
-        ///     Get WarpingMomentOfInertia in InchesToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> in InchesToTheSixth.
         /// </summary>
-        public double InchesToTheSixth => As(WarpingMomentOfInertiaUnit.InchToTheSixth);
+        public T InchesToTheSixth => As(WarpingMomentOfInertiaUnit.InchToTheSixth);
 
         /// <summary>
-        ///     Get WarpingMomentOfInertia in MetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> in MetersToTheSixth.
         /// </summary>
-        public double MetersToTheSixth => As(WarpingMomentOfInertiaUnit.MeterToTheSixth);
+        public T MetersToTheSixth => As(WarpingMomentOfInertiaUnit.MeterToTheSixth);
 
         /// <summary>
-        ///     Get WarpingMomentOfInertia in MillimetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> in MillimetersToTheSixth.
         /// </summary>
-        public double MillimetersToTheSixth => As(WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
+        public T MillimetersToTheSixth => As(WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
 
         #endregion
 
@@ -231,69 +229,63 @@ public static string GetAbbreviation(WarpingMomentOfInertiaUnit unit, IFormatPro
         #region Static Factory Methods
 
         /// <summary>
-        ///     Get WarpingMomentOfInertia from CentimetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> from CentimetersToTheSixth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromCentimetersToTheSixth(QuantityValue centimeterstothesixth)
+        public static WarpingMomentOfInertia<T> FromCentimetersToTheSixth(T centimeterstothesixth)
         {
-            double value = (double) centimeterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
+            return new WarpingMomentOfInertia<T>(centimeterstothesixth, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
         }
         /// <summary>
-        ///     Get WarpingMomentOfInertia from DecimetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> from DecimetersToTheSixth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromDecimetersToTheSixth(QuantityValue decimeterstothesixth)
+        public static WarpingMomentOfInertia<T> FromDecimetersToTheSixth(T decimeterstothesixth)
         {
-            double value = (double) decimeterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
+            return new WarpingMomentOfInertia<T>(decimeterstothesixth, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
         }
         /// <summary>
-        ///     Get WarpingMomentOfInertia from FeetToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> from FeetToTheSixth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromFeetToTheSixth(QuantityValue feettothesixth)
+        public static WarpingMomentOfInertia<T> FromFeetToTheSixth(T feettothesixth)
         {
-            double value = (double) feettothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth);
+            return new WarpingMomentOfInertia<T>(feettothesixth, WarpingMomentOfInertiaUnit.FootToTheSixth);
         }
         /// <summary>
-        ///     Get WarpingMomentOfInertia from InchesToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> from InchesToTheSixth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromInchesToTheSixth(QuantityValue inchestothesixth)
+        public static WarpingMomentOfInertia<T> FromInchesToTheSixth(T inchestothesixth)
         {
-            double value = (double) inchestothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth);
+            return new WarpingMomentOfInertia<T>(inchestothesixth, WarpingMomentOfInertiaUnit.InchToTheSixth);
         }
         /// <summary>
-        ///     Get WarpingMomentOfInertia from MetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> from MetersToTheSixth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromMetersToTheSixth(QuantityValue meterstothesixth)
+        public static WarpingMomentOfInertia<T> FromMetersToTheSixth(T meterstothesixth)
         {
-            double value = (double) meterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth);
+            return new WarpingMomentOfInertia<T>(meterstothesixth, WarpingMomentOfInertiaUnit.MeterToTheSixth);
         }
         /// <summary>
-        ///     Get WarpingMomentOfInertia from MillimetersToTheSixth.
+        ///     Get <see cref="WarpingMomentOfInertia{T}" /> from MillimetersToTheSixth.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromMillimetersToTheSixth(QuantityValue millimeterstothesixth)
+        public static WarpingMomentOfInertia<T> FromMillimetersToTheSixth(T millimeterstothesixth)
         {
-            double value = (double) millimeterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
+            return new WarpingMomentOfInertia<T>(millimeterstothesixth, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
         }
 
         /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="WarpingMomentOfInertiaUnit" /> to <see cref="WarpingMomentOfInertia" />.
+        ///     Dynamically convert from value and unit enum <see cref="WarpingMomentOfInertiaUnit" /> to <see cref="WarpingMomentOfInertia{T}" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>WarpingMomentOfInertia unit value.</returns>
-        public static WarpingMomentOfInertia From(QuantityValue value, WarpingMomentOfInertiaUnit fromUnit)
+        /// <returns><see cref="WarpingMomentOfInertia{T}" /> unit value.</returns>
+        public static WarpingMomentOfInertia<T> From(T value, WarpingMomentOfInertiaUnit fromUnit)
         {
-            return new WarpingMomentOfInertia((double)value, fromUnit);
+            return new WarpingMomentOfInertia<T>(value, fromUnit);
         }
 
         #endregion
@@ -322,7 +314,7 @@ public static WarpingMomentOfInertia From(QuantityValue value, WarpingMomentOfIn
         ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
-        public static WarpingMomentOfInertia Parse(string str)
+        public static WarpingMomentOfInertia<T> Parse(string str)
         {
             return Parse(str, null);
         }
@@ -350,9 +342,9 @@ public static WarpingMomentOfInertia Parse(string str)
         ///     Units.NET exceptions from other exceptions.
         /// </exception>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static WarpingMomentOfInertia Parse(string str, IFormatProvider? provider)
+        public static WarpingMomentOfInertia<T> Parse(string str, IFormatProvider? provider)
         {
-            return QuantityParser.Default.Parse<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(
+            return QuantityParser.Default.Parse<T, WarpingMomentOfInertia<T>, WarpingMomentOfInertiaUnit>(
                 str,
                 provider,
                 From);
@@ -366,7 +358,7 @@ public static WarpingMomentOfInertia Parse(string str, IFormatProvider? provider
         /// <example>
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
-        public static bool TryParse(string? str, out WarpingMomentOfInertia result)
+        public static bool TryParse(string? str, out WarpingMomentOfInertia<T> result)
         {
             return TryParse(str, null, out result);
         }
@@ -381,9 +373,9 @@ public static bool TryParse(string? str, out WarpingMomentOfInertia result)
         ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
         /// </example>
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        public static bool TryParse(string? str, IFormatProvider? provider, out WarpingMomentOfInertia result)
+        public static bool TryParse(string? str, IFormatProvider? provider, out WarpingMomentOfInertia<T> result)
         {
-            return QuantityParser.Default.TryParse<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(
+            return QuantityParser.Default.TryParse<T, WarpingMomentOfInertia<T>, WarpingMomentOfInertiaUnit>(
                 str,
                 provider,
                 From,
@@ -445,45 +437,50 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Warpi
         #region Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static WarpingMomentOfInertia operator -(WarpingMomentOfInertia right)
+        public static WarpingMomentOfInertia<T> operator -(WarpingMomentOfInertia<T> right)
         {
-            return new WarpingMomentOfInertia(-right.Value, right.Unit);
+            return new WarpingMomentOfInertia<T>(CompiledLambdas.Negate(right.Value), right.Unit);
         }
 
-        /// <summary>Get <see cref="WarpingMomentOfInertia"/> from adding two <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static WarpingMomentOfInertia operator +(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        /// <summary>Get <see cref="WarpingMomentOfInertia{T}"/> from adding two <see cref="WarpingMomentOfInertia{T}"/>.</summary>
+        public static WarpingMomentOfInertia<T> operator +(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
-            return new WarpingMomentOfInertia(left.Value + right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Add(left.Value, right.GetValueAs(left.Unit));
+            return new WarpingMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="WarpingMomentOfInertia"/> from subtracting two <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static WarpingMomentOfInertia operator -(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        /// <summary>Get <see cref="WarpingMomentOfInertia{T}"/> from subtracting two <see cref="WarpingMomentOfInertia{T}"/>.</summary>
+        public static WarpingMomentOfInertia<T> operator -(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
-            return new WarpingMomentOfInertia(left.Value - right.GetValueAs(left.Unit), left.Unit);
+            var value = CompiledLambdas.Subtract(left.Value, right.GetValueAs(left.Unit));
+            return new WarpingMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="WarpingMomentOfInertia"/> from multiplying value and <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static WarpingMomentOfInertia operator *(double left, WarpingMomentOfInertia right)
+        /// <summary>Get <see cref="WarpingMomentOfInertia{T}"/> from multiplying value and <see cref="WarpingMomentOfInertia{T}"/>.</summary>
+        public static WarpingMomentOfInertia<T> operator *(T left, WarpingMomentOfInertia<T> right)
         {
-            return new WarpingMomentOfInertia(left * right.Value, right.Unit);
+            var value = CompiledLambdas.Multiply(left, right.Value);
+            return new WarpingMomentOfInertia<T>(value, right.Unit);
         }
 
-        /// <summary>Get <see cref="WarpingMomentOfInertia"/> from multiplying value and <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static WarpingMomentOfInertia operator *(WarpingMomentOfInertia left, double right)
+        /// <summary>Get <see cref="WarpingMomentOfInertia{T}"/> from multiplying value and <see cref="WarpingMomentOfInertia{T}"/>.</summary>
+        public static WarpingMomentOfInertia<T> operator *(WarpingMomentOfInertia<T> left, T right)
         {
-            return new WarpingMomentOfInertia(left.Value * right, left.Unit);
+            var value = CompiledLambdas.Multiply(left.Value, right);
+            return new WarpingMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get <see cref="WarpingMomentOfInertia"/> from dividing <see cref="WarpingMomentOfInertia"/> by value.</summary>
-        public static WarpingMomentOfInertia operator /(WarpingMomentOfInertia left, double right)
+        /// <summary>Get <see cref="WarpingMomentOfInertia{T}"/> from dividing <see cref="WarpingMomentOfInertia{T}"/> by value.</summary>
+        public static WarpingMomentOfInertia<T> operator /(WarpingMomentOfInertia<T> left, T right)
         {
-            return new WarpingMomentOfInertia(left.Value / right, left.Unit);
+            var value = CompiledLambdas.Divide(left.Value, right);
+            return new WarpingMomentOfInertia<T>(value, left.Unit);
         }
 
-        /// <summary>Get ratio value from dividing <see cref="WarpingMomentOfInertia"/> by <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static double operator /(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        /// <summary>Get ratio value from dividing <see cref="WarpingMomentOfInertia{T}"/> by <see cref="WarpingMomentOfInertia{T}"/>.</summary>
+        public static T operator /(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
-            return left.MetersToTheSixth / right.MetersToTheSixth;
+            return CompiledLambdas.Divide(left.MetersToTheSixth, right.MetersToTheSixth);
         }
 
         #endregion
@@ -491,39 +488,39 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Warpi
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
-        public static bool operator <=(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        public static bool operator <=(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
-            return left.Value <= right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
-        public static bool operator >=(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        public static bool operator >=(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
-            return left.Value >= right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThanOrEqual(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if less than.</summary>
-        public static bool operator <(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        public static bool operator <(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
-            return left.Value < right.GetValueAs(left.Unit);
+            return CompiledLambdas.LessThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if greater than.</summary>
-        public static bool operator >(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        public static bool operator >(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
-            return left.Value > right.GetValueAs(left.Unit);
+            return CompiledLambdas.GreaterThan(left.Value, right.GetValueAs(left.Unit));
         }
 
         /// <summary>Returns true if exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator ==(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator ==(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
             return left.Equals(right);
         }
 
         /// <summary>Returns true if not exactly equal.</summary>
-        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public static bool operator !=(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public static bool operator !=(WarpingMomentOfInertia<T> left, WarpingMomentOfInertia<T> right)
         {
             return !(left == right);
         }
@@ -532,37 +529,37 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Warpi
         public int CompareTo(object obj)
         {
             if(obj is null) throw new ArgumentNullException(nameof(obj));
-            if(!(obj is WarpingMomentOfInertia objWarpingMomentOfInertia)) throw new ArgumentException("Expected type WarpingMomentOfInertia.", nameof(obj));
+            if(!(obj is WarpingMomentOfInertia<T> objWarpingMomentOfInertia)) throw new ArgumentException("Expected type WarpingMomentOfInertia.", nameof(obj));
 
             return CompareTo(objWarpingMomentOfInertia);
         }
 
         /// <inheritdoc />
-        public int CompareTo(WarpingMomentOfInertia other)
+        public int CompareTo(WarpingMomentOfInertia<T> other)
         {
-            return _value.CompareTo(other.GetValueAs(this.Unit));
+            return System.Collections.Generic.Comparer<T>.Default.Compare(Value, other.GetValueAs(this.Unit));
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
         public override bool Equals(object obj)
         {
-            if(obj is null || !(obj is WarpingMomentOfInertia objWarpingMomentOfInertia))
+            if(obj is null || !(obj is WarpingMomentOfInertia<T> objWarpingMomentOfInertia))
                 return false;
 
             return Equals(objWarpingMomentOfInertia);
         }
 
         /// <inheritdoc />
-        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
-        public bool Equals(WarpingMomentOfInertia other)
+        /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia{T}, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
+        public bool Equals(WarpingMomentOfInertia<T> other)
         {
-            return _value.Equals(other.GetValueAs(this.Unit));
+            return Value.Equals(other.GetValueAs(this.Unit));
         }
 
         /// <summary>
         ///     <para>
-        ///     Compare equality to another WarpingMomentOfInertia within the given absolute or relative tolerance.
+        ///     Compare equality to another <see cref="WarpingMomentOfInertia{T}" /> within the given absolute or relative tolerance.
         ///     </para>
         ///     <para>
         ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
@@ -600,21 +597,19 @@ public bool Equals(WarpingMomentOfInertia other)
         /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals(WarpingMomentOfInertia other, double tolerance, ComparisonType comparisonType)
+        public bool Equals(WarpingMomentOfInertia<T> other, T tolerance, ComparisonType comparisonType)
         {
-            if(tolerance < 0)
-                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");
-
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            if (CompiledLambdas.LessThan(tolerance, 0))
+                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
 
-            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
+            var otherValueInThisUnits = other.As(this.Unit);
+            return UnitsNet.Comparison.Equals(Value, otherValueInThisUnits, tolerance, comparisonType);
         }
 
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
-        /// <returns>A hash code for the current WarpingMomentOfInertia.</returns>
+        /// <returns>A hash code for the current <see cref="WarpingMomentOfInertia{T}" />.</returns>
         public override int GetHashCode()
         {
             return new { Info.Name, Value, Unit }.GetHashCode();
@@ -628,17 +623,17 @@ public override int GetHashCode()
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As(WarpingMomentOfInertiaUnit unit)
+        public T As(WarpingMomentOfInertiaUnit unit)
         {
             if(Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
 
             var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            return converted;
         }
 
         /// <inheritdoc cref="IQuantity.As(UnitSystem)"/>
-        public double As(UnitSystem unitSystem)
+        public T As(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -658,17 +653,22 @@ double IQuantity.As(Enum unit)
             if(!(unit is WarpingMomentOfInertiaUnit unitAsWarpingMomentOfInertiaUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(WarpingMomentOfInertiaUnit)} is supported.", nameof(unit));
 
-            return As(unitAsWarpingMomentOfInertiaUnit);
+            var asValue = As(unitAsWarpingMomentOfInertiaUnit);
+            return Convert.ToDouble(asValue);
         }
 
+        double IQuantity.As(UnitSystem unitSystem) => Convert.ToDouble(As(unitSystem));
+
+        double IQuantity<WarpingMomentOfInertiaUnit>.As(WarpingMomentOfInertiaUnit unit) => Convert.ToDouble(As(unit));
+
         /// <summary>
-        ///     Converts this WarpingMomentOfInertia to another WarpingMomentOfInertia with the unit representation <paramref name="unit" />.
+        ///     Converts this <see cref="WarpingMomentOfInertia{T}" /> to another <see cref="WarpingMomentOfInertia{T}" /> with the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>A WarpingMomentOfInertia with the specified unit.</returns>
-        public WarpingMomentOfInertia ToUnit(WarpingMomentOfInertiaUnit unit)
+        /// <returns>A <see cref="WarpingMomentOfInertia{T}" /> with the specified unit.</returns>
+        public WarpingMomentOfInertia<T> ToUnit(WarpingMomentOfInertiaUnit unit)
         {
             var convertedValue = GetValueAs(unit);
-            return new WarpingMomentOfInertia(convertedValue, unit);
+            return new WarpingMomentOfInertia<T>(convertedValue, unit);
         }
 
         /// <inheritdoc />
@@ -681,7 +681,7 @@ IQuantity IQuantity.ToUnit(Enum unit)
         }
 
         /// <inheritdoc cref="IQuantity.ToUnit(UnitSystem)"/>
-        public WarpingMomentOfInertia ToUnit(UnitSystem unitSystem)
+        public WarpingMomentOfInertia<T> ToUnit(UnitSystem unitSystem)
         {
             if(unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -701,24 +701,30 @@ public WarpingMomentOfInertia ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<WarpingMomentOfInertiaUnit> IQuantity<WarpingMomentOfInertiaUnit>.ToUnit(WarpingMomentOfInertiaUnit unit) => ToUnit(unit);
 
+        /// <inheritdoc />
+        IQuantityT<WarpingMomentOfInertiaUnit, T> IQuantityT<WarpingMomentOfInertiaUnit, T>.ToUnit(WarpingMomentOfInertiaUnit unit) => ToUnit(unit);
+
         /// <inheritdoc />
         IQuantity<WarpingMomentOfInertiaUnit> IQuantity<WarpingMomentOfInertiaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
+        /// <inheritdoc />
+        IQuantityT<WarpingMomentOfInertiaUnit, T> IQuantityT<WarpingMomentOfInertiaUnit, T>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+
         /// <summary>
         ///     Converts the current value + unit to the base unit.
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double GetValueInBaseUnit()
+        private T GetValueInBaseUnit()
         {
             switch(Unit)
             {
-                case WarpingMomentOfInertiaUnit.CentimeterToTheSixth: return _value/1e12;
-                case WarpingMomentOfInertiaUnit.DecimeterToTheSixth: return _value/1e6;
-                case WarpingMomentOfInertiaUnit.FootToTheSixth: return _value*Math.Pow(0.3048, 6);
-                case WarpingMomentOfInertiaUnit.InchToTheSixth: return _value*Math.Pow(2.54e-2, 6);
-                case WarpingMomentOfInertiaUnit.MeterToTheSixth: return _value;
-                case WarpingMomentOfInertiaUnit.MillimeterToTheSixth: return _value/1e18;
+                case WarpingMomentOfInertiaUnit.CentimeterToTheSixth: return Value/1e12;
+                case WarpingMomentOfInertiaUnit.DecimeterToTheSixth: return Value/1e6;
+                case WarpingMomentOfInertiaUnit.FootToTheSixth: return Value*Math.Pow(0.3048, 6);
+                case WarpingMomentOfInertiaUnit.InchToTheSixth: return Value*Math.Pow(2.54e-2, 6);
+                case WarpingMomentOfInertiaUnit.MeterToTheSixth: return Value;
+                case WarpingMomentOfInertiaUnit.MillimeterToTheSixth: return Value/1e18;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -729,16 +735,16 @@ private double GetValueInBaseUnit()
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        internal WarpingMomentOfInertia ToBaseUnit()
+        internal WarpingMomentOfInertia<T> ToBaseUnit()
         {
             var baseUnitValue = GetValueInBaseUnit();
-            return new WarpingMomentOfInertia(baseUnitValue, BaseUnit);
+            return new WarpingMomentOfInertia<T>(baseUnitValue, BaseUnit);
         }
 
-        private double GetValueAs(WarpingMomentOfInertiaUnit unit)
+        private T GetValueAs(WarpingMomentOfInertiaUnit unit)
         {
             if(Unit == unit)
-                return _value;
+                return Value;
 
             var baseUnitValue = GetValueInBaseUnit();
 
@@ -846,57 +852,57 @@ TypeCode IConvertible.GetTypeCode()
 
         bool IConvertible.ToBoolean(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia)} to bool is not supported.");
+            throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia<T>)} to bool is not supported.");
         }
 
         byte IConvertible.ToByte(IFormatProvider provider)
         {
-            return Convert.ToByte(_value);
+            return Convert.ToByte(Value);
         }
 
         char IConvertible.ToChar(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia)} to char is not supported.");
+            throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia<T>)} to char is not supported.");
         }
 
         DateTime IConvertible.ToDateTime(IFormatProvider provider)
         {
-            throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia)} to DateTime is not supported.");
+            throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia<T>)} to DateTime is not supported.");
         }
 
         decimal IConvertible.ToDecimal(IFormatProvider provider)
         {
-            return Convert.ToDecimal(_value);
+            return Convert.ToDecimal(Value);
         }
 
         double IConvertible.ToDouble(IFormatProvider provider)
         {
-            return Convert.ToDouble(_value);
+            return Convert.ToDouble(Value);
         }
 
         short IConvertible.ToInt16(IFormatProvider provider)
         {
-            return Convert.ToInt16(_value);
+            return Convert.ToInt16(Value);
         }
 
         int IConvertible.ToInt32(IFormatProvider provider)
         {
-            return Convert.ToInt32(_value);
+            return Convert.ToInt32(Value);
         }
 
         long IConvertible.ToInt64(IFormatProvider provider)
         {
-            return Convert.ToInt64(_value);
+            return Convert.ToInt64(Value);
         }
 
         sbyte IConvertible.ToSByte(IFormatProvider provider)
         {
-            return Convert.ToSByte(_value);
+            return Convert.ToSByte(Value);
         }
 
         float IConvertible.ToSingle(IFormatProvider provider)
         {
-            return Convert.ToSingle(_value);
+            return Convert.ToSingle(Value);
         }
 
         string IConvertible.ToString(IFormatProvider provider)
@@ -906,33 +912,33 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            if(conversionType == typeof(WarpingMomentOfInertia))
+            if(conversionType == typeof(WarpingMomentOfInertia<T>))
                 return this;
             else if(conversionType == typeof(WarpingMomentOfInertiaUnit))
                 return Unit;
             else if(conversionType == typeof(QuantityType))
-                return WarpingMomentOfInertia.QuantityType;
+                return WarpingMomentOfInertia<T>.QuantityType;
             else if(conversionType == typeof(QuantityInfo))
-                return WarpingMomentOfInertia.Info;
+                return WarpingMomentOfInertia<T>.Info;
             else if(conversionType == typeof(BaseDimensions))
-                return WarpingMomentOfInertia.BaseDimensions;
+                return WarpingMomentOfInertia<T>.BaseDimensions;
             else
-                throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia)} to {conversionType} is not supported.");
+                throw new InvalidCastException($"Converting {typeof(WarpingMomentOfInertia<T>)} to {conversionType} is not supported.");
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
         {
-            return Convert.ToUInt16(_value);
+            return Convert.ToUInt16(Value);
         }
 
         uint IConvertible.ToUInt32(IFormatProvider provider)
         {
-            return Convert.ToUInt32(_value);
+            return Convert.ToUInt32(Value);
         }
 
         ulong IConvertible.ToUInt64(IFormatProvider provider)
         {
-            return Convert.ToUInt64(_value);
+            return Convert.ToUInt64(Value);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantity.g.cs b/UnitsNet/GeneratedCode/Quantity.g.cs
index e81bf8a27a..a308985d91 100644
--- a/UnitsNet/GeneratedCode/Quantity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantity.g.cs
@@ -261,218 +261,218 @@ public static partial class Quantity
         /// <param name="value">The value to construct the quantity with.</param>
         /// <returns>The created quantity.</returns>
         [Obsolete("QuantityType will be removed. Use FromQuantityInfo(QuantityInfo, QuantityValue) instead.")]
-        public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValue value)
+        public static IQuantity FromQuantityType<T>(QuantityType quantityType, QuantityValue value)
         {
             switch(quantityType)
             {
                 case QuantityType.Acceleration:
-                    return Acceleration.From(value, Acceleration.BaseUnit);
+                    return Acceleration<T>.From(value, Acceleration<T>.BaseUnit);
                 case QuantityType.AmountOfSubstance:
-                    return AmountOfSubstance.From(value, AmountOfSubstance.BaseUnit);
+                    return AmountOfSubstance<T>.From(value, AmountOfSubstance<T>.BaseUnit);
                 case QuantityType.AmplitudeRatio:
-                    return AmplitudeRatio.From(value, AmplitudeRatio.BaseUnit);
+                    return AmplitudeRatio<T>.From(value, AmplitudeRatio<T>.BaseUnit);
                 case QuantityType.Angle:
-                    return Angle.From(value, Angle.BaseUnit);
+                    return Angle<T>.From(value, Angle<T>.BaseUnit);
                 case QuantityType.ApparentEnergy:
-                    return ApparentEnergy.From(value, ApparentEnergy.BaseUnit);
+                    return ApparentEnergy<T>.From(value, ApparentEnergy<T>.BaseUnit);
                 case QuantityType.ApparentPower:
-                    return ApparentPower.From(value, ApparentPower.BaseUnit);
+                    return ApparentPower<T>.From(value, ApparentPower<T>.BaseUnit);
                 case QuantityType.Area:
-                    return Area.From(value, Area.BaseUnit);
+                    return Area<T>.From(value, Area<T>.BaseUnit);
                 case QuantityType.AreaDensity:
-                    return AreaDensity.From(value, AreaDensity.BaseUnit);
+                    return AreaDensity<T>.From(value, AreaDensity<T>.BaseUnit);
                 case QuantityType.AreaMomentOfInertia:
-                    return AreaMomentOfInertia.From(value, AreaMomentOfInertia.BaseUnit);
+                    return AreaMomentOfInertia<T>.From(value, AreaMomentOfInertia<T>.BaseUnit);
                 case QuantityType.BitRate:
-                    return BitRate.From(value, BitRate.BaseUnit);
+                    return BitRate<T>.From(value, BitRate<T>.BaseUnit);
                 case QuantityType.BrakeSpecificFuelConsumption:
-                    return BrakeSpecificFuelConsumption.From(value, BrakeSpecificFuelConsumption.BaseUnit);
+                    return BrakeSpecificFuelConsumption<T>.From(value, BrakeSpecificFuelConsumption<T>.BaseUnit);
                 case QuantityType.Capacitance:
-                    return Capacitance.From(value, Capacitance.BaseUnit);
+                    return Capacitance<T>.From(value, Capacitance<T>.BaseUnit);
                 case QuantityType.CoefficientOfThermalExpansion:
-                    return CoefficientOfThermalExpansion.From(value, CoefficientOfThermalExpansion.BaseUnit);
+                    return CoefficientOfThermalExpansion<T>.From(value, CoefficientOfThermalExpansion<T>.BaseUnit);
                 case QuantityType.Density:
-                    return Density.From(value, Density.BaseUnit);
+                    return Density<T>.From(value, Density<T>.BaseUnit);
                 case QuantityType.Duration:
-                    return Duration.From(value, Duration.BaseUnit);
+                    return Duration<T>.From(value, Duration<T>.BaseUnit);
                 case QuantityType.DynamicViscosity:
-                    return DynamicViscosity.From(value, DynamicViscosity.BaseUnit);
+                    return DynamicViscosity<T>.From(value, DynamicViscosity<T>.BaseUnit);
                 case QuantityType.ElectricAdmittance:
-                    return ElectricAdmittance.From(value, ElectricAdmittance.BaseUnit);
+                    return ElectricAdmittance<T>.From(value, ElectricAdmittance<T>.BaseUnit);
                 case QuantityType.ElectricCharge:
-                    return ElectricCharge.From(value, ElectricCharge.BaseUnit);
+                    return ElectricCharge<T>.From(value, ElectricCharge<T>.BaseUnit);
                 case QuantityType.ElectricChargeDensity:
-                    return ElectricChargeDensity.From(value, ElectricChargeDensity.BaseUnit);
+                    return ElectricChargeDensity<T>.From(value, ElectricChargeDensity<T>.BaseUnit);
                 case QuantityType.ElectricConductance:
-                    return ElectricConductance.From(value, ElectricConductance.BaseUnit);
+                    return ElectricConductance<T>.From(value, ElectricConductance<T>.BaseUnit);
                 case QuantityType.ElectricConductivity:
-                    return ElectricConductivity.From(value, ElectricConductivity.BaseUnit);
+                    return ElectricConductivity<T>.From(value, ElectricConductivity<T>.BaseUnit);
                 case QuantityType.ElectricCurrent:
-                    return ElectricCurrent.From(value, ElectricCurrent.BaseUnit);
+                    return ElectricCurrent<T>.From(value, ElectricCurrent<T>.BaseUnit);
                 case QuantityType.ElectricCurrentDensity:
-                    return ElectricCurrentDensity.From(value, ElectricCurrentDensity.BaseUnit);
+                    return ElectricCurrentDensity<T>.From(value, ElectricCurrentDensity<T>.BaseUnit);
                 case QuantityType.ElectricCurrentGradient:
-                    return ElectricCurrentGradient.From(value, ElectricCurrentGradient.BaseUnit);
+                    return ElectricCurrentGradient<T>.From(value, ElectricCurrentGradient<T>.BaseUnit);
                 case QuantityType.ElectricField:
-                    return ElectricField.From(value, ElectricField.BaseUnit);
+                    return ElectricField<T>.From(value, ElectricField<T>.BaseUnit);
                 case QuantityType.ElectricInductance:
-                    return ElectricInductance.From(value, ElectricInductance.BaseUnit);
+                    return ElectricInductance<T>.From(value, ElectricInductance<T>.BaseUnit);
                 case QuantityType.ElectricPotential:
-                    return ElectricPotential.From(value, ElectricPotential.BaseUnit);
+                    return ElectricPotential<T>.From(value, ElectricPotential<T>.BaseUnit);
                 case QuantityType.ElectricPotentialAc:
-                    return ElectricPotentialAc.From(value, ElectricPotentialAc.BaseUnit);
+                    return ElectricPotentialAc<T>.From(value, ElectricPotentialAc<T>.BaseUnit);
                 case QuantityType.ElectricPotentialChangeRate:
-                    return ElectricPotentialChangeRate.From(value, ElectricPotentialChangeRate.BaseUnit);
+                    return ElectricPotentialChangeRate<T>.From(value, ElectricPotentialChangeRate<T>.BaseUnit);
                 case QuantityType.ElectricPotentialDc:
-                    return ElectricPotentialDc.From(value, ElectricPotentialDc.BaseUnit);
+                    return ElectricPotentialDc<T>.From(value, ElectricPotentialDc<T>.BaseUnit);
                 case QuantityType.ElectricResistance:
-                    return ElectricResistance.From(value, ElectricResistance.BaseUnit);
+                    return ElectricResistance<T>.From(value, ElectricResistance<T>.BaseUnit);
                 case QuantityType.ElectricResistivity:
-                    return ElectricResistivity.From(value, ElectricResistivity.BaseUnit);
+                    return ElectricResistivity<T>.From(value, ElectricResistivity<T>.BaseUnit);
                 case QuantityType.ElectricSurfaceChargeDensity:
-                    return ElectricSurfaceChargeDensity.From(value, ElectricSurfaceChargeDensity.BaseUnit);
+                    return ElectricSurfaceChargeDensity<T>.From(value, ElectricSurfaceChargeDensity<T>.BaseUnit);
                 case QuantityType.Energy:
-                    return Energy.From(value, Energy.BaseUnit);
+                    return Energy<T>.From(value, Energy<T>.BaseUnit);
                 case QuantityType.Entropy:
-                    return Entropy.From(value, Entropy.BaseUnit);
+                    return Entropy<T>.From(value, Entropy<T>.BaseUnit);
                 case QuantityType.Force:
-                    return Force.From(value, Force.BaseUnit);
+                    return Force<T>.From(value, Force<T>.BaseUnit);
                 case QuantityType.ForceChangeRate:
-                    return ForceChangeRate.From(value, ForceChangeRate.BaseUnit);
+                    return ForceChangeRate<T>.From(value, ForceChangeRate<T>.BaseUnit);
                 case QuantityType.ForcePerLength:
-                    return ForcePerLength.From(value, ForcePerLength.BaseUnit);
+                    return ForcePerLength<T>.From(value, ForcePerLength<T>.BaseUnit);
                 case QuantityType.Frequency:
-                    return Frequency.From(value, Frequency.BaseUnit);
+                    return Frequency<T>.From(value, Frequency<T>.BaseUnit);
                 case QuantityType.FuelEfficiency:
-                    return FuelEfficiency.From(value, FuelEfficiency.BaseUnit);
+                    return FuelEfficiency<T>.From(value, FuelEfficiency<T>.BaseUnit);
                 case QuantityType.HeatFlux:
-                    return HeatFlux.From(value, HeatFlux.BaseUnit);
+                    return HeatFlux<T>.From(value, HeatFlux<T>.BaseUnit);
                 case QuantityType.HeatTransferCoefficient:
-                    return HeatTransferCoefficient.From(value, HeatTransferCoefficient.BaseUnit);
+                    return HeatTransferCoefficient<T>.From(value, HeatTransferCoefficient<T>.BaseUnit);
                 case QuantityType.Illuminance:
-                    return Illuminance.From(value, Illuminance.BaseUnit);
+                    return Illuminance<T>.From(value, Illuminance<T>.BaseUnit);
                 case QuantityType.Information:
-                    return Information.From(value, Information.BaseUnit);
+                    return Information<T>.From(value, Information<T>.BaseUnit);
                 case QuantityType.Irradiance:
-                    return Irradiance.From(value, Irradiance.BaseUnit);
+                    return Irradiance<T>.From(value, Irradiance<T>.BaseUnit);
                 case QuantityType.Irradiation:
-                    return Irradiation.From(value, Irradiation.BaseUnit);
+                    return Irradiation<T>.From(value, Irradiation<T>.BaseUnit);
                 case QuantityType.KinematicViscosity:
-                    return KinematicViscosity.From(value, KinematicViscosity.BaseUnit);
+                    return KinematicViscosity<T>.From(value, KinematicViscosity<T>.BaseUnit);
                 case QuantityType.LapseRate:
-                    return LapseRate.From(value, LapseRate.BaseUnit);
+                    return LapseRate<T>.From(value, LapseRate<T>.BaseUnit);
                 case QuantityType.Length:
-                    return Length.From(value, Length.BaseUnit);
+                    return Length<T>.From(value, Length<T>.BaseUnit);
                 case QuantityType.Level:
-                    return Level.From(value, Level.BaseUnit);
+                    return Level<T>.From(value, Level<T>.BaseUnit);
                 case QuantityType.LinearDensity:
-                    return LinearDensity.From(value, LinearDensity.BaseUnit);
+                    return LinearDensity<T>.From(value, LinearDensity<T>.BaseUnit);
                 case QuantityType.LinearPowerDensity:
-                    return LinearPowerDensity.From(value, LinearPowerDensity.BaseUnit);
+                    return LinearPowerDensity<T>.From(value, LinearPowerDensity<T>.BaseUnit);
                 case QuantityType.Luminosity:
-                    return Luminosity.From(value, Luminosity.BaseUnit);
+                    return Luminosity<T>.From(value, Luminosity<T>.BaseUnit);
                 case QuantityType.LuminousFlux:
-                    return LuminousFlux.From(value, LuminousFlux.BaseUnit);
+                    return LuminousFlux<T>.From(value, LuminousFlux<T>.BaseUnit);
                 case QuantityType.LuminousIntensity:
-                    return LuminousIntensity.From(value, LuminousIntensity.BaseUnit);
+                    return LuminousIntensity<T>.From(value, LuminousIntensity<T>.BaseUnit);
                 case QuantityType.MagneticField:
-                    return MagneticField.From(value, MagneticField.BaseUnit);
+                    return MagneticField<T>.From(value, MagneticField<T>.BaseUnit);
                 case QuantityType.MagneticFlux:
-                    return MagneticFlux.From(value, MagneticFlux.BaseUnit);
+                    return MagneticFlux<T>.From(value, MagneticFlux<T>.BaseUnit);
                 case QuantityType.Magnetization:
-                    return Magnetization.From(value, Magnetization.BaseUnit);
+                    return Magnetization<T>.From(value, Magnetization<T>.BaseUnit);
                 case QuantityType.Mass:
-                    return Mass.From(value, Mass.BaseUnit);
+                    return Mass<T>.From(value, Mass<T>.BaseUnit);
                 case QuantityType.MassConcentration:
-                    return MassConcentration.From(value, MassConcentration.BaseUnit);
+                    return MassConcentration<T>.From(value, MassConcentration<T>.BaseUnit);
                 case QuantityType.MassFlow:
-                    return MassFlow.From(value, MassFlow.BaseUnit);
+                    return MassFlow<T>.From(value, MassFlow<T>.BaseUnit);
                 case QuantityType.MassFlux:
-                    return MassFlux.From(value, MassFlux.BaseUnit);
+                    return MassFlux<T>.From(value, MassFlux<T>.BaseUnit);
                 case QuantityType.MassFraction:
-                    return MassFraction.From(value, MassFraction.BaseUnit);
+                    return MassFraction<T>.From(value, MassFraction<T>.BaseUnit);
                 case QuantityType.MassMomentOfInertia:
-                    return MassMomentOfInertia.From(value, MassMomentOfInertia.BaseUnit);
+                    return MassMomentOfInertia<T>.From(value, MassMomentOfInertia<T>.BaseUnit);
                 case QuantityType.MolarEnergy:
-                    return MolarEnergy.From(value, MolarEnergy.BaseUnit);
+                    return MolarEnergy<T>.From(value, MolarEnergy<T>.BaseUnit);
                 case QuantityType.MolarEntropy:
-                    return MolarEntropy.From(value, MolarEntropy.BaseUnit);
+                    return MolarEntropy<T>.From(value, MolarEntropy<T>.BaseUnit);
                 case QuantityType.Molarity:
-                    return Molarity.From(value, Molarity.BaseUnit);
+                    return Molarity<T>.From(value, Molarity<T>.BaseUnit);
                 case QuantityType.MolarMass:
-                    return MolarMass.From(value, MolarMass.BaseUnit);
+                    return MolarMass<T>.From(value, MolarMass<T>.BaseUnit);
                 case QuantityType.Permeability:
-                    return Permeability.From(value, Permeability.BaseUnit);
+                    return Permeability<T>.From(value, Permeability<T>.BaseUnit);
                 case QuantityType.Permittivity:
-                    return Permittivity.From(value, Permittivity.BaseUnit);
+                    return Permittivity<T>.From(value, Permittivity<T>.BaseUnit);
                 case QuantityType.Power:
-                    return Power.From(value, Power.BaseUnit);
+                    return Power<T>.From(value, Power<T>.BaseUnit);
                 case QuantityType.PowerDensity:
-                    return PowerDensity.From(value, PowerDensity.BaseUnit);
+                    return PowerDensity<T>.From(value, PowerDensity<T>.BaseUnit);
                 case QuantityType.PowerRatio:
-                    return PowerRatio.From(value, PowerRatio.BaseUnit);
+                    return PowerRatio<T>.From(value, PowerRatio<T>.BaseUnit);
                 case QuantityType.Pressure:
-                    return Pressure.From(value, Pressure.BaseUnit);
+                    return Pressure<T>.From(value, Pressure<T>.BaseUnit);
                 case QuantityType.PressureChangeRate:
-                    return PressureChangeRate.From(value, PressureChangeRate.BaseUnit);
+                    return PressureChangeRate<T>.From(value, PressureChangeRate<T>.BaseUnit);
                 case QuantityType.Ratio:
-                    return Ratio.From(value, Ratio.BaseUnit);
+                    return Ratio<T>.From(value, Ratio<T>.BaseUnit);
                 case QuantityType.RatioChangeRate:
-                    return RatioChangeRate.From(value, RatioChangeRate.BaseUnit);
+                    return RatioChangeRate<T>.From(value, RatioChangeRate<T>.BaseUnit);
                 case QuantityType.ReactiveEnergy:
-                    return ReactiveEnergy.From(value, ReactiveEnergy.BaseUnit);
+                    return ReactiveEnergy<T>.From(value, ReactiveEnergy<T>.BaseUnit);
                 case QuantityType.ReactivePower:
-                    return ReactivePower.From(value, ReactivePower.BaseUnit);
+                    return ReactivePower<T>.From(value, ReactivePower<T>.BaseUnit);
                 case QuantityType.RelativeHumidity:
-                    return RelativeHumidity.From(value, RelativeHumidity.BaseUnit);
+                    return RelativeHumidity<T>.From(value, RelativeHumidity<T>.BaseUnit);
                 case QuantityType.RotationalAcceleration:
-                    return RotationalAcceleration.From(value, RotationalAcceleration.BaseUnit);
+                    return RotationalAcceleration<T>.From(value, RotationalAcceleration<T>.BaseUnit);
                 case QuantityType.RotationalSpeed:
-                    return RotationalSpeed.From(value, RotationalSpeed.BaseUnit);
+                    return RotationalSpeed<T>.From(value, RotationalSpeed<T>.BaseUnit);
                 case QuantityType.RotationalStiffness:
-                    return RotationalStiffness.From(value, RotationalStiffness.BaseUnit);
+                    return RotationalStiffness<T>.From(value, RotationalStiffness<T>.BaseUnit);
                 case QuantityType.RotationalStiffnessPerLength:
-                    return RotationalStiffnessPerLength.From(value, RotationalStiffnessPerLength.BaseUnit);
+                    return RotationalStiffnessPerLength<T>.From(value, RotationalStiffnessPerLength<T>.BaseUnit);
                 case QuantityType.SolidAngle:
-                    return SolidAngle.From(value, SolidAngle.BaseUnit);
+                    return SolidAngle<T>.From(value, SolidAngle<T>.BaseUnit);
                 case QuantityType.SpecificEnergy:
-                    return SpecificEnergy.From(value, SpecificEnergy.BaseUnit);
+                    return SpecificEnergy<T>.From(value, SpecificEnergy<T>.BaseUnit);
                 case QuantityType.SpecificEntropy:
-                    return SpecificEntropy.From(value, SpecificEntropy.BaseUnit);
+                    return SpecificEntropy<T>.From(value, SpecificEntropy<T>.BaseUnit);
                 case QuantityType.SpecificVolume:
-                    return SpecificVolume.From(value, SpecificVolume.BaseUnit);
+                    return SpecificVolume<T>.From(value, SpecificVolume<T>.BaseUnit);
                 case QuantityType.SpecificWeight:
-                    return SpecificWeight.From(value, SpecificWeight.BaseUnit);
+                    return SpecificWeight<T>.From(value, SpecificWeight<T>.BaseUnit);
                 case QuantityType.Speed:
-                    return Speed.From(value, Speed.BaseUnit);
+                    return Speed<T>.From(value, Speed<T>.BaseUnit);
                 case QuantityType.Temperature:
-                    return Temperature.From(value, Temperature.BaseUnit);
+                    return Temperature<T>.From(value, Temperature<T>.BaseUnit);
                 case QuantityType.TemperatureChangeRate:
-                    return TemperatureChangeRate.From(value, TemperatureChangeRate.BaseUnit);
+                    return TemperatureChangeRate<T>.From(value, TemperatureChangeRate<T>.BaseUnit);
                 case QuantityType.TemperatureDelta:
-                    return TemperatureDelta.From(value, TemperatureDelta.BaseUnit);
+                    return TemperatureDelta<T>.From(value, TemperatureDelta<T>.BaseUnit);
                 case QuantityType.ThermalConductivity:
-                    return ThermalConductivity.From(value, ThermalConductivity.BaseUnit);
+                    return ThermalConductivity<T>.From(value, ThermalConductivity<T>.BaseUnit);
                 case QuantityType.ThermalResistance:
-                    return ThermalResistance.From(value, ThermalResistance.BaseUnit);
+                    return ThermalResistance<T>.From(value, ThermalResistance<T>.BaseUnit);
                 case QuantityType.Torque:
-                    return Torque.From(value, Torque.BaseUnit);
+                    return Torque<T>.From(value, Torque<T>.BaseUnit);
                 case QuantityType.TorquePerLength:
-                    return TorquePerLength.From(value, TorquePerLength.BaseUnit);
+                    return TorquePerLength<T>.From(value, TorquePerLength<T>.BaseUnit);
                 case QuantityType.Turbidity:
-                    return Turbidity.From(value, Turbidity.BaseUnit);
+                    return Turbidity<T>.From(value, Turbidity<T>.BaseUnit);
                 case QuantityType.VitaminA:
-                    return VitaminA.From(value, VitaminA.BaseUnit);
+                    return VitaminA<T>.From(value, VitaminA<T>.BaseUnit);
                 case QuantityType.Volume:
-                    return Volume.From(value, Volume.BaseUnit);
+                    return Volume<T>.From(value, Volume<T>.BaseUnit);
                 case QuantityType.VolumeConcentration:
-                    return VolumeConcentration.From(value, VolumeConcentration.BaseUnit);
+                    return VolumeConcentration<T>.From(value, VolumeConcentration<T>.BaseUnit);
                 case QuantityType.VolumeFlow:
-                    return VolumeFlow.From(value, VolumeFlow.BaseUnit);
+                    return VolumeFlow<T>.From(value, VolumeFlow<T>.BaseUnit);
                 case QuantityType.VolumePerLength:
-                    return VolumePerLength.From(value, VolumePerLength.BaseUnit);
+                    return VolumePerLength<T>.From(value, VolumePerLength<T>.BaseUnit);
                 case QuantityType.WarpingMomentOfInertia:
-                    return WarpingMomentOfInertia.From(value, WarpingMomentOfInertia.BaseUnit);
+                    return WarpingMomentOfInertia<T>.From(value, WarpingMomentOfInertia<T>.BaseUnit);
                 default:
                     throw new ArgumentException($"{quantityType} is not a supported quantity type.");
             }
@@ -708,321 +708,321 @@ public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValu
         /// <param name="unit">Unit enum value.</param>
         /// <param name="quantity">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns><c>True</c> if successful with <paramref name="quantity"/> assigned the value, otherwise <c>false</c>.</returns>
-        public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quantity)
+        public static bool TryFrom<T>(QuantityValue value, Enum unit, out IQuantity? quantity)
         {
             switch (unit)
             {
                 case AccelerationUnit accelerationUnit:
-                    quantity = Acceleration.From(value, accelerationUnit);
+                    quantity = Acceleration<T>.From(value, accelerationUnit);
                     return true;
                 case AmountOfSubstanceUnit amountOfSubstanceUnit:
-                    quantity = AmountOfSubstance.From(value, amountOfSubstanceUnit);
+                    quantity = AmountOfSubstance<T>.From(value, amountOfSubstanceUnit);
                     return true;
                 case AmplitudeRatioUnit amplitudeRatioUnit:
-                    quantity = AmplitudeRatio.From(value, amplitudeRatioUnit);
+                    quantity = AmplitudeRatio<T>.From(value, amplitudeRatioUnit);
                     return true;
                 case AngleUnit angleUnit:
-                    quantity = Angle.From(value, angleUnit);
+                    quantity = Angle<T>.From(value, angleUnit);
                     return true;
                 case ApparentEnergyUnit apparentEnergyUnit:
-                    quantity = ApparentEnergy.From(value, apparentEnergyUnit);
+                    quantity = ApparentEnergy<T>.From(value, apparentEnergyUnit);
                     return true;
                 case ApparentPowerUnit apparentPowerUnit:
-                    quantity = ApparentPower.From(value, apparentPowerUnit);
+                    quantity = ApparentPower<T>.From(value, apparentPowerUnit);
                     return true;
                 case AreaUnit areaUnit:
-                    quantity = Area.From(value, areaUnit);
+                    quantity = Area<T>.From(value, areaUnit);
                     return true;
                 case AreaDensityUnit areaDensityUnit:
-                    quantity = AreaDensity.From(value, areaDensityUnit);
+                    quantity = AreaDensity<T>.From(value, areaDensityUnit);
                     return true;
                 case AreaMomentOfInertiaUnit areaMomentOfInertiaUnit:
-                    quantity = AreaMomentOfInertia.From(value, areaMomentOfInertiaUnit);
+                    quantity = AreaMomentOfInertia<T>.From(value, areaMomentOfInertiaUnit);
                     return true;
                 case BitRateUnit bitRateUnit:
-                    quantity = BitRate.From(value, bitRateUnit);
+                    quantity = BitRate<T>.From(value, bitRateUnit);
                     return true;
                 case BrakeSpecificFuelConsumptionUnit brakeSpecificFuelConsumptionUnit:
-                    quantity = BrakeSpecificFuelConsumption.From(value, brakeSpecificFuelConsumptionUnit);
+                    quantity = BrakeSpecificFuelConsumption<T>.From(value, brakeSpecificFuelConsumptionUnit);
                     return true;
                 case CapacitanceUnit capacitanceUnit:
-                    quantity = Capacitance.From(value, capacitanceUnit);
+                    quantity = Capacitance<T>.From(value, capacitanceUnit);
                     return true;
                 case CoefficientOfThermalExpansionUnit coefficientOfThermalExpansionUnit:
-                    quantity = CoefficientOfThermalExpansion.From(value, coefficientOfThermalExpansionUnit);
+                    quantity = CoefficientOfThermalExpansion<T>.From(value, coefficientOfThermalExpansionUnit);
                     return true;
                 case DensityUnit densityUnit:
-                    quantity = Density.From(value, densityUnit);
+                    quantity = Density<T>.From(value, densityUnit);
                     return true;
                 case DurationUnit durationUnit:
-                    quantity = Duration.From(value, durationUnit);
+                    quantity = Duration<T>.From(value, durationUnit);
                     return true;
                 case DynamicViscosityUnit dynamicViscosityUnit:
-                    quantity = DynamicViscosity.From(value, dynamicViscosityUnit);
+                    quantity = DynamicViscosity<T>.From(value, dynamicViscosityUnit);
                     return true;
                 case ElectricAdmittanceUnit electricAdmittanceUnit:
-                    quantity = ElectricAdmittance.From(value, electricAdmittanceUnit);
+                    quantity = ElectricAdmittance<T>.From(value, electricAdmittanceUnit);
                     return true;
                 case ElectricChargeUnit electricChargeUnit:
-                    quantity = ElectricCharge.From(value, electricChargeUnit);
+                    quantity = ElectricCharge<T>.From(value, electricChargeUnit);
                     return true;
                 case ElectricChargeDensityUnit electricChargeDensityUnit:
-                    quantity = ElectricChargeDensity.From(value, electricChargeDensityUnit);
+                    quantity = ElectricChargeDensity<T>.From(value, electricChargeDensityUnit);
                     return true;
                 case ElectricConductanceUnit electricConductanceUnit:
-                    quantity = ElectricConductance.From(value, electricConductanceUnit);
+                    quantity = ElectricConductance<T>.From(value, electricConductanceUnit);
                     return true;
                 case ElectricConductivityUnit electricConductivityUnit:
-                    quantity = ElectricConductivity.From(value, electricConductivityUnit);
+                    quantity = ElectricConductivity<T>.From(value, electricConductivityUnit);
                     return true;
                 case ElectricCurrentUnit electricCurrentUnit:
-                    quantity = ElectricCurrent.From(value, electricCurrentUnit);
+                    quantity = ElectricCurrent<T>.From(value, electricCurrentUnit);
                     return true;
                 case ElectricCurrentDensityUnit electricCurrentDensityUnit:
-                    quantity = ElectricCurrentDensity.From(value, electricCurrentDensityUnit);
+                    quantity = ElectricCurrentDensity<T>.From(value, electricCurrentDensityUnit);
                     return true;
                 case ElectricCurrentGradientUnit electricCurrentGradientUnit:
-                    quantity = ElectricCurrentGradient.From(value, electricCurrentGradientUnit);
+                    quantity = ElectricCurrentGradient<T>.From(value, electricCurrentGradientUnit);
                     return true;
                 case ElectricFieldUnit electricFieldUnit:
-                    quantity = ElectricField.From(value, electricFieldUnit);
+                    quantity = ElectricField<T>.From(value, electricFieldUnit);
                     return true;
                 case ElectricInductanceUnit electricInductanceUnit:
-                    quantity = ElectricInductance.From(value, electricInductanceUnit);
+                    quantity = ElectricInductance<T>.From(value, electricInductanceUnit);
                     return true;
                 case ElectricPotentialUnit electricPotentialUnit:
-                    quantity = ElectricPotential.From(value, electricPotentialUnit);
+                    quantity = ElectricPotential<T>.From(value, electricPotentialUnit);
                     return true;
                 case ElectricPotentialAcUnit electricPotentialAcUnit:
-                    quantity = ElectricPotentialAc.From(value, electricPotentialAcUnit);
+                    quantity = ElectricPotentialAc<T>.From(value, electricPotentialAcUnit);
                     return true;
                 case ElectricPotentialChangeRateUnit electricPotentialChangeRateUnit:
-                    quantity = ElectricPotentialChangeRate.From(value, electricPotentialChangeRateUnit);
+                    quantity = ElectricPotentialChangeRate<T>.From(value, electricPotentialChangeRateUnit);
                     return true;
                 case ElectricPotentialDcUnit electricPotentialDcUnit:
-                    quantity = ElectricPotentialDc.From(value, electricPotentialDcUnit);
+                    quantity = ElectricPotentialDc<T>.From(value, electricPotentialDcUnit);
                     return true;
                 case ElectricResistanceUnit electricResistanceUnit:
-                    quantity = ElectricResistance.From(value, electricResistanceUnit);
+                    quantity = ElectricResistance<T>.From(value, electricResistanceUnit);
                     return true;
                 case ElectricResistivityUnit electricResistivityUnit:
-                    quantity = ElectricResistivity.From(value, electricResistivityUnit);
+                    quantity = ElectricResistivity<T>.From(value, electricResistivityUnit);
                     return true;
                 case ElectricSurfaceChargeDensityUnit electricSurfaceChargeDensityUnit:
-                    quantity = ElectricSurfaceChargeDensity.From(value, electricSurfaceChargeDensityUnit);
+                    quantity = ElectricSurfaceChargeDensity<T>.From(value, electricSurfaceChargeDensityUnit);
                     return true;
                 case EnergyUnit energyUnit:
-                    quantity = Energy.From(value, energyUnit);
+                    quantity = Energy<T>.From(value, energyUnit);
                     return true;
                 case EntropyUnit entropyUnit:
-                    quantity = Entropy.From(value, entropyUnit);
+                    quantity = Entropy<T>.From(value, entropyUnit);
                     return true;
                 case ForceUnit forceUnit:
-                    quantity = Force.From(value, forceUnit);
+                    quantity = Force<T>.From(value, forceUnit);
                     return true;
                 case ForceChangeRateUnit forceChangeRateUnit:
-                    quantity = ForceChangeRate.From(value, forceChangeRateUnit);
+                    quantity = ForceChangeRate<T>.From(value, forceChangeRateUnit);
                     return true;
                 case ForcePerLengthUnit forcePerLengthUnit:
-                    quantity = ForcePerLength.From(value, forcePerLengthUnit);
+                    quantity = ForcePerLength<T>.From(value, forcePerLengthUnit);
                     return true;
                 case FrequencyUnit frequencyUnit:
-                    quantity = Frequency.From(value, frequencyUnit);
+                    quantity = Frequency<T>.From(value, frequencyUnit);
                     return true;
                 case FuelEfficiencyUnit fuelEfficiencyUnit:
-                    quantity = FuelEfficiency.From(value, fuelEfficiencyUnit);
+                    quantity = FuelEfficiency<T>.From(value, fuelEfficiencyUnit);
                     return true;
                 case HeatFluxUnit heatFluxUnit:
-                    quantity = HeatFlux.From(value, heatFluxUnit);
+                    quantity = HeatFlux<T>.From(value, heatFluxUnit);
                     return true;
                 case HeatTransferCoefficientUnit heatTransferCoefficientUnit:
-                    quantity = HeatTransferCoefficient.From(value, heatTransferCoefficientUnit);
+                    quantity = HeatTransferCoefficient<T>.From(value, heatTransferCoefficientUnit);
                     return true;
                 case IlluminanceUnit illuminanceUnit:
-                    quantity = Illuminance.From(value, illuminanceUnit);
+                    quantity = Illuminance<T>.From(value, illuminanceUnit);
                     return true;
                 case InformationUnit informationUnit:
-                    quantity = Information.From(value, informationUnit);
+                    quantity = Information<T>.From(value, informationUnit);
                     return true;
                 case IrradianceUnit irradianceUnit:
-                    quantity = Irradiance.From(value, irradianceUnit);
+                    quantity = Irradiance<T>.From(value, irradianceUnit);
                     return true;
                 case IrradiationUnit irradiationUnit:
-                    quantity = Irradiation.From(value, irradiationUnit);
+                    quantity = Irradiation<T>.From(value, irradiationUnit);
                     return true;
                 case KinematicViscosityUnit kinematicViscosityUnit:
-                    quantity = KinematicViscosity.From(value, kinematicViscosityUnit);
+                    quantity = KinematicViscosity<T>.From(value, kinematicViscosityUnit);
                     return true;
                 case LapseRateUnit lapseRateUnit:
-                    quantity = LapseRate.From(value, lapseRateUnit);
+                    quantity = LapseRate<T>.From(value, lapseRateUnit);
                     return true;
                 case LengthUnit lengthUnit:
-                    quantity = Length.From(value, lengthUnit);
+                    quantity = Length<T>.From(value, lengthUnit);
                     return true;
                 case LevelUnit levelUnit:
-                    quantity = Level.From(value, levelUnit);
+                    quantity = Level<T>.From(value, levelUnit);
                     return true;
                 case LinearDensityUnit linearDensityUnit:
-                    quantity = LinearDensity.From(value, linearDensityUnit);
+                    quantity = LinearDensity<T>.From(value, linearDensityUnit);
                     return true;
                 case LinearPowerDensityUnit linearPowerDensityUnit:
-                    quantity = LinearPowerDensity.From(value, linearPowerDensityUnit);
+                    quantity = LinearPowerDensity<T>.From(value, linearPowerDensityUnit);
                     return true;
                 case LuminosityUnit luminosityUnit:
-                    quantity = Luminosity.From(value, luminosityUnit);
+                    quantity = Luminosity<T>.From(value, luminosityUnit);
                     return true;
                 case LuminousFluxUnit luminousFluxUnit:
-                    quantity = LuminousFlux.From(value, luminousFluxUnit);
+                    quantity = LuminousFlux<T>.From(value, luminousFluxUnit);
                     return true;
                 case LuminousIntensityUnit luminousIntensityUnit:
-                    quantity = LuminousIntensity.From(value, luminousIntensityUnit);
+                    quantity = LuminousIntensity<T>.From(value, luminousIntensityUnit);
                     return true;
                 case MagneticFieldUnit magneticFieldUnit:
-                    quantity = MagneticField.From(value, magneticFieldUnit);
+                    quantity = MagneticField<T>.From(value, magneticFieldUnit);
                     return true;
                 case MagneticFluxUnit magneticFluxUnit:
-                    quantity = MagneticFlux.From(value, magneticFluxUnit);
+                    quantity = MagneticFlux<T>.From(value, magneticFluxUnit);
                     return true;
                 case MagnetizationUnit magnetizationUnit:
-                    quantity = Magnetization.From(value, magnetizationUnit);
+                    quantity = Magnetization<T>.From(value, magnetizationUnit);
                     return true;
                 case MassUnit massUnit:
-                    quantity = Mass.From(value, massUnit);
+                    quantity = Mass<T>.From(value, massUnit);
                     return true;
                 case MassConcentrationUnit massConcentrationUnit:
-                    quantity = MassConcentration.From(value, massConcentrationUnit);
+                    quantity = MassConcentration<T>.From(value, massConcentrationUnit);
                     return true;
                 case MassFlowUnit massFlowUnit:
-                    quantity = MassFlow.From(value, massFlowUnit);
+                    quantity = MassFlow<T>.From(value, massFlowUnit);
                     return true;
                 case MassFluxUnit massFluxUnit:
-                    quantity = MassFlux.From(value, massFluxUnit);
+                    quantity = MassFlux<T>.From(value, massFluxUnit);
                     return true;
                 case MassFractionUnit massFractionUnit:
-                    quantity = MassFraction.From(value, massFractionUnit);
+                    quantity = MassFraction<T>.From(value, massFractionUnit);
                     return true;
                 case MassMomentOfInertiaUnit massMomentOfInertiaUnit:
-                    quantity = MassMomentOfInertia.From(value, massMomentOfInertiaUnit);
+                    quantity = MassMomentOfInertia<T>.From(value, massMomentOfInertiaUnit);
                     return true;
                 case MolarEnergyUnit molarEnergyUnit:
-                    quantity = MolarEnergy.From(value, molarEnergyUnit);
+                    quantity = MolarEnergy<T>.From(value, molarEnergyUnit);
                     return true;
                 case MolarEntropyUnit molarEntropyUnit:
-                    quantity = MolarEntropy.From(value, molarEntropyUnit);
+                    quantity = MolarEntropy<T>.From(value, molarEntropyUnit);
                     return true;
                 case MolarityUnit molarityUnit:
-                    quantity = Molarity.From(value, molarityUnit);
+                    quantity = Molarity<T>.From(value, molarityUnit);
                     return true;
                 case MolarMassUnit molarMassUnit:
-                    quantity = MolarMass.From(value, molarMassUnit);
+                    quantity = MolarMass<T>.From(value, molarMassUnit);
                     return true;
                 case PermeabilityUnit permeabilityUnit:
-                    quantity = Permeability.From(value, permeabilityUnit);
+                    quantity = Permeability<T>.From(value, permeabilityUnit);
                     return true;
                 case PermittivityUnit permittivityUnit:
-                    quantity = Permittivity.From(value, permittivityUnit);
+                    quantity = Permittivity<T>.From(value, permittivityUnit);
                     return true;
                 case PowerUnit powerUnit:
-                    quantity = Power.From(value, powerUnit);
+                    quantity = Power<T>.From(value, powerUnit);
                     return true;
                 case PowerDensityUnit powerDensityUnit:
-                    quantity = PowerDensity.From(value, powerDensityUnit);
+                    quantity = PowerDensity<T>.From(value, powerDensityUnit);
                     return true;
                 case PowerRatioUnit powerRatioUnit:
-                    quantity = PowerRatio.From(value, powerRatioUnit);
+                    quantity = PowerRatio<T>.From(value, powerRatioUnit);
                     return true;
                 case PressureUnit pressureUnit:
-                    quantity = Pressure.From(value, pressureUnit);
+                    quantity = Pressure<T>.From(value, pressureUnit);
                     return true;
                 case PressureChangeRateUnit pressureChangeRateUnit:
-                    quantity = PressureChangeRate.From(value, pressureChangeRateUnit);
+                    quantity = PressureChangeRate<T>.From(value, pressureChangeRateUnit);
                     return true;
                 case RatioUnit ratioUnit:
-                    quantity = Ratio.From(value, ratioUnit);
+                    quantity = Ratio<T>.From(value, ratioUnit);
                     return true;
                 case RatioChangeRateUnit ratioChangeRateUnit:
-                    quantity = RatioChangeRate.From(value, ratioChangeRateUnit);
+                    quantity = RatioChangeRate<T>.From(value, ratioChangeRateUnit);
                     return true;
                 case ReactiveEnergyUnit reactiveEnergyUnit:
-                    quantity = ReactiveEnergy.From(value, reactiveEnergyUnit);
+                    quantity = ReactiveEnergy<T>.From(value, reactiveEnergyUnit);
                     return true;
                 case ReactivePowerUnit reactivePowerUnit:
-                    quantity = ReactivePower.From(value, reactivePowerUnit);
+                    quantity = ReactivePower<T>.From(value, reactivePowerUnit);
                     return true;
                 case RelativeHumidityUnit relativeHumidityUnit:
-                    quantity = RelativeHumidity.From(value, relativeHumidityUnit);
+                    quantity = RelativeHumidity<T>.From(value, relativeHumidityUnit);
                     return true;
                 case RotationalAccelerationUnit rotationalAccelerationUnit:
-                    quantity = RotationalAcceleration.From(value, rotationalAccelerationUnit);
+                    quantity = RotationalAcceleration<T>.From(value, rotationalAccelerationUnit);
                     return true;
                 case RotationalSpeedUnit rotationalSpeedUnit:
-                    quantity = RotationalSpeed.From(value, rotationalSpeedUnit);
+                    quantity = RotationalSpeed<T>.From(value, rotationalSpeedUnit);
                     return true;
                 case RotationalStiffnessUnit rotationalStiffnessUnit:
-                    quantity = RotationalStiffness.From(value, rotationalStiffnessUnit);
+                    quantity = RotationalStiffness<T>.From(value, rotationalStiffnessUnit);
                     return true;
                 case RotationalStiffnessPerLengthUnit rotationalStiffnessPerLengthUnit:
-                    quantity = RotationalStiffnessPerLength.From(value, rotationalStiffnessPerLengthUnit);
+                    quantity = RotationalStiffnessPerLength<T>.From(value, rotationalStiffnessPerLengthUnit);
                     return true;
                 case SolidAngleUnit solidAngleUnit:
-                    quantity = SolidAngle.From(value, solidAngleUnit);
+                    quantity = SolidAngle<T>.From(value, solidAngleUnit);
                     return true;
                 case SpecificEnergyUnit specificEnergyUnit:
-                    quantity = SpecificEnergy.From(value, specificEnergyUnit);
+                    quantity = SpecificEnergy<T>.From(value, specificEnergyUnit);
                     return true;
                 case SpecificEntropyUnit specificEntropyUnit:
-                    quantity = SpecificEntropy.From(value, specificEntropyUnit);
+                    quantity = SpecificEntropy<T>.From(value, specificEntropyUnit);
                     return true;
                 case SpecificVolumeUnit specificVolumeUnit:
-                    quantity = SpecificVolume.From(value, specificVolumeUnit);
+                    quantity = SpecificVolume<T>.From(value, specificVolumeUnit);
                     return true;
                 case SpecificWeightUnit specificWeightUnit:
-                    quantity = SpecificWeight.From(value, specificWeightUnit);
+                    quantity = SpecificWeight<T>.From(value, specificWeightUnit);
                     return true;
                 case SpeedUnit speedUnit:
-                    quantity = Speed.From(value, speedUnit);
+                    quantity = Speed<T>.From(value, speedUnit);
                     return true;
                 case TemperatureUnit temperatureUnit:
-                    quantity = Temperature.From(value, temperatureUnit);
+                    quantity = Temperature<T>.From(value, temperatureUnit);
                     return true;
                 case TemperatureChangeRateUnit temperatureChangeRateUnit:
-                    quantity = TemperatureChangeRate.From(value, temperatureChangeRateUnit);
+                    quantity = TemperatureChangeRate<T>.From(value, temperatureChangeRateUnit);
                     return true;
                 case TemperatureDeltaUnit temperatureDeltaUnit:
-                    quantity = TemperatureDelta.From(value, temperatureDeltaUnit);
+                    quantity = TemperatureDelta<T>.From(value, temperatureDeltaUnit);
                     return true;
                 case ThermalConductivityUnit thermalConductivityUnit:
-                    quantity = ThermalConductivity.From(value, thermalConductivityUnit);
+                    quantity = ThermalConductivity<T>.From(value, thermalConductivityUnit);
                     return true;
                 case ThermalResistanceUnit thermalResistanceUnit:
-                    quantity = ThermalResistance.From(value, thermalResistanceUnit);
+                    quantity = ThermalResistance<T>.From(value, thermalResistanceUnit);
                     return true;
                 case TorqueUnit torqueUnit:
-                    quantity = Torque.From(value, torqueUnit);
+                    quantity = Torque<T>.From(value, torqueUnit);
                     return true;
                 case TorquePerLengthUnit torquePerLengthUnit:
-                    quantity = TorquePerLength.From(value, torquePerLengthUnit);
+                    quantity = TorquePerLength<T>.From(value, torquePerLengthUnit);
                     return true;
                 case TurbidityUnit turbidityUnit:
-                    quantity = Turbidity.From(value, turbidityUnit);
+                    quantity = Turbidity<T>.From(value, turbidityUnit);
                     return true;
                 case VitaminAUnit vitaminAUnit:
-                    quantity = VitaminA.From(value, vitaminAUnit);
+                    quantity = VitaminA<T>.From(value, vitaminAUnit);
                     return true;
                 case VolumeUnit volumeUnit:
-                    quantity = Volume.From(value, volumeUnit);
+                    quantity = Volume<T>.From(value, volumeUnit);
                     return true;
                 case VolumeConcentrationUnit volumeConcentrationUnit:
-                    quantity = VolumeConcentration.From(value, volumeConcentrationUnit);
+                    quantity = VolumeConcentration<T>.From(value, volumeConcentrationUnit);
                     return true;
                 case VolumeFlowUnit volumeFlowUnit:
-                    quantity = VolumeFlow.From(value, volumeFlowUnit);
+                    quantity = VolumeFlow<T>.From(value, volumeFlowUnit);
                     return true;
                 case VolumePerLengthUnit volumePerLengthUnit:
-                    quantity = VolumePerLength.From(value, volumePerLengthUnit);
+                    quantity = VolumePerLength<T>.From(value, volumePerLengthUnit);
                     return true;
                 case WarpingMomentOfInertiaUnit warpingMomentOfInertiaUnit:
-                    quantity = WarpingMomentOfInertia.From(value, warpingMomentOfInertiaUnit);
+                    quantity = WarpingMomentOfInertia<T>.From(value, warpingMomentOfInertiaUnit);
                     return true;
                 default:
                 {
@@ -1036,11 +1036,11 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quanti
         ///     Try to dynamically parse a quantity string representation.
         /// </summary>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
-        /// <param name="quantityType">Type of quantity, such as <see cref="Length"/>.</param>
+        /// <param name="quantityType">Type of quantity, such as <see cref="Length{T}"/>.</param>
         /// <param name="quantityString">Quantity string representation, such as "1.5 kg". Must be compatible with given quantity type.</param>
         /// <param name="quantity">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns>The parsed quantity.</returns>
-        public static bool TryParse(IFormatProvider? formatProvider, Type quantityType, string quantityString, out IQuantity? quantity)
+        public static bool TryParse<T>(IFormatProvider? formatProvider, Type quantityType, string quantityString, out IQuantity? quantity)
         {
             quantity = default(IQuantity);
 
@@ -1051,214 +1051,214 @@ public static bool TryParse(IFormatProvider? formatProvider, Type quantityType,
 
             switch(quantityType)
             {
-                case Type _ when quantityType == typeof(Acceleration):
-                    return parser.TryParse<Acceleration, AccelerationUnit>(quantityString, formatProvider, Acceleration.From, out quantity);
-                case Type _ when quantityType == typeof(AmountOfSubstance):
-                    return parser.TryParse<AmountOfSubstance, AmountOfSubstanceUnit>(quantityString, formatProvider, AmountOfSubstance.From, out quantity);
-                case Type _ when quantityType == typeof(AmplitudeRatio):
-                    return parser.TryParse<AmplitudeRatio, AmplitudeRatioUnit>(quantityString, formatProvider, AmplitudeRatio.From, out quantity);
-                case Type _ when quantityType == typeof(Angle):
-                    return parser.TryParse<Angle, AngleUnit>(quantityString, formatProvider, Angle.From, out quantity);
-                case Type _ when quantityType == typeof(ApparentEnergy):
-                    return parser.TryParse<ApparentEnergy, ApparentEnergyUnit>(quantityString, formatProvider, ApparentEnergy.From, out quantity);
-                case Type _ when quantityType == typeof(ApparentPower):
-                    return parser.TryParse<ApparentPower, ApparentPowerUnit>(quantityString, formatProvider, ApparentPower.From, out quantity);
-                case Type _ when quantityType == typeof(Area):
-                    return parser.TryParse<Area, AreaUnit>(quantityString, formatProvider, Area.From, out quantity);
-                case Type _ when quantityType == typeof(AreaDensity):
-                    return parser.TryParse<AreaDensity, AreaDensityUnit>(quantityString, formatProvider, AreaDensity.From, out quantity);
-                case Type _ when quantityType == typeof(AreaMomentOfInertia):
-                    return parser.TryParse<AreaMomentOfInertia, AreaMomentOfInertiaUnit>(quantityString, formatProvider, AreaMomentOfInertia.From, out quantity);
-                case Type _ when quantityType == typeof(BitRate):
-                    return parser.TryParse<BitRate, BitRateUnit>(quantityString, formatProvider, BitRate.From, out quantity);
-                case Type _ when quantityType == typeof(BrakeSpecificFuelConsumption):
-                    return parser.TryParse<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>(quantityString, formatProvider, BrakeSpecificFuelConsumption.From, out quantity);
-                case Type _ when quantityType == typeof(Capacitance):
-                    return parser.TryParse<Capacitance, CapacitanceUnit>(quantityString, formatProvider, Capacitance.From, out quantity);
-                case Type _ when quantityType == typeof(CoefficientOfThermalExpansion):
-                    return parser.TryParse<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>(quantityString, formatProvider, CoefficientOfThermalExpansion.From, out quantity);
-                case Type _ when quantityType == typeof(Density):
-                    return parser.TryParse<Density, DensityUnit>(quantityString, formatProvider, Density.From, out quantity);
-                case Type _ when quantityType == typeof(Duration):
-                    return parser.TryParse<Duration, DurationUnit>(quantityString, formatProvider, Duration.From, out quantity);
-                case Type _ when quantityType == typeof(DynamicViscosity):
-                    return parser.TryParse<DynamicViscosity, DynamicViscosityUnit>(quantityString, formatProvider, DynamicViscosity.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricAdmittance):
-                    return parser.TryParse<ElectricAdmittance, ElectricAdmittanceUnit>(quantityString, formatProvider, ElectricAdmittance.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricCharge):
-                    return parser.TryParse<ElectricCharge, ElectricChargeUnit>(quantityString, formatProvider, ElectricCharge.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricChargeDensity):
-                    return parser.TryParse<ElectricChargeDensity, ElectricChargeDensityUnit>(quantityString, formatProvider, ElectricChargeDensity.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricConductance):
-                    return parser.TryParse<ElectricConductance, ElectricConductanceUnit>(quantityString, formatProvider, ElectricConductance.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricConductivity):
-                    return parser.TryParse<ElectricConductivity, ElectricConductivityUnit>(quantityString, formatProvider, ElectricConductivity.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricCurrent):
-                    return parser.TryParse<ElectricCurrent, ElectricCurrentUnit>(quantityString, formatProvider, ElectricCurrent.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricCurrentDensity):
-                    return parser.TryParse<ElectricCurrentDensity, ElectricCurrentDensityUnit>(quantityString, formatProvider, ElectricCurrentDensity.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricCurrentGradient):
-                    return parser.TryParse<ElectricCurrentGradient, ElectricCurrentGradientUnit>(quantityString, formatProvider, ElectricCurrentGradient.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricField):
-                    return parser.TryParse<ElectricField, ElectricFieldUnit>(quantityString, formatProvider, ElectricField.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricInductance):
-                    return parser.TryParse<ElectricInductance, ElectricInductanceUnit>(quantityString, formatProvider, ElectricInductance.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricPotential):
-                    return parser.TryParse<ElectricPotential, ElectricPotentialUnit>(quantityString, formatProvider, ElectricPotential.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricPotentialAc):
-                    return parser.TryParse<ElectricPotentialAc, ElectricPotentialAcUnit>(quantityString, formatProvider, ElectricPotentialAc.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricPotentialChangeRate):
-                    return parser.TryParse<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>(quantityString, formatProvider, ElectricPotentialChangeRate.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricPotentialDc):
-                    return parser.TryParse<ElectricPotentialDc, ElectricPotentialDcUnit>(quantityString, formatProvider, ElectricPotentialDc.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricResistance):
-                    return parser.TryParse<ElectricResistance, ElectricResistanceUnit>(quantityString, formatProvider, ElectricResistance.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricResistivity):
-                    return parser.TryParse<ElectricResistivity, ElectricResistivityUnit>(quantityString, formatProvider, ElectricResistivity.From, out quantity);
-                case Type _ when quantityType == typeof(ElectricSurfaceChargeDensity):
-                    return parser.TryParse<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>(quantityString, formatProvider, ElectricSurfaceChargeDensity.From, out quantity);
-                case Type _ when quantityType == typeof(Energy):
-                    return parser.TryParse<Energy, EnergyUnit>(quantityString, formatProvider, Energy.From, out quantity);
-                case Type _ when quantityType == typeof(Entropy):
-                    return parser.TryParse<Entropy, EntropyUnit>(quantityString, formatProvider, Entropy.From, out quantity);
-                case Type _ when quantityType == typeof(Force):
-                    return parser.TryParse<Force, ForceUnit>(quantityString, formatProvider, Force.From, out quantity);
-                case Type _ when quantityType == typeof(ForceChangeRate):
-                    return parser.TryParse<ForceChangeRate, ForceChangeRateUnit>(quantityString, formatProvider, ForceChangeRate.From, out quantity);
-                case Type _ when quantityType == typeof(ForcePerLength):
-                    return parser.TryParse<ForcePerLength, ForcePerLengthUnit>(quantityString, formatProvider, ForcePerLength.From, out quantity);
-                case Type _ when quantityType == typeof(Frequency):
-                    return parser.TryParse<Frequency, FrequencyUnit>(quantityString, formatProvider, Frequency.From, out quantity);
-                case Type _ when quantityType == typeof(FuelEfficiency):
-                    return parser.TryParse<FuelEfficiency, FuelEfficiencyUnit>(quantityString, formatProvider, FuelEfficiency.From, out quantity);
-                case Type _ when quantityType == typeof(HeatFlux):
-                    return parser.TryParse<HeatFlux, HeatFluxUnit>(quantityString, formatProvider, HeatFlux.From, out quantity);
-                case Type _ when quantityType == typeof(HeatTransferCoefficient):
-                    return parser.TryParse<HeatTransferCoefficient, HeatTransferCoefficientUnit>(quantityString, formatProvider, HeatTransferCoefficient.From, out quantity);
-                case Type _ when quantityType == typeof(Illuminance):
-                    return parser.TryParse<Illuminance, IlluminanceUnit>(quantityString, formatProvider, Illuminance.From, out quantity);
-                case Type _ when quantityType == typeof(Information):
-                    return parser.TryParse<Information, InformationUnit>(quantityString, formatProvider, Information.From, out quantity);
-                case Type _ when quantityType == typeof(Irradiance):
-                    return parser.TryParse<Irradiance, IrradianceUnit>(quantityString, formatProvider, Irradiance.From, out quantity);
-                case Type _ when quantityType == typeof(Irradiation):
-                    return parser.TryParse<Irradiation, IrradiationUnit>(quantityString, formatProvider, Irradiation.From, out quantity);
-                case Type _ when quantityType == typeof(KinematicViscosity):
-                    return parser.TryParse<KinematicViscosity, KinematicViscosityUnit>(quantityString, formatProvider, KinematicViscosity.From, out quantity);
-                case Type _ when quantityType == typeof(LapseRate):
-                    return parser.TryParse<LapseRate, LapseRateUnit>(quantityString, formatProvider, LapseRate.From, out quantity);
-                case Type _ when quantityType == typeof(Length):
-                    return parser.TryParse<Length, LengthUnit>(quantityString, formatProvider, Length.From, out quantity);
-                case Type _ when quantityType == typeof(Level):
-                    return parser.TryParse<Level, LevelUnit>(quantityString, formatProvider, Level.From, out quantity);
-                case Type _ when quantityType == typeof(LinearDensity):
-                    return parser.TryParse<LinearDensity, LinearDensityUnit>(quantityString, formatProvider, LinearDensity.From, out quantity);
-                case Type _ when quantityType == typeof(LinearPowerDensity):
-                    return parser.TryParse<LinearPowerDensity, LinearPowerDensityUnit>(quantityString, formatProvider, LinearPowerDensity.From, out quantity);
-                case Type _ when quantityType == typeof(Luminosity):
-                    return parser.TryParse<Luminosity, LuminosityUnit>(quantityString, formatProvider, Luminosity.From, out quantity);
-                case Type _ when quantityType == typeof(LuminousFlux):
-                    return parser.TryParse<LuminousFlux, LuminousFluxUnit>(quantityString, formatProvider, LuminousFlux.From, out quantity);
-                case Type _ when quantityType == typeof(LuminousIntensity):
-                    return parser.TryParse<LuminousIntensity, LuminousIntensityUnit>(quantityString, formatProvider, LuminousIntensity.From, out quantity);
-                case Type _ when quantityType == typeof(MagneticField):
-                    return parser.TryParse<MagneticField, MagneticFieldUnit>(quantityString, formatProvider, MagneticField.From, out quantity);
-                case Type _ when quantityType == typeof(MagneticFlux):
-                    return parser.TryParse<MagneticFlux, MagneticFluxUnit>(quantityString, formatProvider, MagneticFlux.From, out quantity);
-                case Type _ when quantityType == typeof(Magnetization):
-                    return parser.TryParse<Magnetization, MagnetizationUnit>(quantityString, formatProvider, Magnetization.From, out quantity);
-                case Type _ when quantityType == typeof(Mass):
-                    return parser.TryParse<Mass, MassUnit>(quantityString, formatProvider, Mass.From, out quantity);
-                case Type _ when quantityType == typeof(MassConcentration):
-                    return parser.TryParse<MassConcentration, MassConcentrationUnit>(quantityString, formatProvider, MassConcentration.From, out quantity);
-                case Type _ when quantityType == typeof(MassFlow):
-                    return parser.TryParse<MassFlow, MassFlowUnit>(quantityString, formatProvider, MassFlow.From, out quantity);
-                case Type _ when quantityType == typeof(MassFlux):
-                    return parser.TryParse<MassFlux, MassFluxUnit>(quantityString, formatProvider, MassFlux.From, out quantity);
-                case Type _ when quantityType == typeof(MassFraction):
-                    return parser.TryParse<MassFraction, MassFractionUnit>(quantityString, formatProvider, MassFraction.From, out quantity);
-                case Type _ when quantityType == typeof(MassMomentOfInertia):
-                    return parser.TryParse<MassMomentOfInertia, MassMomentOfInertiaUnit>(quantityString, formatProvider, MassMomentOfInertia.From, out quantity);
-                case Type _ when quantityType == typeof(MolarEnergy):
-                    return parser.TryParse<MolarEnergy, MolarEnergyUnit>(quantityString, formatProvider, MolarEnergy.From, out quantity);
-                case Type _ when quantityType == typeof(MolarEntropy):
-                    return parser.TryParse<MolarEntropy, MolarEntropyUnit>(quantityString, formatProvider, MolarEntropy.From, out quantity);
-                case Type _ when quantityType == typeof(Molarity):
-                    return parser.TryParse<Molarity, MolarityUnit>(quantityString, formatProvider, Molarity.From, out quantity);
-                case Type _ when quantityType == typeof(MolarMass):
-                    return parser.TryParse<MolarMass, MolarMassUnit>(quantityString, formatProvider, MolarMass.From, out quantity);
-                case Type _ when quantityType == typeof(Permeability):
-                    return parser.TryParse<Permeability, PermeabilityUnit>(quantityString, formatProvider, Permeability.From, out quantity);
-                case Type _ when quantityType == typeof(Permittivity):
-                    return parser.TryParse<Permittivity, PermittivityUnit>(quantityString, formatProvider, Permittivity.From, out quantity);
-                case Type _ when quantityType == typeof(Power):
-                    return parser.TryParse<Power, PowerUnit>(quantityString, formatProvider, Power.From, out quantity);
-                case Type _ when quantityType == typeof(PowerDensity):
-                    return parser.TryParse<PowerDensity, PowerDensityUnit>(quantityString, formatProvider, PowerDensity.From, out quantity);
-                case Type _ when quantityType == typeof(PowerRatio):
-                    return parser.TryParse<PowerRatio, PowerRatioUnit>(quantityString, formatProvider, PowerRatio.From, out quantity);
-                case Type _ when quantityType == typeof(Pressure):
-                    return parser.TryParse<Pressure, PressureUnit>(quantityString, formatProvider, Pressure.From, out quantity);
-                case Type _ when quantityType == typeof(PressureChangeRate):
-                    return parser.TryParse<PressureChangeRate, PressureChangeRateUnit>(quantityString, formatProvider, PressureChangeRate.From, out quantity);
-                case Type _ when quantityType == typeof(Ratio):
-                    return parser.TryParse<Ratio, RatioUnit>(quantityString, formatProvider, Ratio.From, out quantity);
-                case Type _ when quantityType == typeof(RatioChangeRate):
-                    return parser.TryParse<RatioChangeRate, RatioChangeRateUnit>(quantityString, formatProvider, RatioChangeRate.From, out quantity);
-                case Type _ when quantityType == typeof(ReactiveEnergy):
-                    return parser.TryParse<ReactiveEnergy, ReactiveEnergyUnit>(quantityString, formatProvider, ReactiveEnergy.From, out quantity);
-                case Type _ when quantityType == typeof(ReactivePower):
-                    return parser.TryParse<ReactivePower, ReactivePowerUnit>(quantityString, formatProvider, ReactivePower.From, out quantity);
-                case Type _ when quantityType == typeof(RelativeHumidity):
-                    return parser.TryParse<RelativeHumidity, RelativeHumidityUnit>(quantityString, formatProvider, RelativeHumidity.From, out quantity);
-                case Type _ when quantityType == typeof(RotationalAcceleration):
-                    return parser.TryParse<RotationalAcceleration, RotationalAccelerationUnit>(quantityString, formatProvider, RotationalAcceleration.From, out quantity);
-                case Type _ when quantityType == typeof(RotationalSpeed):
-                    return parser.TryParse<RotationalSpeed, RotationalSpeedUnit>(quantityString, formatProvider, RotationalSpeed.From, out quantity);
-                case Type _ when quantityType == typeof(RotationalStiffness):
-                    return parser.TryParse<RotationalStiffness, RotationalStiffnessUnit>(quantityString, formatProvider, RotationalStiffness.From, out quantity);
-                case Type _ when quantityType == typeof(RotationalStiffnessPerLength):
-                    return parser.TryParse<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>(quantityString, formatProvider, RotationalStiffnessPerLength.From, out quantity);
-                case Type _ when quantityType == typeof(SolidAngle):
-                    return parser.TryParse<SolidAngle, SolidAngleUnit>(quantityString, formatProvider, SolidAngle.From, out quantity);
-                case Type _ when quantityType == typeof(SpecificEnergy):
-                    return parser.TryParse<SpecificEnergy, SpecificEnergyUnit>(quantityString, formatProvider, SpecificEnergy.From, out quantity);
-                case Type _ when quantityType == typeof(SpecificEntropy):
-                    return parser.TryParse<SpecificEntropy, SpecificEntropyUnit>(quantityString, formatProvider, SpecificEntropy.From, out quantity);
-                case Type _ when quantityType == typeof(SpecificVolume):
-                    return parser.TryParse<SpecificVolume, SpecificVolumeUnit>(quantityString, formatProvider, SpecificVolume.From, out quantity);
-                case Type _ when quantityType == typeof(SpecificWeight):
-                    return parser.TryParse<SpecificWeight, SpecificWeightUnit>(quantityString, formatProvider, SpecificWeight.From, out quantity);
-                case Type _ when quantityType == typeof(Speed):
-                    return parser.TryParse<Speed, SpeedUnit>(quantityString, formatProvider, Speed.From, out quantity);
-                case Type _ when quantityType == typeof(Temperature):
-                    return parser.TryParse<Temperature, TemperatureUnit>(quantityString, formatProvider, Temperature.From, out quantity);
-                case Type _ when quantityType == typeof(TemperatureChangeRate):
-                    return parser.TryParse<TemperatureChangeRate, TemperatureChangeRateUnit>(quantityString, formatProvider, TemperatureChangeRate.From, out quantity);
-                case Type _ when quantityType == typeof(TemperatureDelta):
-                    return parser.TryParse<TemperatureDelta, TemperatureDeltaUnit>(quantityString, formatProvider, TemperatureDelta.From, out quantity);
-                case Type _ when quantityType == typeof(ThermalConductivity):
-                    return parser.TryParse<ThermalConductivity, ThermalConductivityUnit>(quantityString, formatProvider, ThermalConductivity.From, out quantity);
-                case Type _ when quantityType == typeof(ThermalResistance):
-                    return parser.TryParse<ThermalResistance, ThermalResistanceUnit>(quantityString, formatProvider, ThermalResistance.From, out quantity);
-                case Type _ when quantityType == typeof(Torque):
-                    return parser.TryParse<Torque, TorqueUnit>(quantityString, formatProvider, Torque.From, out quantity);
-                case Type _ when quantityType == typeof(TorquePerLength):
-                    return parser.TryParse<TorquePerLength, TorquePerLengthUnit>(quantityString, formatProvider, TorquePerLength.From, out quantity);
-                case Type _ when quantityType == typeof(Turbidity):
-                    return parser.TryParse<Turbidity, TurbidityUnit>(quantityString, formatProvider, Turbidity.From, out quantity);
-                case Type _ when quantityType == typeof(VitaminA):
-                    return parser.TryParse<VitaminA, VitaminAUnit>(quantityString, formatProvider, VitaminA.From, out quantity);
-                case Type _ when quantityType == typeof(Volume):
-                    return parser.TryParse<Volume, VolumeUnit>(quantityString, formatProvider, Volume.From, out quantity);
-                case Type _ when quantityType == typeof(VolumeConcentration):
-                    return parser.TryParse<VolumeConcentration, VolumeConcentrationUnit>(quantityString, formatProvider, VolumeConcentration.From, out quantity);
-                case Type _ when quantityType == typeof(VolumeFlow):
-                    return parser.TryParse<VolumeFlow, VolumeFlowUnit>(quantityString, formatProvider, VolumeFlow.From, out quantity);
-                case Type _ when quantityType == typeof(VolumePerLength):
-                    return parser.TryParse<VolumePerLength, VolumePerLengthUnit>(quantityString, formatProvider, VolumePerLength.From, out quantity);
-                case Type _ when quantityType == typeof(WarpingMomentOfInertia):
-                    return parser.TryParse<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(quantityString, formatProvider, WarpingMomentOfInertia.From, out quantity);
+                case Type _ when quantityType == typeof(Acceleration<T>):
+                    return parser.TryParse<Acceleration<T>, AccelerationUnit>(quantityString, formatProvider, Acceleration<T>.From, out quantity);
+                case Type _ when quantityType == typeof(AmountOfSubstance<T>):
+                    return parser.TryParse<AmountOfSubstance<T>, AmountOfSubstanceUnit>(quantityString, formatProvider, AmountOfSubstance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(AmplitudeRatio<T>):
+                    return parser.TryParse<AmplitudeRatio<T>, AmplitudeRatioUnit>(quantityString, formatProvider, AmplitudeRatio<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Angle<T>):
+                    return parser.TryParse<Angle<T>, AngleUnit>(quantityString, formatProvider, Angle<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ApparentEnergy<T>):
+                    return parser.TryParse<ApparentEnergy<T>, ApparentEnergyUnit>(quantityString, formatProvider, ApparentEnergy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ApparentPower<T>):
+                    return parser.TryParse<ApparentPower<T>, ApparentPowerUnit>(quantityString, formatProvider, ApparentPower<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Area<T>):
+                    return parser.TryParse<Area<T>, AreaUnit>(quantityString, formatProvider, Area<T>.From, out quantity);
+                case Type _ when quantityType == typeof(AreaDensity<T>):
+                    return parser.TryParse<AreaDensity<T>, AreaDensityUnit>(quantityString, formatProvider, AreaDensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(AreaMomentOfInertia<T>):
+                    return parser.TryParse<AreaMomentOfInertia<T>, AreaMomentOfInertiaUnit>(quantityString, formatProvider, AreaMomentOfInertia<T>.From, out quantity);
+                case Type _ when quantityType == typeof(BitRate<T>):
+                    return parser.TryParse<BitRate<T>, BitRateUnit>(quantityString, formatProvider, BitRate<T>.From, out quantity);
+                case Type _ when quantityType == typeof(BrakeSpecificFuelConsumption<T>):
+                    return parser.TryParse<BrakeSpecificFuelConsumption<T>, BrakeSpecificFuelConsumptionUnit>(quantityString, formatProvider, BrakeSpecificFuelConsumption<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Capacitance<T>):
+                    return parser.TryParse<Capacitance<T>, CapacitanceUnit>(quantityString, formatProvider, Capacitance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(CoefficientOfThermalExpansion<T>):
+                    return parser.TryParse<CoefficientOfThermalExpansion<T>, CoefficientOfThermalExpansionUnit>(quantityString, formatProvider, CoefficientOfThermalExpansion<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Density<T>):
+                    return parser.TryParse<Density<T>, DensityUnit>(quantityString, formatProvider, Density<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Duration<T>):
+                    return parser.TryParse<Duration<T>, DurationUnit>(quantityString, formatProvider, Duration<T>.From, out quantity);
+                case Type _ when quantityType == typeof(DynamicViscosity<T>):
+                    return parser.TryParse<DynamicViscosity<T>, DynamicViscosityUnit>(quantityString, formatProvider, DynamicViscosity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricAdmittance<T>):
+                    return parser.TryParse<ElectricAdmittance<T>, ElectricAdmittanceUnit>(quantityString, formatProvider, ElectricAdmittance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricCharge<T>):
+                    return parser.TryParse<ElectricCharge<T>, ElectricChargeUnit>(quantityString, formatProvider, ElectricCharge<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricChargeDensity<T>):
+                    return parser.TryParse<ElectricChargeDensity<T>, ElectricChargeDensityUnit>(quantityString, formatProvider, ElectricChargeDensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricConductance<T>):
+                    return parser.TryParse<ElectricConductance<T>, ElectricConductanceUnit>(quantityString, formatProvider, ElectricConductance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricConductivity<T>):
+                    return parser.TryParse<ElectricConductivity<T>, ElectricConductivityUnit>(quantityString, formatProvider, ElectricConductivity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricCurrent<T>):
+                    return parser.TryParse<ElectricCurrent<T>, ElectricCurrentUnit>(quantityString, formatProvider, ElectricCurrent<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricCurrentDensity<T>):
+                    return parser.TryParse<ElectricCurrentDensity<T>, ElectricCurrentDensityUnit>(quantityString, formatProvider, ElectricCurrentDensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricCurrentGradient<T>):
+                    return parser.TryParse<ElectricCurrentGradient<T>, ElectricCurrentGradientUnit>(quantityString, formatProvider, ElectricCurrentGradient<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricField<T>):
+                    return parser.TryParse<ElectricField<T>, ElectricFieldUnit>(quantityString, formatProvider, ElectricField<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricInductance<T>):
+                    return parser.TryParse<ElectricInductance<T>, ElectricInductanceUnit>(quantityString, formatProvider, ElectricInductance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricPotential<T>):
+                    return parser.TryParse<ElectricPotential<T>, ElectricPotentialUnit>(quantityString, formatProvider, ElectricPotential<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricPotentialAc<T>):
+                    return parser.TryParse<ElectricPotentialAc<T>, ElectricPotentialAcUnit>(quantityString, formatProvider, ElectricPotentialAc<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricPotentialChangeRate<T>):
+                    return parser.TryParse<ElectricPotentialChangeRate<T>, ElectricPotentialChangeRateUnit>(quantityString, formatProvider, ElectricPotentialChangeRate<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricPotentialDc<T>):
+                    return parser.TryParse<ElectricPotentialDc<T>, ElectricPotentialDcUnit>(quantityString, formatProvider, ElectricPotentialDc<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricResistance<T>):
+                    return parser.TryParse<ElectricResistance<T>, ElectricResistanceUnit>(quantityString, formatProvider, ElectricResistance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricResistivity<T>):
+                    return parser.TryParse<ElectricResistivity<T>, ElectricResistivityUnit>(quantityString, formatProvider, ElectricResistivity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ElectricSurfaceChargeDensity<T>):
+                    return parser.TryParse<ElectricSurfaceChargeDensity<T>, ElectricSurfaceChargeDensityUnit>(quantityString, formatProvider, ElectricSurfaceChargeDensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Energy<T>):
+                    return parser.TryParse<Energy<T>, EnergyUnit>(quantityString, formatProvider, Energy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Entropy<T>):
+                    return parser.TryParse<Entropy<T>, EntropyUnit>(quantityString, formatProvider, Entropy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Force<T>):
+                    return parser.TryParse<Force<T>, ForceUnit>(quantityString, formatProvider, Force<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ForceChangeRate<T>):
+                    return parser.TryParse<ForceChangeRate<T>, ForceChangeRateUnit>(quantityString, formatProvider, ForceChangeRate<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ForcePerLength<T>):
+                    return parser.TryParse<ForcePerLength<T>, ForcePerLengthUnit>(quantityString, formatProvider, ForcePerLength<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Frequency<T>):
+                    return parser.TryParse<Frequency<T>, FrequencyUnit>(quantityString, formatProvider, Frequency<T>.From, out quantity);
+                case Type _ when quantityType == typeof(FuelEfficiency<T>):
+                    return parser.TryParse<FuelEfficiency<T>, FuelEfficiencyUnit>(quantityString, formatProvider, FuelEfficiency<T>.From, out quantity);
+                case Type _ when quantityType == typeof(HeatFlux<T>):
+                    return parser.TryParse<HeatFlux<T>, HeatFluxUnit>(quantityString, formatProvider, HeatFlux<T>.From, out quantity);
+                case Type _ when quantityType == typeof(HeatTransferCoefficient<T>):
+                    return parser.TryParse<HeatTransferCoefficient<T>, HeatTransferCoefficientUnit>(quantityString, formatProvider, HeatTransferCoefficient<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Illuminance<T>):
+                    return parser.TryParse<Illuminance<T>, IlluminanceUnit>(quantityString, formatProvider, Illuminance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Information<T>):
+                    return parser.TryParse<Information<T>, InformationUnit>(quantityString, formatProvider, Information<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Irradiance<T>):
+                    return parser.TryParse<Irradiance<T>, IrradianceUnit>(quantityString, formatProvider, Irradiance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Irradiation<T>):
+                    return parser.TryParse<Irradiation<T>, IrradiationUnit>(quantityString, formatProvider, Irradiation<T>.From, out quantity);
+                case Type _ when quantityType == typeof(KinematicViscosity<T>):
+                    return parser.TryParse<KinematicViscosity<T>, KinematicViscosityUnit>(quantityString, formatProvider, KinematicViscosity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(LapseRate<T>):
+                    return parser.TryParse<LapseRate<T>, LapseRateUnit>(quantityString, formatProvider, LapseRate<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Length<T>):
+                    return parser.TryParse<Length<T>, LengthUnit>(quantityString, formatProvider, Length<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Level<T>):
+                    return parser.TryParse<Level<T>, LevelUnit>(quantityString, formatProvider, Level<T>.From, out quantity);
+                case Type _ when quantityType == typeof(LinearDensity<T>):
+                    return parser.TryParse<LinearDensity<T>, LinearDensityUnit>(quantityString, formatProvider, LinearDensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(LinearPowerDensity<T>):
+                    return parser.TryParse<LinearPowerDensity<T>, LinearPowerDensityUnit>(quantityString, formatProvider, LinearPowerDensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Luminosity<T>):
+                    return parser.TryParse<Luminosity<T>, LuminosityUnit>(quantityString, formatProvider, Luminosity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(LuminousFlux<T>):
+                    return parser.TryParse<LuminousFlux<T>, LuminousFluxUnit>(quantityString, formatProvider, LuminousFlux<T>.From, out quantity);
+                case Type _ when quantityType == typeof(LuminousIntensity<T>):
+                    return parser.TryParse<LuminousIntensity<T>, LuminousIntensityUnit>(quantityString, formatProvider, LuminousIntensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MagneticField<T>):
+                    return parser.TryParse<MagneticField<T>, MagneticFieldUnit>(quantityString, formatProvider, MagneticField<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MagneticFlux<T>):
+                    return parser.TryParse<MagneticFlux<T>, MagneticFluxUnit>(quantityString, formatProvider, MagneticFlux<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Magnetization<T>):
+                    return parser.TryParse<Magnetization<T>, MagnetizationUnit>(quantityString, formatProvider, Magnetization<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Mass<T>):
+                    return parser.TryParse<Mass<T>, MassUnit>(quantityString, formatProvider, Mass<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MassConcentration<T>):
+                    return parser.TryParse<MassConcentration<T>, MassConcentrationUnit>(quantityString, formatProvider, MassConcentration<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MassFlow<T>):
+                    return parser.TryParse<MassFlow<T>, MassFlowUnit>(quantityString, formatProvider, MassFlow<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MassFlux<T>):
+                    return parser.TryParse<MassFlux<T>, MassFluxUnit>(quantityString, formatProvider, MassFlux<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MassFraction<T>):
+                    return parser.TryParse<MassFraction<T>, MassFractionUnit>(quantityString, formatProvider, MassFraction<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MassMomentOfInertia<T>):
+                    return parser.TryParse<MassMomentOfInertia<T>, MassMomentOfInertiaUnit>(quantityString, formatProvider, MassMomentOfInertia<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MolarEnergy<T>):
+                    return parser.TryParse<MolarEnergy<T>, MolarEnergyUnit>(quantityString, formatProvider, MolarEnergy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MolarEntropy<T>):
+                    return parser.TryParse<MolarEntropy<T>, MolarEntropyUnit>(quantityString, formatProvider, MolarEntropy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Molarity<T>):
+                    return parser.TryParse<Molarity<T>, MolarityUnit>(quantityString, formatProvider, Molarity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(MolarMass<T>):
+                    return parser.TryParse<MolarMass<T>, MolarMassUnit>(quantityString, formatProvider, MolarMass<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Permeability<T>):
+                    return parser.TryParse<Permeability<T>, PermeabilityUnit>(quantityString, formatProvider, Permeability<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Permittivity<T>):
+                    return parser.TryParse<Permittivity<T>, PermittivityUnit>(quantityString, formatProvider, Permittivity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Power<T>):
+                    return parser.TryParse<Power<T>, PowerUnit>(quantityString, formatProvider, Power<T>.From, out quantity);
+                case Type _ when quantityType == typeof(PowerDensity<T>):
+                    return parser.TryParse<PowerDensity<T>, PowerDensityUnit>(quantityString, formatProvider, PowerDensity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(PowerRatio<T>):
+                    return parser.TryParse<PowerRatio<T>, PowerRatioUnit>(quantityString, formatProvider, PowerRatio<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Pressure<T>):
+                    return parser.TryParse<Pressure<T>, PressureUnit>(quantityString, formatProvider, Pressure<T>.From, out quantity);
+                case Type _ when quantityType == typeof(PressureChangeRate<T>):
+                    return parser.TryParse<PressureChangeRate<T>, PressureChangeRateUnit>(quantityString, formatProvider, PressureChangeRate<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Ratio<T>):
+                    return parser.TryParse<Ratio<T>, RatioUnit>(quantityString, formatProvider, Ratio<T>.From, out quantity);
+                case Type _ when quantityType == typeof(RatioChangeRate<T>):
+                    return parser.TryParse<RatioChangeRate<T>, RatioChangeRateUnit>(quantityString, formatProvider, RatioChangeRate<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ReactiveEnergy<T>):
+                    return parser.TryParse<ReactiveEnergy<T>, ReactiveEnergyUnit>(quantityString, formatProvider, ReactiveEnergy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ReactivePower<T>):
+                    return parser.TryParse<ReactivePower<T>, ReactivePowerUnit>(quantityString, formatProvider, ReactivePower<T>.From, out quantity);
+                case Type _ when quantityType == typeof(RelativeHumidity<T>):
+                    return parser.TryParse<RelativeHumidity<T>, RelativeHumidityUnit>(quantityString, formatProvider, RelativeHumidity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(RotationalAcceleration<T>):
+                    return parser.TryParse<RotationalAcceleration<T>, RotationalAccelerationUnit>(quantityString, formatProvider, RotationalAcceleration<T>.From, out quantity);
+                case Type _ when quantityType == typeof(RotationalSpeed<T>):
+                    return parser.TryParse<RotationalSpeed<T>, RotationalSpeedUnit>(quantityString, formatProvider, RotationalSpeed<T>.From, out quantity);
+                case Type _ when quantityType == typeof(RotationalStiffness<T>):
+                    return parser.TryParse<RotationalStiffness<T>, RotationalStiffnessUnit>(quantityString, formatProvider, RotationalStiffness<T>.From, out quantity);
+                case Type _ when quantityType == typeof(RotationalStiffnessPerLength<T>):
+                    return parser.TryParse<RotationalStiffnessPerLength<T>, RotationalStiffnessPerLengthUnit>(quantityString, formatProvider, RotationalStiffnessPerLength<T>.From, out quantity);
+                case Type _ when quantityType == typeof(SolidAngle<T>):
+                    return parser.TryParse<SolidAngle<T>, SolidAngleUnit>(quantityString, formatProvider, SolidAngle<T>.From, out quantity);
+                case Type _ when quantityType == typeof(SpecificEnergy<T>):
+                    return parser.TryParse<SpecificEnergy<T>, SpecificEnergyUnit>(quantityString, formatProvider, SpecificEnergy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(SpecificEntropy<T>):
+                    return parser.TryParse<SpecificEntropy<T>, SpecificEntropyUnit>(quantityString, formatProvider, SpecificEntropy<T>.From, out quantity);
+                case Type _ when quantityType == typeof(SpecificVolume<T>):
+                    return parser.TryParse<SpecificVolume<T>, SpecificVolumeUnit>(quantityString, formatProvider, SpecificVolume<T>.From, out quantity);
+                case Type _ when quantityType == typeof(SpecificWeight<T>):
+                    return parser.TryParse<SpecificWeight<T>, SpecificWeightUnit>(quantityString, formatProvider, SpecificWeight<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Speed<T>):
+                    return parser.TryParse<Speed<T>, SpeedUnit>(quantityString, formatProvider, Speed<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Temperature<T>):
+                    return parser.TryParse<Temperature<T>, TemperatureUnit>(quantityString, formatProvider, Temperature<T>.From, out quantity);
+                case Type _ when quantityType == typeof(TemperatureChangeRate<T>):
+                    return parser.TryParse<TemperatureChangeRate<T>, TemperatureChangeRateUnit>(quantityString, formatProvider, TemperatureChangeRate<T>.From, out quantity);
+                case Type _ when quantityType == typeof(TemperatureDelta<T>):
+                    return parser.TryParse<TemperatureDelta<T>, TemperatureDeltaUnit>(quantityString, formatProvider, TemperatureDelta<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ThermalConductivity<T>):
+                    return parser.TryParse<ThermalConductivity<T>, ThermalConductivityUnit>(quantityString, formatProvider, ThermalConductivity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(ThermalResistance<T>):
+                    return parser.TryParse<ThermalResistance<T>, ThermalResistanceUnit>(quantityString, formatProvider, ThermalResistance<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Torque<T>):
+                    return parser.TryParse<Torque<T>, TorqueUnit>(quantityString, formatProvider, Torque<T>.From, out quantity);
+                case Type _ when quantityType == typeof(TorquePerLength<T>):
+                    return parser.TryParse<TorquePerLength<T>, TorquePerLengthUnit>(quantityString, formatProvider, TorquePerLength<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Turbidity<T>):
+                    return parser.TryParse<Turbidity<T>, TurbidityUnit>(quantityString, formatProvider, Turbidity<T>.From, out quantity);
+                case Type _ when quantityType == typeof(VitaminA<T>):
+                    return parser.TryParse<VitaminA<T>, VitaminAUnit>(quantityString, formatProvider, VitaminA<T>.From, out quantity);
+                case Type _ when quantityType == typeof(Volume<T>):
+                    return parser.TryParse<Volume<T>, VolumeUnit>(quantityString, formatProvider, Volume<T>.From, out quantity);
+                case Type _ when quantityType == typeof(VolumeConcentration<T>):
+                    return parser.TryParse<VolumeConcentration<T>, VolumeConcentrationUnit>(quantityString, formatProvider, VolumeConcentration<T>.From, out quantity);
+                case Type _ when quantityType == typeof(VolumeFlow<T>):
+                    return parser.TryParse<VolumeFlow<T>, VolumeFlowUnit>(quantityString, formatProvider, VolumeFlow<T>.From, out quantity);
+                case Type _ when quantityType == typeof(VolumePerLength<T>):
+                    return parser.TryParse<VolumePerLength<T>, VolumePerLengthUnit>(quantityString, formatProvider, VolumePerLength<T>.From, out quantity);
+                case Type _ when quantityType == typeof(WarpingMomentOfInertia<T>):
+                    return parser.TryParse<WarpingMomentOfInertia<T>, WarpingMomentOfInertiaUnit>(quantityString, formatProvider, WarpingMomentOfInertia<T>.From, out quantity);
                 default:
                     return false;
             }
diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs
index ade5906c03..817fca7698 100644
--- a/UnitsNet/GeneratedCode/UnitConverter.g.cs
+++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs
@@ -24,2436 +24,2436 @@
 
 namespace UnitsNet
 {
-    public sealed partial class UnitConverter
+    public sealed partial class UnitConverter<T>
     {
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
+        /// Registers the default conversion functions in the given <see cref="UnitConverter{T}"/> instance.
         /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        public static void RegisterDefaultConversions(UnitConverter unitConverter)
+        /// <param name="unitConverter">The <see cref="UnitConverter{T}"/> to register the default conversion functions in.</param>
+        public static void RegisterDefaultConversions(UnitConverter<T> unitConverter)
         {
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.CentimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.CentimeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.CentimeterPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.DecimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.DecimeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.DecimeterPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.FootPerSecondSquared, q => q.ToUnit(AccelerationUnit.FootPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.FootPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.InchPerSecondSquared, q => q.ToUnit(AccelerationUnit.InchPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.InchPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.KilometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.KilometerPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KilometerPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.KnotPerHour, q => q.ToUnit(AccelerationUnit.KnotPerHour));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KnotPerHour, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.KnotPerMinute, q => q.ToUnit(AccelerationUnit.KnotPerMinute));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KnotPerMinute, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.KnotPerSecond, q => q.ToUnit(AccelerationUnit.KnotPerSecond));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KnotPerSecond, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, Acceleration.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.MicrometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.MicrometerPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MicrometerPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.MillimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.MillimeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MillimeterPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.MillistandardGravity, q => q.ToUnit(AccelerationUnit.MillistandardGravity));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MillistandardGravity, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.NanometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.NanometerPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.NanometerPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Acceleration>(Acceleration.BaseUnit, AccelerationUnit.StandardGravity, q => q.ToUnit(AccelerationUnit.StandardGravity));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.StandardGravity, Acceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Centimole, q => q.ToUnit(AmountOfSubstanceUnit.Centimole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Centimole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.CentipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.CentipoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Decimole, q => q.ToUnit(AmountOfSubstanceUnit.Decimole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Decimole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.DecipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.DecipoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Kilomole, q => q.ToUnit(AmountOfSubstanceUnit.Kilomole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Kilomole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.KilopoundMole, q => q.ToUnit(AmountOfSubstanceUnit.KilopoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Megamole, q => q.ToUnit(AmountOfSubstanceUnit.Megamole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Megamole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Micromole, q => q.ToUnit(AmountOfSubstanceUnit.Micromole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Micromole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MicropoundMole, q => q.ToUnit(AmountOfSubstanceUnit.MicropoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Millimole, q => q.ToUnit(AmountOfSubstanceUnit.Millimole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Millimole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MillipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.MillipoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Nanomole, q => q.ToUnit(AmountOfSubstanceUnit.Nanomole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Nanomole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.NanopoundMole, q => q.ToUnit(AmountOfSubstanceUnit.NanopoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.PoundMole, q => q.ToUnit(AmountOfSubstanceUnit.PoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.PoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMicrovolt, q => q.ToUnit(AmplitudeRatioUnit.DecibelMicrovolt));
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMillivolt, q => q.ToUnit(AmplitudeRatioUnit.DecibelMillivolt));
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelUnloaded, q => q.ToUnit(AmplitudeRatioUnit.DecibelUnloaded));
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatio.BaseUnit, AmplitudeRatio.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Arcminute, q => q.ToUnit(AngleUnit.Arcminute));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Arcminute, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Arcsecond, q => q.ToUnit(AngleUnit.Arcsecond));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Arcsecond, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Centiradian, q => q.ToUnit(AngleUnit.Centiradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Centiradian, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Deciradian, q => q.ToUnit(AngleUnit.Deciradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Deciradian, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, Angle.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Gradian, q => q.ToUnit(AngleUnit.Gradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Gradian, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Microdegree, q => q.ToUnit(AngleUnit.Microdegree));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Microdegree, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Microradian, q => q.ToUnit(AngleUnit.Microradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Microradian, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Millidegree, q => q.ToUnit(AngleUnit.Millidegree));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Millidegree, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Milliradian, q => q.ToUnit(AngleUnit.Milliradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Milliradian, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Nanodegree, q => q.ToUnit(AngleUnit.Nanodegree));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Nanodegree, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Nanoradian, q => q.ToUnit(AngleUnit.Nanoradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Nanoradian, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Radian, q => q.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Angle>(Angle.BaseUnit, AngleUnit.Revolution, q => q.ToUnit(AngleUnit.Revolution));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Revolution, Angle.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ApparentEnergy>(ApparentEnergy.BaseUnit, ApparentEnergyUnit.KilovoltampereHour, q => q.ToUnit(ApparentEnergyUnit.KilovoltampereHour));
-            unitConverter.SetConversionFunction<ApparentEnergy>(ApparentEnergyUnit.KilovoltampereHour, ApparentEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ApparentEnergy>(ApparentEnergy.BaseUnit, ApparentEnergyUnit.MegavoltampereHour, q => q.ToUnit(ApparentEnergyUnit.MegavoltampereHour));
-            unitConverter.SetConversionFunction<ApparentEnergy>(ApparentEnergyUnit.MegavoltampereHour, ApparentEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ApparentEnergy>(ApparentEnergy.BaseUnit, ApparentEnergy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ApparentPower>(ApparentPower.BaseUnit, ApparentPowerUnit.Gigavoltampere, q => q.ToUnit(ApparentPowerUnit.Gigavoltampere));
-            unitConverter.SetConversionFunction<ApparentPower>(ApparentPowerUnit.Gigavoltampere, ApparentPower.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ApparentPower>(ApparentPower.BaseUnit, ApparentPowerUnit.Kilovoltampere, q => q.ToUnit(ApparentPowerUnit.Kilovoltampere));
-            unitConverter.SetConversionFunction<ApparentPower>(ApparentPowerUnit.Kilovoltampere, ApparentPower.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ApparentPower>(ApparentPower.BaseUnit, ApparentPowerUnit.Megavoltampere, q => q.ToUnit(ApparentPowerUnit.Megavoltampere));
-            unitConverter.SetConversionFunction<ApparentPower>(ApparentPowerUnit.Megavoltampere, ApparentPower.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ApparentPower>(ApparentPower.BaseUnit, ApparentPower.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.Acre, q => q.ToUnit(AreaUnit.Acre));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.Acre, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.Hectare, q => q.ToUnit(AreaUnit.Hectare));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.Hectare, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareCentimeter, q => q.ToUnit(AreaUnit.SquareCentimeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareCentimeter, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareDecimeter, q => q.ToUnit(AreaUnit.SquareDecimeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareDecimeter, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareFoot, q => q.ToUnit(AreaUnit.SquareFoot));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareFoot, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareInch, q => q.ToUnit(AreaUnit.SquareInch));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareInch, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareKilometer, q => q.ToUnit(AreaUnit.SquareKilometer));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareKilometer, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, Area.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareMicrometer, q => q.ToUnit(AreaUnit.SquareMicrometer));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMicrometer, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareMile, q => q.ToUnit(AreaUnit.SquareMile));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMile, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareMillimeter, q => q.ToUnit(AreaUnit.SquareMillimeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMillimeter, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareNauticalMile, q => q.ToUnit(AreaUnit.SquareNauticalMile));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareNauticalMile, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.SquareYard, q => q.ToUnit(AreaUnit.SquareYard));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareYard, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Area>(Area.BaseUnit, AreaUnit.UsSurveySquareFoot, q => q.ToUnit(AreaUnit.UsSurveySquareFoot));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.UsSurveySquareFoot, Area.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AreaDensity>(AreaDensity.BaseUnit, AreaDensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.CentimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.DecimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.FootToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.InchToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertia.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.MillimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRate.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.BytePerSecond, q => q.ToUnit(BitRateUnit.BytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.ExabitPerSecond, q => q.ToUnit(BitRateUnit.ExabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.ExabytePerSecond, q => q.ToUnit(BitRateUnit.ExabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.ExbibitPerSecond, q => q.ToUnit(BitRateUnit.ExbibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExbibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.ExbibytePerSecond, q => q.ToUnit(BitRateUnit.ExbibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExbibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.GibibitPerSecond, q => q.ToUnit(BitRateUnit.GibibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GibibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.GibibytePerSecond, q => q.ToUnit(BitRateUnit.GibibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GibibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.GigabitPerSecond, q => q.ToUnit(BitRateUnit.GigabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GigabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.GigabytePerSecond, q => q.ToUnit(BitRateUnit.GigabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GigabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.KibibitPerSecond, q => q.ToUnit(BitRateUnit.KibibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KibibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.KibibytePerSecond, q => q.ToUnit(BitRateUnit.KibibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KibibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.KilobitPerSecond, q => q.ToUnit(BitRateUnit.KilobitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KilobitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.KilobytePerSecond, q => q.ToUnit(BitRateUnit.KilobytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KilobytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.MebibitPerSecond, q => q.ToUnit(BitRateUnit.MebibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MebibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.MebibytePerSecond, q => q.ToUnit(BitRateUnit.MebibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MebibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.MegabitPerSecond, q => q.ToUnit(BitRateUnit.MegabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MegabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.MegabytePerSecond, q => q.ToUnit(BitRateUnit.MegabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MegabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.PebibitPerSecond, q => q.ToUnit(BitRateUnit.PebibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PebibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.PebibytePerSecond, q => q.ToUnit(BitRateUnit.PebibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PebibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.PetabitPerSecond, q => q.ToUnit(BitRateUnit.PetabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PetabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.PetabytePerSecond, q => q.ToUnit(BitRateUnit.PetabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PetabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.TebibitPerSecond, q => q.ToUnit(BitRateUnit.TebibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TebibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.TebibytePerSecond, q => q.ToUnit(BitRateUnit.TebibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TebibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.TerabitPerSecond, q => q.ToUnit(BitRateUnit.TerabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TerabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BitRate>(BitRate.BaseUnit, BitRateUnit.TerabytePerSecond, q => q.ToUnit(BitRateUnit.TerabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TerabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, q => q.ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour));
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumption.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumption.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, q => q.ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour));
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumption.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Capacitance>(Capacitance.BaseUnit, Capacitance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Capacitance>(Capacitance.BaseUnit, CapacitanceUnit.Kilofarad, q => q.ToUnit(CapacitanceUnit.Kilofarad));
-            unitConverter.SetConversionFunction<Capacitance>(CapacitanceUnit.Kilofarad, Capacitance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Capacitance>(Capacitance.BaseUnit, CapacitanceUnit.Megafarad, q => q.ToUnit(CapacitanceUnit.Megafarad));
-            unitConverter.SetConversionFunction<Capacitance>(CapacitanceUnit.Megafarad, Capacitance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Capacitance>(Capacitance.BaseUnit, CapacitanceUnit.Microfarad, q => q.ToUnit(CapacitanceUnit.Microfarad));
-            unitConverter.SetConversionFunction<Capacitance>(CapacitanceUnit.Microfarad, Capacitance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Capacitance>(Capacitance.BaseUnit, CapacitanceUnit.Millifarad, q => q.ToUnit(CapacitanceUnit.Millifarad));
-            unitConverter.SetConversionFunction<Capacitance>(CapacitanceUnit.Millifarad, Capacitance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Capacitance>(Capacitance.BaseUnit, CapacitanceUnit.Nanofarad, q => q.ToUnit(CapacitanceUnit.Nanofarad));
-            unitConverter.SetConversionFunction<Capacitance>(CapacitanceUnit.Nanofarad, Capacitance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Capacitance>(Capacitance.BaseUnit, CapacitanceUnit.Picofarad, q => q.ToUnit(CapacitanceUnit.Picofarad));
-            unitConverter.SetConversionFunction<Capacitance>(CapacitanceUnit.Picofarad, Capacitance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, q => q.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, CoefficientOfThermalExpansion.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, q => q.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, CoefficientOfThermalExpansion.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansion.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.CentigramPerDeciliter, q => q.ToUnit(DensityUnit.CentigramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.CentigramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.CentigramPerLiter, q => q.ToUnit(DensityUnit.CentigramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.CentigramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.CentigramPerMilliliter, q => q.ToUnit(DensityUnit.CentigramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.CentigramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.DecigramPerDeciliter, q => q.ToUnit(DensityUnit.DecigramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.DecigramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.DecigramPerLiter, q => q.ToUnit(DensityUnit.DecigramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.DecigramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.DecigramPerMilliliter, q => q.ToUnit(DensityUnit.DecigramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.DecigramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.GramPerCubicCentimeter, q => q.ToUnit(DensityUnit.GramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.GramPerCubicMeter, q => q.ToUnit(DensityUnit.GramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.GramPerCubicMillimeter, q => q.ToUnit(DensityUnit.GramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.GramPerDeciliter, q => q.ToUnit(DensityUnit.GramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.GramPerLiter, q => q.ToUnit(DensityUnit.GramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.GramPerMilliliter, q => q.ToUnit(DensityUnit.GramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.KilogramPerCubicCentimeter, q => q.ToUnit(DensityUnit.KilogramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, Density.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.KilogramPerCubicMillimeter, q => q.ToUnit(DensityUnit.KilogramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.KilogramPerLiter, q => q.ToUnit(DensityUnit.KilogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.KilopoundPerCubicFoot, q => q.ToUnit(DensityUnit.KilopoundPerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilopoundPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.KilopoundPerCubicInch, q => q.ToUnit(DensityUnit.KilopoundPerCubicInch));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilopoundPerCubicInch, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MicrogramPerCubicMeter, q => q.ToUnit(DensityUnit.MicrogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MicrogramPerDeciliter, q => q.ToUnit(DensityUnit.MicrogramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MicrogramPerLiter, q => q.ToUnit(DensityUnit.MicrogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MicrogramPerMilliliter, q => q.ToUnit(DensityUnit.MicrogramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MilligramPerCubicMeter, q => q.ToUnit(DensityUnit.MilligramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MilligramPerDeciliter, q => q.ToUnit(DensityUnit.MilligramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MilligramPerLiter, q => q.ToUnit(DensityUnit.MilligramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.MilligramPerMilliliter, q => q.ToUnit(DensityUnit.MilligramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.NanogramPerDeciliter, q => q.ToUnit(DensityUnit.NanogramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.NanogramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.NanogramPerLiter, q => q.ToUnit(DensityUnit.NanogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.NanogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.NanogramPerMilliliter, q => q.ToUnit(DensityUnit.NanogramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.NanogramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.PicogramPerDeciliter, q => q.ToUnit(DensityUnit.PicogramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PicogramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.PicogramPerLiter, q => q.ToUnit(DensityUnit.PicogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PicogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.PicogramPerMilliliter, q => q.ToUnit(DensityUnit.PicogramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PicogramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.PoundPerCubicFoot, q => q.ToUnit(DensityUnit.PoundPerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.PoundPerCubicInch, q => q.ToUnit(DensityUnit.PoundPerCubicInch));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicInch, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.PoundPerImperialGallon, q => q.ToUnit(DensityUnit.PoundPerImperialGallon));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerImperialGallon, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.PoundPerUSGallon, q => q.ToUnit(DensityUnit.PoundPerUSGallon));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerUSGallon, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.SlugPerCubicFoot, q => q.ToUnit(DensityUnit.SlugPerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.SlugPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.TonnePerCubicCentimeter, q => q.ToUnit(DensityUnit.TonnePerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.TonnePerCubicMeter, q => q.ToUnit(DensityUnit.TonnePerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Density>(Density.BaseUnit, DensityUnit.TonnePerCubicMillimeter, q => q.ToUnit(DensityUnit.TonnePerCubicMillimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Day, q => q.ToUnit(DurationUnit.Day));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Day, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Hour, q => q.ToUnit(DurationUnit.Hour));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Hour, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Microsecond, q => q.ToUnit(DurationUnit.Microsecond));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Microsecond, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Millisecond, q => q.ToUnit(DurationUnit.Millisecond));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Millisecond, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Minute, q => q.ToUnit(DurationUnit.Minute));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Minute, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Month30, q => q.ToUnit(DurationUnit.Month30));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Month30, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Nanosecond, q => q.ToUnit(DurationUnit.Nanosecond));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Nanosecond, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, Duration.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Week, q => q.ToUnit(DurationUnit.Week));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Week, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Duration>(Duration.BaseUnit, DurationUnit.Year365, q => q.ToUnit(DurationUnit.Year365));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Year365, Duration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Centipoise, q => q.ToUnit(DynamicViscosityUnit.Centipoise));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.Centipoise, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MicropascalSecond, q => q.ToUnit(DynamicViscosityUnit.MicropascalSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.MicropascalSecond, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MillipascalSecond, q => q.ToUnit(DynamicViscosityUnit.MillipascalSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.MillipascalSecond, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PascalSecond, q => q.ToUnit(DynamicViscosityUnit.PascalSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PascalSecond, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Poise, q => q.ToUnit(DynamicViscosityUnit.Poise));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.Poise, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PoundForceSecondPerSquareFoot, q => q.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareFoot));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PoundForceSecondPerSquareFoot, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PoundForceSecondPerSquareInch, q => q.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareInch));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PoundForceSecondPerSquareInch, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PoundPerFootSecond, q => q.ToUnit(DynamicViscosityUnit.PoundPerFootSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PoundPerFootSecond, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Reyn, q => q.ToUnit(DynamicViscosityUnit.Reyn));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.Reyn, DynamicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Microsiemens, q => q.ToUnit(ElectricAdmittanceUnit.Microsiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Millisiemens, q => q.ToUnit(ElectricAdmittanceUnit.Millisiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Nanosiemens, q => q.ToUnit(ElectricAdmittanceUnit.Nanosiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittance.BaseUnit, ElectricAdmittance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricCharge.BaseUnit, ElectricChargeUnit.AmpereHour, q => q.ToUnit(ElectricChargeUnit.AmpereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.AmpereHour, ElectricCharge.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricCharge.BaseUnit, ElectricCharge.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricCharge.BaseUnit, ElectricChargeUnit.KiloampereHour, q => q.ToUnit(ElectricChargeUnit.KiloampereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.KiloampereHour, ElectricCharge.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricCharge.BaseUnit, ElectricChargeUnit.MegaampereHour, q => q.ToUnit(ElectricChargeUnit.MegaampereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.MegaampereHour, ElectricCharge.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricCharge.BaseUnit, ElectricChargeUnit.MilliampereHour, q => q.ToUnit(ElectricChargeUnit.MilliampereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.MilliampereHour, ElectricCharge.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricChargeDensity>(ElectricChargeDensity.BaseUnit, ElectricChargeDensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductance.BaseUnit, ElectricConductanceUnit.Microsiemens, q => q.ToUnit(ElectricConductanceUnit.Microsiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Microsiemens, ElectricConductance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductance.BaseUnit, ElectricConductanceUnit.Millisiemens, q => q.ToUnit(ElectricConductanceUnit.Millisiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Millisiemens, ElectricConductance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductance.BaseUnit, ElectricConductance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivity.BaseUnit, ElectricConductivityUnit.SiemensPerFoot, q => q.ToUnit(ElectricConductivityUnit.SiemensPerFoot));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerFoot, ElectricConductivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivity.BaseUnit, ElectricConductivityUnit.SiemensPerInch, q => q.ToUnit(ElectricConductivityUnit.SiemensPerInch));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerInch, ElectricConductivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivity.BaseUnit, ElectricConductivity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrent.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Centiampere, q => q.ToUnit(ElectricCurrentUnit.Centiampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Centiampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Kiloampere, q => q.ToUnit(ElectricCurrentUnit.Kiloampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Kiloampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Megaampere, q => q.ToUnit(ElectricCurrentUnit.Megaampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Megaampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Microampere, q => q.ToUnit(ElectricCurrentUnit.Microampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Microampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Milliampere, q => q.ToUnit(ElectricCurrentUnit.Milliampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Milliampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Nanoampere, q => q.ToUnit(ElectricCurrentUnit.Nanoampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Nanoampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Picoampere, q => q.ToUnit(ElectricCurrentUnit.Picoampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Picoampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensity.BaseUnit, ElectricCurrentDensityUnit.AmperePerSquareFoot, q => q.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareFoot));
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensityUnit.AmperePerSquareFoot, ElectricCurrentDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensity.BaseUnit, ElectricCurrentDensityUnit.AmperePerSquareInch, q => q.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareInch));
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensityUnit.AmperePerSquareInch, ElectricCurrentDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensity.BaseUnit, ElectricCurrentDensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradientUnit.AmperePerMicrosecond, q => q.ToUnit(ElectricCurrentGradientUnit.AmperePerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerMicrosecond, ElectricCurrentGradient.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradientUnit.AmperePerMillisecond, q => q.ToUnit(ElectricCurrentGradientUnit.AmperePerMillisecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerMillisecond, ElectricCurrentGradient.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradientUnit.AmperePerNanosecond, q => q.ToUnit(ElectricCurrentGradientUnit.AmperePerNanosecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerNanosecond, ElectricCurrentGradient.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradient.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricField>(ElectricField.BaseUnit, ElectricField.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductance.BaseUnit, ElectricInductance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductance.BaseUnit, ElectricInductanceUnit.Microhenry, q => q.ToUnit(ElectricInductanceUnit.Microhenry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Microhenry, ElectricInductance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductance.BaseUnit, ElectricInductanceUnit.Millihenry, q => q.ToUnit(ElectricInductanceUnit.Millihenry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Millihenry, ElectricInductance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductance.BaseUnit, ElectricInductanceUnit.Nanohenry, q => q.ToUnit(ElectricInductanceUnit.Nanohenry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Nanohenry, ElectricInductance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotential.BaseUnit, ElectricPotentialUnit.Kilovolt, q => q.ToUnit(ElectricPotentialUnit.Kilovolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Kilovolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotential.BaseUnit, ElectricPotentialUnit.Megavolt, q => q.ToUnit(ElectricPotentialUnit.Megavolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Megavolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotential.BaseUnit, ElectricPotentialUnit.Microvolt, q => q.ToUnit(ElectricPotentialUnit.Microvolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Microvolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotential.BaseUnit, ElectricPotentialUnit.Millivolt, q => q.ToUnit(ElectricPotentialUnit.Millivolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Millivolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotential.BaseUnit, ElectricPotential.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.KilovoltAc, q => q.ToUnit(ElectricPotentialAcUnit.KilovoltAc));
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAcUnit.KilovoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MegavoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MegavoltAc));
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAcUnit.MegavoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MicrovoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MicrovoltAc));
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAcUnit.MicrovoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MillivoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MillivoltAc));
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAcUnit.MillivoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialAc>(ElectricPotentialAc.BaseUnit, ElectricPotentialAc.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerHour, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerMinute, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerSecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerHour, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerMinute, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerSecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerHour, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerHour, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerMinute, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerSecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.VoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.VoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerHour, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.VoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.VoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRateUnit.VoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.VoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerMinute, ElectricPotentialChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRate.BaseUnit, ElectricPotentialChangeRate.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.KilovoltDc, q => q.ToUnit(ElectricPotentialDcUnit.KilovoltDc));
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDcUnit.KilovoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MegavoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MegavoltDc));
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDcUnit.MegavoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MicrovoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MicrovoltDc));
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDcUnit.MicrovoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MillivoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MillivoltDc));
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDcUnit.MillivoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricPotentialDc>(ElectricPotentialDc.BaseUnit, ElectricPotentialDc.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistance.BaseUnit, ElectricResistanceUnit.Gigaohm, q => q.ToUnit(ElectricResistanceUnit.Gigaohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Gigaohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistance.BaseUnit, ElectricResistanceUnit.Kiloohm, q => q.ToUnit(ElectricResistanceUnit.Kiloohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Kiloohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistance.BaseUnit, ElectricResistanceUnit.Megaohm, q => q.ToUnit(ElectricResistanceUnit.Megaohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Megaohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistance.BaseUnit, ElectricResistanceUnit.Microohm, q => q.ToUnit(ElectricResistanceUnit.Microohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Microohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistance.BaseUnit, ElectricResistanceUnit.Milliohm, q => q.ToUnit(ElectricResistanceUnit.Milliohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Milliohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistance.BaseUnit, ElectricResistance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.KiloohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmMeter, q => q.ToUnit(ElectricResistivityUnit.KiloohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.KiloohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MegaohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmMeter, q => q.ToUnit(ElectricResistivityUnit.MegaohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MegaohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MicroohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmMeter, q => q.ToUnit(ElectricResistivityUnit.MicroohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MicroohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MilliohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmMeter, q => q.ToUnit(ElectricResistivityUnit.MilliohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MilliohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.NanoohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmMeter, q => q.ToUnit(ElectricResistivityUnit.NanoohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.NanoohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.OhmCentimeter, q => q.ToUnit(ElectricResistivityUnit.OhmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.PicoohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmMeter, q => q.ToUnit(ElectricResistivityUnit.PicoohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.PicoohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensity.BaseUnit, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, q => q.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter));
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, ElectricSurfaceChargeDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensity.BaseUnit, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, q => q.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch));
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, ElectricSurfaceChargeDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensity.BaseUnit, ElectricSurfaceChargeDensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.BritishThermalUnit, q => q.ToUnit(EnergyUnit.BritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.BritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Calorie, q => q.ToUnit(EnergyUnit.Calorie));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Calorie, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.DecathermEc, q => q.ToUnit(EnergyUnit.DecathermEc));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.DecathermEc, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.DecathermImperial, q => q.ToUnit(EnergyUnit.DecathermImperial));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.DecathermImperial, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.DecathermUs, q => q.ToUnit(EnergyUnit.DecathermUs));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.DecathermUs, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.ElectronVolt, q => q.ToUnit(EnergyUnit.ElectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ElectronVolt, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Erg, q => q.ToUnit(EnergyUnit.Erg));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Erg, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.FootPound, q => q.ToUnit(EnergyUnit.FootPound));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.FootPound, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.GigabritishThermalUnit, q => q.ToUnit(EnergyUnit.GigabritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigabritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.GigaelectronVolt, q => q.ToUnit(EnergyUnit.GigaelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigaelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Gigajoule, q => q.ToUnit(EnergyUnit.Gigajoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Gigajoule, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.GigawattDay, q => q.ToUnit(EnergyUnit.GigawattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigawattDay, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.GigawattHour, q => q.ToUnit(EnergyUnit.GigawattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigawattHour, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.HorsepowerHour, q => q.ToUnit(EnergyUnit.HorsepowerHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.HorsepowerHour, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, Energy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.KilobritishThermalUnit, q => q.ToUnit(EnergyUnit.KilobritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KilobritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Kilocalorie, q => q.ToUnit(EnergyUnit.Kilocalorie));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Kilocalorie, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.KiloelectronVolt, q => q.ToUnit(EnergyUnit.KiloelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KiloelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Kilojoule, q => q.ToUnit(EnergyUnit.Kilojoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Kilojoule, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.KilowattDay, q => q.ToUnit(EnergyUnit.KilowattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KilowattDay, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.KilowattHour, q => q.ToUnit(EnergyUnit.KilowattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KilowattHour, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.MegabritishThermalUnit, q => q.ToUnit(EnergyUnit.MegabritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegabritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Megacalorie, q => q.ToUnit(EnergyUnit.Megacalorie));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Megacalorie, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.MegaelectronVolt, q => q.ToUnit(EnergyUnit.MegaelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegaelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Megajoule, q => q.ToUnit(EnergyUnit.Megajoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Megajoule, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.MegawattDay, q => q.ToUnit(EnergyUnit.MegawattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegawattDay, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.MegawattHour, q => q.ToUnit(EnergyUnit.MegawattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegawattHour, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.Millijoule, q => q.ToUnit(EnergyUnit.Millijoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Millijoule, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.TeraelectronVolt, q => q.ToUnit(EnergyUnit.TeraelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.TeraelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.TerawattDay, q => q.ToUnit(EnergyUnit.TerawattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.TerawattDay, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.TerawattHour, q => q.ToUnit(EnergyUnit.TerawattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.TerawattHour, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.ThermEc, q => q.ToUnit(EnergyUnit.ThermEc));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ThermEc, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.ThermImperial, q => q.ToUnit(EnergyUnit.ThermImperial));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ThermImperial, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.ThermUs, q => q.ToUnit(EnergyUnit.ThermUs));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ThermUs, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.WattDay, q => q.ToUnit(EnergyUnit.WattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.WattDay, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Energy>(Energy.BaseUnit, EnergyUnit.WattHour, q => q.ToUnit(EnergyUnit.WattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.WattHour, Energy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Entropy>(Entropy.BaseUnit, EntropyUnit.CaloriePerKelvin, q => q.ToUnit(EntropyUnit.CaloriePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.CaloriePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Entropy>(Entropy.BaseUnit, EntropyUnit.JoulePerDegreeCelsius, q => q.ToUnit(EntropyUnit.JoulePerDegreeCelsius));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerDegreeCelsius, Entropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Entropy>(Entropy.BaseUnit, Entropy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Entropy>(Entropy.BaseUnit, EntropyUnit.KilocaloriePerKelvin, q => q.ToUnit(EntropyUnit.KilocaloriePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.KilocaloriePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Entropy>(Entropy.BaseUnit, EntropyUnit.KilojoulePerDegreeCelsius, q => q.ToUnit(EntropyUnit.KilojoulePerDegreeCelsius));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.KilojoulePerDegreeCelsius, Entropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Entropy>(Entropy.BaseUnit, EntropyUnit.KilojoulePerKelvin, q => q.ToUnit(EntropyUnit.KilojoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.KilojoulePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Entropy>(Entropy.BaseUnit, EntropyUnit.MegajoulePerKelvin, q => q.ToUnit(EntropyUnit.MegajoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.MegajoulePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Decanewton, q => q.ToUnit(ForceUnit.Decanewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Decanewton, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Dyn, q => q.ToUnit(ForceUnit.Dyn));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Dyn, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.KilogramForce, q => q.ToUnit(ForceUnit.KilogramForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.KilogramForce, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Kilonewton, q => q.ToUnit(ForceUnit.Kilonewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Kilonewton, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.KiloPond, q => q.ToUnit(ForceUnit.KiloPond));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.KiloPond, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.KilopoundForce, q => q.ToUnit(ForceUnit.KilopoundForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.KilopoundForce, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Meganewton, q => q.ToUnit(ForceUnit.Meganewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Meganewton, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Micronewton, q => q.ToUnit(ForceUnit.Micronewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Micronewton, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Millinewton, q => q.ToUnit(ForceUnit.Millinewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Millinewton, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, Force.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.OunceForce, q => q.ToUnit(ForceUnit.OunceForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.OunceForce, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Poundal, q => q.ToUnit(ForceUnit.Poundal));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Poundal, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.PoundForce, q => q.ToUnit(ForceUnit.PoundForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.PoundForce, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.ShortTonForce, q => q.ToUnit(ForceUnit.ShortTonForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.ShortTonForce, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.TonneForce, q => q.ToUnit(ForceUnit.TonneForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.TonneForce, Force.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.CentinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.CentinewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.DecanewtonPerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.DecanewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.DecinewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.KilonewtonPerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.KilonewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MicronewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MicronewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MillinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MillinewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NanonewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.NanonewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.NewtonPerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRate.BaseUnit, ForceChangeRate.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.CentinewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.CentinewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecanewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.DecanewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecanewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecanewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.DecanewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecanewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecanewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.DecanewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecanewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecinewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.DecinewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecinewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.DecinewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecinewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.DecinewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecinewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilogramForcePerCentimeter, q => q.ToUnit(ForcePerLengthUnit.KilogramForcePerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilogramForcePerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilogramForcePerMeter, q => q.ToUnit(ForcePerLengthUnit.KilogramForcePerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilogramForcePerMillimeter, q => q.ToUnit(ForcePerLengthUnit.KilogramForcePerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilogramForcePerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilonewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.KilonewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilonewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilonewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.KilonewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilonewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.KilonewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilonewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilopoundForcePerFoot, q => q.ToUnit(ForcePerLengthUnit.KilopoundForcePerFoot));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilopoundForcePerFoot, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilopoundForcePerInch, q => q.ToUnit(ForcePerLengthUnit.KilopoundForcePerInch));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilopoundForcePerInch, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MeganewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.MeganewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MeganewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MeganewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MeganewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MeganewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.MeganewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MeganewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MicronewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.MicronewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MicronewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MicronewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MicronewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MicronewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.MicronewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MicronewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MillinewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.MillinewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MillinewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MillinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MillinewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.MillinewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.MillinewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MillinewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NanonewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NanonewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.NewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.NewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLength.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.NewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.NewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.PoundForcePerFoot, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerFoot));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.PoundForcePerFoot, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.PoundForcePerInch, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerInch));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.PoundForcePerInch, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.PoundForcePerYard, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerYard));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.PoundForcePerYard, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.TonneForcePerCentimeter, q => q.ToUnit(ForcePerLengthUnit.TonneForcePerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.TonneForcePerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.TonneForcePerMeter, q => q.ToUnit(ForcePerLengthUnit.TonneForcePerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.TonneForcePerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLength.BaseUnit, ForcePerLengthUnit.TonneForcePerMillimeter, q => q.ToUnit(ForcePerLengthUnit.TonneForcePerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.TonneForcePerMillimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.BeatPerMinute, q => q.ToUnit(FrequencyUnit.BeatPerMinute));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.BeatPerMinute, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.CyclePerHour, q => q.ToUnit(FrequencyUnit.CyclePerHour));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.CyclePerHour, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.CyclePerMinute, q => q.ToUnit(FrequencyUnit.CyclePerMinute));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.CyclePerMinute, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.Gigahertz, q => q.ToUnit(FrequencyUnit.Gigahertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Gigahertz, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, Frequency.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.Kilohertz, q => q.ToUnit(FrequencyUnit.Kilohertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Kilohertz, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.Megahertz, q => q.ToUnit(FrequencyUnit.Megahertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Megahertz, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.PerSecond, q => q.ToUnit(FrequencyUnit.PerSecond));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.PerSecond, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.RadianPerSecond, q => q.ToUnit(FrequencyUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.RadianPerSecond, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Frequency>(Frequency.BaseUnit, FrequencyUnit.Terahertz, q => q.ToUnit(FrequencyUnit.Terahertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Terahertz, Frequency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiency.BaseUnit, FuelEfficiencyUnit.KilometerPerLiter, q => q.ToUnit(FuelEfficiencyUnit.KilometerPerLiter));
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiency.BaseUnit, FuelEfficiency.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiency.BaseUnit, FuelEfficiencyUnit.MilePerUkGallon, q => q.ToUnit(FuelEfficiencyUnit.MilePerUkGallon));
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.MilePerUkGallon, FuelEfficiency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiency.BaseUnit, FuelEfficiencyUnit.MilePerUsGallon, q => q.ToUnit(FuelEfficiencyUnit.MilePerUsGallon));
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.MilePerUsGallon, FuelEfficiency.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerHourSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerHourSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerHourSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerMinuteSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerMinuteSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerSecondSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareInch, q => q.ToUnit(HeatFluxUnit.BtuPerSecondSquareInch));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerSecondSquareInch, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.CaloriePerSecondSquareCentimeter, q => q.ToUnit(HeatFluxUnit.CaloriePerSecondSquareCentimeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.CentiwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.CentiwattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.CentiwattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.DeciwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.DeciwattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.DeciwattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerHourSquareMeter, q => q.ToUnit(HeatFluxUnit.KilocaloriePerHourSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, q => q.ToUnit(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.KilowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.KilowattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.KilowattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.MicrowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.MicrowattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.MicrowattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.MilliwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.MilliwattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.MilliwattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.NanowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.NanowattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.NanowattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.PoundForcePerFootSecond, q => q.ToUnit(HeatFluxUnit.PoundForcePerFootSecond));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.PoundForcePerFootSecond, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.PoundPerSecondCubed, q => q.ToUnit(HeatFluxUnit.PoundPerSecondCubed));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.PoundPerSecondCubed, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareFoot, q => q.ToUnit(HeatFluxUnit.WattPerSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareInch, q => q.ToUnit(HeatFluxUnit.WattPerSquareInch));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareInch, HeatFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFlux.BaseUnit, HeatFlux.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, q => q.ToUnit(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, HeatTransferCoefficient.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, q => q.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficient.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Illuminance>(Illuminance.BaseUnit, IlluminanceUnit.Kilolux, q => q.ToUnit(IlluminanceUnit.Kilolux));
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Kilolux, Illuminance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Illuminance>(Illuminance.BaseUnit, Illuminance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Illuminance>(Illuminance.BaseUnit, IlluminanceUnit.Megalux, q => q.ToUnit(IlluminanceUnit.Megalux));
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Megalux, Illuminance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Illuminance>(Illuminance.BaseUnit, IlluminanceUnit.Millilux, q => q.ToUnit(IlluminanceUnit.Millilux));
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Millilux, Illuminance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, Information.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Byte, q => q.ToUnit(InformationUnit.Byte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Byte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Exabit, q => q.ToUnit(InformationUnit.Exabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exabit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Exabyte, q => q.ToUnit(InformationUnit.Exabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exabyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Exbibit, q => q.ToUnit(InformationUnit.Exbibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exbibit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Exbibyte, q => q.ToUnit(InformationUnit.Exbibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exbibyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Gibibit, q => q.ToUnit(InformationUnit.Gibibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gibibit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Gibibyte, q => q.ToUnit(InformationUnit.Gibibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gibibyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Gigabit, q => q.ToUnit(InformationUnit.Gigabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gigabit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Gigabyte, q => q.ToUnit(InformationUnit.Gigabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gigabyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Kibibit, q => q.ToUnit(InformationUnit.Kibibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kibibit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Kibibyte, q => q.ToUnit(InformationUnit.Kibibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kibibyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Kilobit, q => q.ToUnit(InformationUnit.Kilobit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kilobit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Kilobyte, q => q.ToUnit(InformationUnit.Kilobyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kilobyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Mebibit, q => q.ToUnit(InformationUnit.Mebibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Mebibit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Mebibyte, q => q.ToUnit(InformationUnit.Mebibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Mebibyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Megabit, q => q.ToUnit(InformationUnit.Megabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Megabit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Megabyte, q => q.ToUnit(InformationUnit.Megabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Megabyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Pebibit, q => q.ToUnit(InformationUnit.Pebibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Pebibit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Pebibyte, q => q.ToUnit(InformationUnit.Pebibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Pebibyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Petabit, q => q.ToUnit(InformationUnit.Petabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Petabit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Petabyte, q => q.ToUnit(InformationUnit.Petabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Petabyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Tebibit, q => q.ToUnit(InformationUnit.Tebibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Tebibit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Tebibyte, q => q.ToUnit(InformationUnit.Tebibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Tebibyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Terabit, q => q.ToUnit(InformationUnit.Terabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Terabit, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Information>(Information.BaseUnit, InformationUnit.Terabyte, q => q.ToUnit(InformationUnit.Terabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Terabyte, Information.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.KilowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.KilowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.KilowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.KilowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MegawattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MegawattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MegawattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MegawattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MicrowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MicrowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MicrowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MicrowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MilliwattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MilliwattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MilliwattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MilliwattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.NanowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.NanowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.NanowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.NanowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.PicowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.PicowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.PicowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.PicowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, IrradianceUnit.WattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.WattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiance>(Irradiance.BaseUnit, Irradiance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Irradiation>(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareCentimeter, q => q.ToUnit(IrradiationUnit.JoulePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareCentimeter, Irradiation.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiation>(Irradiation.BaseUnit, Irradiation.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Irradiation>(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareMillimeter, q => q.ToUnit(IrradiationUnit.JoulePerSquareMillimeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMillimeter, Irradiation.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiation>(Irradiation.BaseUnit, IrradiationUnit.KilojoulePerSquareMeter, q => q.ToUnit(IrradiationUnit.KilojoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.KilojoulePerSquareMeter, Irradiation.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiation>(Irradiation.BaseUnit, IrradiationUnit.KilowattHourPerSquareMeter, q => q.ToUnit(IrradiationUnit.KilowattHourPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.KilowattHourPerSquareMeter, Irradiation.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiation>(Irradiation.BaseUnit, IrradiationUnit.MillijoulePerSquareCentimeter, q => q.ToUnit(IrradiationUnit.MillijoulePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.MillijoulePerSquareCentimeter, Irradiation.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Irradiation>(Irradiation.BaseUnit, IrradiationUnit.WattHourPerSquareMeter, q => q.ToUnit(IrradiationUnit.WattHourPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.WattHourPerSquareMeter, Irradiation.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Centistokes, q => q.ToUnit(KinematicViscosityUnit.Centistokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Centistokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Decistokes, q => q.ToUnit(KinematicViscosityUnit.Decistokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Decistokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Kilostokes, q => q.ToUnit(KinematicViscosityUnit.Kilostokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Kilostokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Microstokes, q => q.ToUnit(KinematicViscosityUnit.Microstokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Microstokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Millistokes, q => q.ToUnit(KinematicViscosityUnit.Millistokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Millistokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Nanostokes, q => q.ToUnit(KinematicViscosityUnit.Nanostokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Nanostokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Stokes, q => q.ToUnit(KinematicViscosityUnit.Stokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Stokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LapseRate>(LapseRate.BaseUnit, LapseRate.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.AstronomicalUnit, q => q.ToUnit(LengthUnit.AstronomicalUnit));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.AstronomicalUnit, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Centimeter, q => q.ToUnit(LengthUnit.Centimeter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Centimeter, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Chain, q => q.ToUnit(LengthUnit.Chain));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Chain, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Decimeter, q => q.ToUnit(LengthUnit.Decimeter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Decimeter, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.DtpPica, q => q.ToUnit(LengthUnit.DtpPica));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.DtpPica, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.DtpPoint, q => q.ToUnit(LengthUnit.DtpPoint));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.DtpPoint, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Fathom, q => q.ToUnit(LengthUnit.Fathom));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Fathom, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Foot, q => q.ToUnit(LengthUnit.Foot));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Foot, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Hand, q => q.ToUnit(LengthUnit.Hand));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Hand, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Hectometer, q => q.ToUnit(LengthUnit.Hectometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Hectometer, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Inch, q => q.ToUnit(LengthUnit.Inch));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Inch, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.KilolightYear, q => q.ToUnit(LengthUnit.KilolightYear));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.KilolightYear, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Kilometer, q => q.ToUnit(LengthUnit.Kilometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Kilometer, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Kiloparsec, q => q.ToUnit(LengthUnit.Kiloparsec));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Kiloparsec, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.LightYear, q => q.ToUnit(LengthUnit.LightYear));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.LightYear, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.MegalightYear, q => q.ToUnit(LengthUnit.MegalightYear));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.MegalightYear, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Megaparsec, q => q.ToUnit(LengthUnit.Megaparsec));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Megaparsec, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, Length.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Microinch, q => q.ToUnit(LengthUnit.Microinch));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Microinch, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Micrometer, q => q.ToUnit(LengthUnit.Micrometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Micrometer, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Mil, q => q.ToUnit(LengthUnit.Mil));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Mil, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Mile, q => q.ToUnit(LengthUnit.Mile));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Mile, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Millimeter, q => q.ToUnit(LengthUnit.Millimeter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Millimeter, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Nanometer, q => q.ToUnit(LengthUnit.Nanometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Nanometer, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.NauticalMile, q => q.ToUnit(LengthUnit.NauticalMile));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.NauticalMile, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Parsec, q => q.ToUnit(LengthUnit.Parsec));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Parsec, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.PrinterPica, q => q.ToUnit(LengthUnit.PrinterPica));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.PrinterPica, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.PrinterPoint, q => q.ToUnit(LengthUnit.PrinterPoint));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.PrinterPoint, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Shackle, q => q.ToUnit(LengthUnit.Shackle));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Shackle, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.SolarRadius, q => q.ToUnit(LengthUnit.SolarRadius));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.SolarRadius, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Twip, q => q.ToUnit(LengthUnit.Twip));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Twip, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.UsSurveyFoot, q => q.ToUnit(LengthUnit.UsSurveyFoot));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.UsSurveyFoot, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Length>(Length.BaseUnit, LengthUnit.Yard, q => q.ToUnit(LengthUnit.Yard));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Yard, Length.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Level>(Level.BaseUnit, Level.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Level>(Level.BaseUnit, LevelUnit.Neper, q => q.ToUnit(LevelUnit.Neper));
-            unitConverter.SetConversionFunction<Level>(LevelUnit.Neper, Level.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.GramPerCentimeter, q => q.ToUnit(LinearDensityUnit.GramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.GramPerCentimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.GramPerMeter, q => q.ToUnit(LinearDensityUnit.GramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.GramPerMeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.GramPerMillimeter, q => q.ToUnit(LinearDensityUnit.GramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.GramPerMillimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.KilogramPerCentimeter, q => q.ToUnit(LinearDensityUnit.KilogramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerCentimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.KilogramPerMillimeter, q => q.ToUnit(LinearDensityUnit.KilogramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMillimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.MicrogramPerCentimeter, q => q.ToUnit(LinearDensityUnit.MicrogramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MicrogramPerCentimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.MicrogramPerMeter, q => q.ToUnit(LinearDensityUnit.MicrogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MicrogramPerMeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.MicrogramPerMillimeter, q => q.ToUnit(LinearDensityUnit.MicrogramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MicrogramPerMillimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.MilligramPerCentimeter, q => q.ToUnit(LinearDensityUnit.MilligramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MilligramPerCentimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.MilligramPerMeter, q => q.ToUnit(LinearDensityUnit.MilligramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MilligramPerMeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.MilligramPerMillimeter, q => q.ToUnit(LinearDensityUnit.MilligramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MilligramPerMillimeter, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.PoundPerFoot, q => q.ToUnit(LinearDensityUnit.PoundPerFoot));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.PoundPerFoot, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensity.BaseUnit, LinearDensityUnit.PoundPerInch, q => q.ToUnit(LinearDensityUnit.PoundPerInch));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.PoundPerInch, LinearDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerInch, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerInch, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerInch, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerInch, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.WattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.WattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerInch, q => q.ToUnit(LinearPowerDensityUnit.WattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.WattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Decawatt, q => q.ToUnit(LuminosityUnit.Decawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Decawatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Deciwatt, q => q.ToUnit(LuminosityUnit.Deciwatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Deciwatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Femtowatt, q => q.ToUnit(LuminosityUnit.Femtowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Femtowatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Gigawatt, q => q.ToUnit(LuminosityUnit.Gigawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Gigawatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Kilowatt, q => q.ToUnit(LuminosityUnit.Kilowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Kilowatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Megawatt, q => q.ToUnit(LuminosityUnit.Megawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Megawatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Microwatt, q => q.ToUnit(LuminosityUnit.Microwatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Microwatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Milliwatt, q => q.ToUnit(LuminosityUnit.Milliwatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Milliwatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Nanowatt, q => q.ToUnit(LuminosityUnit.Nanowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Nanowatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Petawatt, q => q.ToUnit(LuminosityUnit.Petawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Petawatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Picowatt, q => q.ToUnit(LuminosityUnit.Picowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Picowatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.SolarLuminosity, q => q.ToUnit(LuminosityUnit.SolarLuminosity));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.SolarLuminosity, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, LuminosityUnit.Terawatt, q => q.ToUnit(LuminosityUnit.Terawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Terawatt, Luminosity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Luminosity>(Luminosity.BaseUnit, Luminosity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<LuminousFlux>(LuminousFlux.BaseUnit, LuminousFlux.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<LuminousIntensity>(LuminousIntensity.BaseUnit, LuminousIntensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MagneticField>(MagneticField.BaseUnit, MagneticFieldUnit.Gauss, q => q.ToUnit(MagneticFieldUnit.Gauss));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Gauss, MagneticField.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MagneticField>(MagneticField.BaseUnit, MagneticFieldUnit.Microtesla, q => q.ToUnit(MagneticFieldUnit.Microtesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Microtesla, MagneticField.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MagneticField>(MagneticField.BaseUnit, MagneticFieldUnit.Millitesla, q => q.ToUnit(MagneticFieldUnit.Millitesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Millitesla, MagneticField.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MagneticField>(MagneticField.BaseUnit, MagneticFieldUnit.Nanotesla, q => q.ToUnit(MagneticFieldUnit.Nanotesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Nanotesla, MagneticField.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MagneticField>(MagneticField.BaseUnit, MagneticField.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MagneticFlux>(MagneticFlux.BaseUnit, MagneticFlux.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Magnetization>(Magnetization.BaseUnit, Magnetization.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Centigram, q => q.ToUnit(MassUnit.Centigram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Centigram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Decagram, q => q.ToUnit(MassUnit.Decagram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Decagram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Decigram, q => q.ToUnit(MassUnit.Decigram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Decigram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.EarthMass, q => q.ToUnit(MassUnit.EarthMass));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.EarthMass, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Grain, q => q.ToUnit(MassUnit.Grain));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Grain, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Gram, q => q.ToUnit(MassUnit.Gram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Gram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Hectogram, q => q.ToUnit(MassUnit.Hectogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Hectogram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, Mass.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Kilopound, q => q.ToUnit(MassUnit.Kilopound));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilopound, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Kilotonne, q => q.ToUnit(MassUnit.Kilotonne));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilotonne, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.LongHundredweight, q => q.ToUnit(MassUnit.LongHundredweight));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.LongHundredweight, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.LongTon, q => q.ToUnit(MassUnit.LongTon));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.LongTon, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Megapound, q => q.ToUnit(MassUnit.Megapound));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Megapound, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Megatonne, q => q.ToUnit(MassUnit.Megatonne));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Megatonne, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Microgram, q => q.ToUnit(MassUnit.Microgram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Microgram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Milligram, q => q.ToUnit(MassUnit.Milligram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Milligram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Nanogram, q => q.ToUnit(MassUnit.Nanogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Nanogram, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Ounce, q => q.ToUnit(MassUnit.Ounce));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Ounce, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Pound, q => q.ToUnit(MassUnit.Pound));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Pound, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.ShortHundredweight, q => q.ToUnit(MassUnit.ShortHundredweight));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.ShortHundredweight, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.ShortTon, q => q.ToUnit(MassUnit.ShortTon));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.ShortTon, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Slug, q => q.ToUnit(MassUnit.Slug));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Slug, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.SolarMass, q => q.ToUnit(MassUnit.SolarMass));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.SolarMass, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Stone, q => q.ToUnit(MassUnit.Stone));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Stone, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Mass>(Mass.BaseUnit, MassUnit.Tonne, q => q.ToUnit(MassUnit.Tonne));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Tonne, Mass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.CentigramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.CentigramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.CentigramPerLiter, q => q.ToUnit(MassConcentrationUnit.CentigramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.CentigramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.CentigramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.CentigramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.CentigramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.DecigramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.DecigramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.DecigramPerLiter, q => q.ToUnit(MassConcentrationUnit.DecigramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.DecigramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.DecigramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.DecigramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.DecigramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.GramPerCubicCentimeter, q => q.ToUnit(MassConcentrationUnit.GramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerCubicCentimeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.GramPerCubicMeter, q => q.ToUnit(MassConcentrationUnit.GramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerCubicMeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.GramPerCubicMillimeter, q => q.ToUnit(MassConcentrationUnit.GramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerCubicMillimeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.GramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.GramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.GramPerLiter, q => q.ToUnit(MassConcentrationUnit.GramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.GramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.GramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.GramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.GramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.KilogramPerCubicCentimeter, q => q.ToUnit(MassConcentrationUnit.KilogramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicCentimeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentration.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.KilogramPerCubicMillimeter, q => q.ToUnit(MassConcentrationUnit.KilogramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMillimeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.KilogramPerLiter, q => q.ToUnit(MassConcentrationUnit.KilogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.KilopoundPerCubicFoot, q => q.ToUnit(MassConcentrationUnit.KilopoundPerCubicFoot));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilopoundPerCubicFoot, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.KilopoundPerCubicInch, q => q.ToUnit(MassConcentrationUnit.KilopoundPerCubicInch));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilopoundPerCubicInch, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MicrogramPerCubicMeter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerCubicMeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MicrogramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MicrogramPerLiter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MicrogramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MicrogramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MilligramPerCubicMeter, q => q.ToUnit(MassConcentrationUnit.MilligramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerCubicMeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MilligramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.MilligramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MilligramPerLiter, q => q.ToUnit(MassConcentrationUnit.MilligramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MilligramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.MilligramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.MilligramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.MilligramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.NanogramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.NanogramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.NanogramPerLiter, q => q.ToUnit(MassConcentrationUnit.NanogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.NanogramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.NanogramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.NanogramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.NanogramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PicogramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.PicogramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PicogramPerLiter, q => q.ToUnit(MassConcentrationUnit.PicogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerLiter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PicogramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.PicogramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PicogramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.PicogramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PoundPerCubicFoot, q => q.ToUnit(MassConcentrationUnit.PoundPerCubicFoot));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerCubicFoot, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PoundPerCubicInch, q => q.ToUnit(MassConcentrationUnit.PoundPerCubicInch));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerCubicInch, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PoundPerImperialGallon, q => q.ToUnit(MassConcentrationUnit.PoundPerImperialGallon));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerImperialGallon, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PoundPerUSGallon, q => q.ToUnit(MassConcentrationUnit.PoundPerUSGallon));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerUSGallon, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.SlugPerCubicFoot, q => q.ToUnit(MassConcentrationUnit.SlugPerCubicFoot));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.SlugPerCubicFoot, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.TonnePerCubicCentimeter, q => q.ToUnit(MassConcentrationUnit.TonnePerCubicCentimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.TonnePerCubicCentimeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.TonnePerCubicMeter, q => q.ToUnit(MassConcentrationUnit.TonnePerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.TonnePerCubicMeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.TonnePerCubicMillimeter, q => q.ToUnit(MassConcentrationUnit.TonnePerCubicMillimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.TonnePerCubicMillimeter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.CentigramPerDay, q => q.ToUnit(MassFlowUnit.CentigramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.CentigramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.CentigramPerSecond, q => q.ToUnit(MassFlowUnit.CentigramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.CentigramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.DecagramPerDay, q => q.ToUnit(MassFlowUnit.DecagramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecagramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.DecagramPerSecond, q => q.ToUnit(MassFlowUnit.DecagramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecagramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.DecigramPerDay, q => q.ToUnit(MassFlowUnit.DecigramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecigramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.DecigramPerSecond, q => q.ToUnit(MassFlowUnit.DecigramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecigramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.GramPerDay, q => q.ToUnit(MassFlowUnit.GramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.GramPerHour, q => q.ToUnit(MassFlowUnit.GramPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlow.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.HectogramPerDay, q => q.ToUnit(MassFlowUnit.HectogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.HectogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.HectogramPerSecond, q => q.ToUnit(MassFlowUnit.HectogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.HectogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.KilogramPerDay, q => q.ToUnit(MassFlowUnit.KilogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.KilogramPerHour, q => q.ToUnit(MassFlowUnit.KilogramPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.KilogramPerMinute, q => q.ToUnit(MassFlowUnit.KilogramPerMinute));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.KilogramPerSecond, q => q.ToUnit(MassFlowUnit.KilogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MegagramPerDay, q => q.ToUnit(MassFlowUnit.MegagramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegagramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerDay, q => q.ToUnit(MassFlowUnit.MegapoundPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerHour, q => q.ToUnit(MassFlowUnit.MegapoundPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerMinute, q => q.ToUnit(MassFlowUnit.MegapoundPerMinute));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerSecond, q => q.ToUnit(MassFlowUnit.MegapoundPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerDay, q => q.ToUnit(MassFlowUnit.MicrogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MicrogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerSecond, q => q.ToUnit(MassFlowUnit.MicrogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MicrogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MilligramPerDay, q => q.ToUnit(MassFlowUnit.MilligramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MilligramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.MilligramPerSecond, q => q.ToUnit(MassFlowUnit.MilligramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MilligramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.NanogramPerDay, q => q.ToUnit(MassFlowUnit.NanogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.NanogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.NanogramPerSecond, q => q.ToUnit(MassFlowUnit.NanogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.NanogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.PoundPerDay, q => q.ToUnit(MassFlowUnit.PoundPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.PoundPerHour, q => q.ToUnit(MassFlowUnit.PoundPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.PoundPerMinute, q => q.ToUnit(MassFlowUnit.PoundPerMinute));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.PoundPerSecond, q => q.ToUnit(MassFlowUnit.PoundPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.ShortTonPerHour, q => q.ToUnit(MassFlowUnit.ShortTonPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.ShortTonPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.TonnePerDay, q => q.ToUnit(MassFlowUnit.TonnePerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.TonnePerDay, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlow>(MassFlow.BaseUnit, MassFlowUnit.TonnePerHour, q => q.ToUnit(MassFlowUnit.TonnePerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.TonnePerHour, MassFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.GramPerHourPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.GramPerHourPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerHourPerSquareCentimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.GramPerHourPerSquareMeter, q => q.ToUnit(MassFluxUnit.GramPerHourPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerHourPerSquareMeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.GramPerHourPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.GramPerHourPerSquareMillimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerHourPerSquareMillimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.GramPerSecondPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.GramPerSecondPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerSecondPerSquareCentimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMeter, q => q.ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerSecondPerSquareMeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.GramPerSecondPerSquareMillimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerSecondPerSquareMillimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.KilogramPerHourPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.KilogramPerHourPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerHourPerSquareCentimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.KilogramPerHourPerSquareMeter, q => q.ToUnit(MassFluxUnit.KilogramPerHourPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerHourPerSquareMeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.KilogramPerHourPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.KilogramPerHourPerSquareMillimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerHourPerSquareMillimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.KilogramPerSecondPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareCentimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFlux.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MassFlux>(MassFlux.BaseUnit, MassFluxUnit.KilogramPerSecondPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMillimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMillimeter, MassFlux.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.CentigramPerGram, q => q.ToUnit(MassFractionUnit.CentigramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.CentigramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.CentigramPerKilogram, q => q.ToUnit(MassFractionUnit.CentigramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.CentigramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.DecagramPerGram, q => q.ToUnit(MassFractionUnit.DecagramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecagramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.DecagramPerKilogram, q => q.ToUnit(MassFractionUnit.DecagramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecagramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.DecigramPerGram, q => q.ToUnit(MassFractionUnit.DecigramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecigramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.DecigramPerKilogram, q => q.ToUnit(MassFractionUnit.DecigramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecigramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFraction.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.GramPerGram, q => q.ToUnit(MassFractionUnit.GramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.GramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.GramPerKilogram, q => q.ToUnit(MassFractionUnit.GramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.GramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.HectogramPerGram, q => q.ToUnit(MassFractionUnit.HectogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.HectogramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.HectogramPerKilogram, q => q.ToUnit(MassFractionUnit.HectogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.HectogramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.KilogramPerGram, q => q.ToUnit(MassFractionUnit.KilogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.KilogramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.KilogramPerKilogram, q => q.ToUnit(MassFractionUnit.KilogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.KilogramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.MicrogramPerGram, q => q.ToUnit(MassFractionUnit.MicrogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MicrogramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.MicrogramPerKilogram, q => q.ToUnit(MassFractionUnit.MicrogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MicrogramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.MilligramPerGram, q => q.ToUnit(MassFractionUnit.MilligramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MilligramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.MilligramPerKilogram, q => q.ToUnit(MassFractionUnit.MilligramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MilligramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.NanogramPerGram, q => q.ToUnit(MassFractionUnit.NanogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.NanogramPerGram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.NanogramPerKilogram, q => q.ToUnit(MassFractionUnit.NanogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.NanogramPerKilogram, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.PartPerBillion, q => q.ToUnit(MassFractionUnit.PartPerBillion));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerBillion, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.PartPerMillion, q => q.ToUnit(MassFractionUnit.PartPerMillion));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerMillion, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.PartPerThousand, q => q.ToUnit(MassFractionUnit.PartPerThousand));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerThousand, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.PartPerTrillion, q => q.ToUnit(MassFractionUnit.PartPerTrillion));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerTrillion, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassFraction>(MassFraction.BaseUnit, MassFractionUnit.Percent, q => q.ToUnit(MassFractionUnit.Percent));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.Percent, MassFraction.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertia.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMilimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMilimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareFoot, q => q.ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareInch, q => q.ToUnit(MassMomentOfInertiaUnit.PoundSquareInch));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareFoot, q => q.ToUnit(MassMomentOfInertiaUnit.SlugSquareFoot));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareInch, q => q.ToUnit(MassMomentOfInertiaUnit.SlugSquareInch));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareMilimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareMilimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergy.BaseUnit, MolarEnergy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergy.BaseUnit, MolarEnergyUnit.KilojoulePerMole, q => q.ToUnit(MolarEnergyUnit.KilojoulePerMole));
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergyUnit.KilojoulePerMole, MolarEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergy.BaseUnit, MolarEnergyUnit.MegajoulePerMole, q => q.ToUnit(MolarEnergyUnit.MegajoulePerMole));
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergyUnit.MegajoulePerMole, MolarEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropy.BaseUnit, MolarEntropy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropy.BaseUnit, MolarEntropyUnit.KilojoulePerMoleKelvin, q => q.ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin));
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropy.BaseUnit, MolarEntropyUnit.MegajoulePerMoleKelvin, q => q.ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin));
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, MolarityUnit.CentimolesPerLiter, q => q.ToUnit(MolarityUnit.CentimolesPerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.CentimolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, MolarityUnit.DecimolesPerLiter, q => q.ToUnit(MolarityUnit.DecimolesPerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.DecimolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, MolarityUnit.MicromolesPerLiter, q => q.ToUnit(MolarityUnit.MicromolesPerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MicromolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, MolarityUnit.MillimolesPerLiter, q => q.ToUnit(MolarityUnit.MillimolesPerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MillimolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, Molarity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, MolarityUnit.MolesPerLiter, q => q.ToUnit(MolarityUnit.MolesPerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, MolarityUnit.NanomolesPerLiter, q => q.ToUnit(MolarityUnit.NanomolesPerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.NanomolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Molarity>(Molarity.BaseUnit, MolarityUnit.PicomolesPerLiter, q => q.ToUnit(MolarityUnit.PicomolesPerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.PicomolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.CentigramPerMole, q => q.ToUnit(MolarMassUnit.CentigramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.CentigramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.DecagramPerMole, q => q.ToUnit(MolarMassUnit.DecagramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.DecagramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.DecigramPerMole, q => q.ToUnit(MolarMassUnit.DecigramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.DecigramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.GramPerMole, q => q.ToUnit(MolarMassUnit.GramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.GramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.HectogramPerMole, q => q.ToUnit(MolarMassUnit.HectogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.HectogramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMass.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.KilopoundPerMole, q => q.ToUnit(MolarMassUnit.KilopoundPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilopoundPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.MegapoundPerMole, q => q.ToUnit(MolarMassUnit.MegapoundPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.MegapoundPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.MicrogramPerMole, q => q.ToUnit(MolarMassUnit.MicrogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.MicrogramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.MilligramPerMole, q => q.ToUnit(MolarMassUnit.MilligramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.MilligramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.NanogramPerMole, q => q.ToUnit(MolarMassUnit.NanogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.NanogramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<MolarMass>(MolarMass.BaseUnit, MolarMassUnit.PoundPerMole, q => q.ToUnit(MolarMassUnit.PoundPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.PoundPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Permeability>(Permeability.BaseUnit, Permeability.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Permittivity>(Permittivity.BaseUnit, Permittivity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.BoilerHorsepower, q => q.ToUnit(PowerUnit.BoilerHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.BoilerHorsepower, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.BritishThermalUnitPerHour, q => q.ToUnit(PowerUnit.BritishThermalUnitPerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.BritishThermalUnitPerHour, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Decawatt, q => q.ToUnit(PowerUnit.Decawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Decawatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Deciwatt, q => q.ToUnit(PowerUnit.Deciwatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Deciwatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.ElectricalHorsepower, q => q.ToUnit(PowerUnit.ElectricalHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.ElectricalHorsepower, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Femtowatt, q => q.ToUnit(PowerUnit.Femtowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Femtowatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.GigajoulePerHour, q => q.ToUnit(PowerUnit.GigajoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.GigajoulePerHour, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Gigawatt, q => q.ToUnit(PowerUnit.Gigawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Gigawatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.HydraulicHorsepower, q => q.ToUnit(PowerUnit.HydraulicHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.HydraulicHorsepower, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.JoulePerHour, q => q.ToUnit(PowerUnit.JoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.JoulePerHour, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.KilobritishThermalUnitPerHour, q => q.ToUnit(PowerUnit.KilobritishThermalUnitPerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.KilobritishThermalUnitPerHour, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.KilojoulePerHour, q => q.ToUnit(PowerUnit.KilojoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.KilojoulePerHour, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Kilowatt, q => q.ToUnit(PowerUnit.Kilowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Kilowatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.MechanicalHorsepower, q => q.ToUnit(PowerUnit.MechanicalHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MechanicalHorsepower, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.MegajoulePerHour, q => q.ToUnit(PowerUnit.MegajoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MegajoulePerHour, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Megawatt, q => q.ToUnit(PowerUnit.Megawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Megawatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.MetricHorsepower, q => q.ToUnit(PowerUnit.MetricHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MetricHorsepower, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Microwatt, q => q.ToUnit(PowerUnit.Microwatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Microwatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.MillijoulePerHour, q => q.ToUnit(PowerUnit.MillijoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MillijoulePerHour, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Milliwatt, q => q.ToUnit(PowerUnit.Milliwatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Milliwatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Nanowatt, q => q.ToUnit(PowerUnit.Nanowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Nanowatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Petawatt, q => q.ToUnit(PowerUnit.Petawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Petawatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Picowatt, q => q.ToUnit(PowerUnit.Picowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Picowatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, PowerUnit.Terawatt, q => q.ToUnit(PowerUnit.Terawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Terawatt, Power.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Power>(Power.BaseUnit, Power.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerLiter, q => q.ToUnit(PowerDensityUnit.DecawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicInch, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerLiter, q => q.ToUnit(PowerDensityUnit.DeciwattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerLiter, q => q.ToUnit(PowerDensityUnit.GigawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerLiter, q => q.ToUnit(PowerDensityUnit.KilowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerLiter, q => q.ToUnit(PowerDensityUnit.MegawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerLiter, q => q.ToUnit(PowerDensityUnit.MicrowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerLiter, q => q.ToUnit(PowerDensityUnit.MilliwattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerLiter, q => q.ToUnit(PowerDensityUnit.NanowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerLiter, q => q.ToUnit(PowerDensityUnit.PicowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerLiter, q => q.ToUnit(PowerDensityUnit.TerawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.WattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicInch, q => q.ToUnit(PowerDensityUnit.WattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensity.BaseUnit, PowerDensityUnit.WattPerLiter, q => q.ToUnit(PowerDensityUnit.WattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerRatio>(PowerRatio.BaseUnit, PowerRatioUnit.DecibelMilliwatt, q => q.ToUnit(PowerRatioUnit.DecibelMilliwatt));
-            unitConverter.SetConversionFunction<PowerRatio>(PowerRatioUnit.DecibelMilliwatt, PowerRatio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PowerRatio>(PowerRatio.BaseUnit, PowerRatio.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Atmosphere, q => q.ToUnit(PressureUnit.Atmosphere));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Atmosphere, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Bar, q => q.ToUnit(PressureUnit.Bar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Bar, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Centibar, q => q.ToUnit(PressureUnit.Centibar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Centibar, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Decapascal, q => q.ToUnit(PressureUnit.Decapascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Decapascal, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Decibar, q => q.ToUnit(PressureUnit.Decibar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Decibar, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.DynePerSquareCentimeter, q => q.ToUnit(PressureUnit.DynePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.DynePerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.FootOfHead, q => q.ToUnit(PressureUnit.FootOfHead));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.FootOfHead, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Gigapascal, q => q.ToUnit(PressureUnit.Gigapascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Gigapascal, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Hectopascal, q => q.ToUnit(PressureUnit.Hectopascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Hectopascal, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.InchOfMercury, q => q.ToUnit(PressureUnit.InchOfMercury));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.InchOfMercury, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.InchOfWaterColumn, q => q.ToUnit(PressureUnit.InchOfWaterColumn));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.InchOfWaterColumn, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Kilobar, q => q.ToUnit(PressureUnit.Kilobar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Kilobar, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareCentimeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilogramForcePerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilogramForcePerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMillimeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilogramForcePerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareCentimeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilonewtonPerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilonewtonPerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMillimeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilonewtonPerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Kilopascal, q => q.ToUnit(PressureUnit.Kilopascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Kilopascal, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareFoot, q => q.ToUnit(PressureUnit.KilopoundForcePerSquareFoot));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilopoundForcePerSquareFoot, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareInch, q => q.ToUnit(PressureUnit.KilopoundForcePerSquareInch));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilopoundForcePerSquareInch, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Megabar, q => q.ToUnit(PressureUnit.Megabar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Megabar, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.MeganewtonPerSquareMeter, q => q.ToUnit(PressureUnit.MeganewtonPerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MeganewtonPerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Megapascal, q => q.ToUnit(PressureUnit.Megapascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Megapascal, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.MeterOfHead, q => q.ToUnit(PressureUnit.MeterOfHead));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MeterOfHead, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Microbar, q => q.ToUnit(PressureUnit.Microbar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Microbar, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Micropascal, q => q.ToUnit(PressureUnit.Micropascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Micropascal, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Millibar, q => q.ToUnit(PressureUnit.Millibar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Millibar, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.MillimeterOfMercury, q => q.ToUnit(PressureUnit.MillimeterOfMercury));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MillimeterOfMercury, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Millipascal, q => q.ToUnit(PressureUnit.Millipascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Millipascal, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.NewtonPerSquareCentimeter, q => q.ToUnit(PressureUnit.NewtonPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.NewtonPerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMeter, q => q.ToUnit(PressureUnit.NewtonPerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.NewtonPerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMillimeter, q => q.ToUnit(PressureUnit.NewtonPerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.NewtonPerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, Pressure.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareFoot, q => q.ToUnit(PressureUnit.PoundForcePerSquareFoot));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.PoundForcePerSquareFoot, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareInch, q => q.ToUnit(PressureUnit.PoundForcePerSquareInch));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.PoundForcePerSquareInch, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.PoundPerInchSecondSquared, q => q.ToUnit(PressureUnit.PoundPerInchSecondSquared));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.PoundPerInchSecondSquared, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.TechnicalAtmosphere, q => q.ToUnit(PressureUnit.TechnicalAtmosphere));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TechnicalAtmosphere, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareCentimeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TonneForcePerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TonneForcePerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMillimeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TonneForcePerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Pressure>(Pressure.BaseUnit, PressureUnit.Torr, q => q.ToUnit(PressureUnit.Torr));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Torr, Pressure.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRate.BaseUnit, PressureChangeRateUnit.AtmospherePerSecond, q => q.ToUnit(PressureChangeRateUnit.AtmospherePerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.KilopascalPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.KilopascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.PascalPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRate.BaseUnit, PressureChangeRate.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Ratio>(Ratio.BaseUnit, Ratio.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Ratio>(Ratio.BaseUnit, RatioUnit.PartPerBillion, q => q.ToUnit(RatioUnit.PartPerBillion));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerBillion, Ratio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Ratio>(Ratio.BaseUnit, RatioUnit.PartPerMillion, q => q.ToUnit(RatioUnit.PartPerMillion));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerMillion, Ratio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Ratio>(Ratio.BaseUnit, RatioUnit.PartPerThousand, q => q.ToUnit(RatioUnit.PartPerThousand));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerThousand, Ratio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Ratio>(Ratio.BaseUnit, RatioUnit.PartPerTrillion, q => q.ToUnit(RatioUnit.PartPerTrillion));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerTrillion, Ratio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Ratio>(Ratio.BaseUnit, RatioUnit.Percent, q => q.ToUnit(RatioUnit.Percent));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.Percent, Ratio.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RatioChangeRate>(RatioChangeRate.BaseUnit, RatioChangeRate.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<RatioChangeRate>(RatioChangeRate.BaseUnit, RatioChangeRateUnit.PercentPerSecond, q => q.ToUnit(RatioChangeRateUnit.PercentPerSecond));
-            unitConverter.SetConversionFunction<RatioChangeRate>(RatioChangeRateUnit.PercentPerSecond, RatioChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ReactiveEnergy>(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.KilovoltampereReactiveHour, q => q.ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour));
-            unitConverter.SetConversionFunction<ReactiveEnergy>(ReactiveEnergyUnit.KilovoltampereReactiveHour, ReactiveEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ReactiveEnergy>(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.MegavoltampereReactiveHour, q => q.ToUnit(ReactiveEnergyUnit.MegavoltampereReactiveHour));
-            unitConverter.SetConversionFunction<ReactiveEnergy>(ReactiveEnergyUnit.MegavoltampereReactiveHour, ReactiveEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ReactiveEnergy>(ReactiveEnergy.BaseUnit, ReactiveEnergy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ReactivePower>(ReactivePower.BaseUnit, ReactivePowerUnit.GigavoltampereReactive, q => q.ToUnit(ReactivePowerUnit.GigavoltampereReactive));
-            unitConverter.SetConversionFunction<ReactivePower>(ReactivePowerUnit.GigavoltampereReactive, ReactivePower.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ReactivePower>(ReactivePower.BaseUnit, ReactivePowerUnit.KilovoltampereReactive, q => q.ToUnit(ReactivePowerUnit.KilovoltampereReactive));
-            unitConverter.SetConversionFunction<ReactivePower>(ReactivePowerUnit.KilovoltampereReactive, ReactivePower.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ReactivePower>(ReactivePower.BaseUnit, ReactivePowerUnit.MegavoltampereReactive, q => q.ToUnit(ReactivePowerUnit.MegavoltampereReactive));
-            unitConverter.SetConversionFunction<ReactivePower>(ReactivePowerUnit.MegavoltampereReactive, ReactivePower.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ReactivePower>(ReactivePower.BaseUnit, ReactivePower.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<RelativeHumidity>(RelativeHumidity.BaseUnit, RelativeHumidity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.DegreePerSecondSquared, q => q.ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared));
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAcceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAcceleration.BaseUnit, RotationalAcceleration.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, q => q.ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond));
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerSecondSquared, q => q.ToUnit(RotationalAccelerationUnit.RevolutionPerSecondSquared));
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RevolutionPerSecondSquared, RotationalAcceleration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.CentiradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.CentiradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DeciradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.DeciradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerMinute, q => q.ToUnit(RotationalSpeedUnit.DegreePerMinute));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.DegreePerMinute, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.DegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.DegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicrodegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.MicrodegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicroradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.MicroradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MillidegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.MillidegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MilliradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.MilliradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanodegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.NanodegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanoradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.NanoradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeed.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerMinute, q => q.ToUnit(RotationalSpeedUnit.RevolutionPerMinute));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerSecond, q => q.ToUnit(RotationalSpeedUnit.RevolutionPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.CentinewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.CentinewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.CentinewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.DecanewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecanewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecanewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.DecinewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecinewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecinewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilopoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerDegrees));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MicronewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MicronewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MicronewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MillinewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MillinewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MillinewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.NanonewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NanonewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NanonewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.NewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffness.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.NewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMillimeterPerDegree, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.NewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.NewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMillimeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.PoundForceFeetPerRadian, q => q.ToUnit(RotationalStiffnessUnit.PoundForceFeetPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.PoundForceFeetPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.PoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.PoundForceFootPerDegrees));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.PoundForceFootPerDegrees, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, q => q.ToUnit(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLength.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, q => q.ToUnit(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SolidAngle>(SolidAngle.BaseUnit, SolidAngle.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.BtuPerPound, q => q.ToUnit(SpecificEnergyUnit.BtuPerPound));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.BtuPerPound, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.CaloriePerGram, q => q.ToUnit(SpecificEnergyUnit.CaloriePerGram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.CaloriePerGram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.GigawattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.GigawattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattDayPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.GigawattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.GigawattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattDayPerShortTon, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.GigawattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.GigawattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattDayPerTonne, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.GigawattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.GigawattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattHourPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilocaloriePerGram, q => q.ToUnit(SpecificEnergyUnit.KilocaloriePerGram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilojoulePerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilojoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilowattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattDayPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.KilowattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattDayPerShortTon, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.KilowattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattDayPerTonne, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegajoulePerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegajoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegawattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattDayPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.MegawattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattDayPerShortTon, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.MegawattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattDayPerTonne, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.TerawattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.TerawattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.TerawattDayPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.TerawattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.TerawattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.TerawattDayPerShortTon, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.TerawattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.TerawattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.TerawattDayPerTonne, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.WattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattDayPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.WattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattDayPerShortTon, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.WattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattDayPerTonne, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.WattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.BtuPerPoundFahrenheit, q => q.ToUnit(SpecificEntropyUnit.BtuPerPoundFahrenheit));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.BtuPerPoundFahrenheit, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.CaloriePerGramKelvin, q => q.ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropy.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilocaloriePerGramKelvin, q => q.ToUnit(SpecificEntropyUnit.KilocaloriePerGramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramKelvin, q => q.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramKelvin, q => q.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolume.BaseUnit, SpecificVolumeUnit.CubicFootPerPound, q => q.ToUnit(SpecificVolumeUnit.CubicFootPerPound));
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolumeUnit.CubicFootPerPound, SpecificVolume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolume.BaseUnit, SpecificVolume.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolume.BaseUnit, SpecificVolumeUnit.MillicubicMeterPerKilogram, q => q.ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram));
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMillimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMillimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicFoot, q => q.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicFoot));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicInch, q => q.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicInch));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.MeganewtonPerCubicMeter, q => q.ToUnit(SpecificWeightUnit.MeganewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.NewtonPerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeight.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.NewtonPerCubicMillimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicFoot, q => q.ToUnit(SpecificWeightUnit.PoundForcePerCubicFoot));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicInch, q => q.ToUnit(SpecificWeightUnit.PoundForcePerCubicInch));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicMillimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.CentimeterPerHour, q => q.ToUnit(SpeedUnit.CentimeterPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.CentimeterPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.CentimeterPerMinute, q => q.ToUnit(SpeedUnit.CentimeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.CentimeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.CentimeterPerSecond, q => q.ToUnit(SpeedUnit.CentimeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.CentimeterPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.DecimeterPerMinute, q => q.ToUnit(SpeedUnit.DecimeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.DecimeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.DecimeterPerSecond, q => q.ToUnit(SpeedUnit.DecimeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.DecimeterPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.FootPerHour, q => q.ToUnit(SpeedUnit.FootPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.FootPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.FootPerMinute, q => q.ToUnit(SpeedUnit.FootPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.FootPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.FootPerSecond, q => q.ToUnit(SpeedUnit.FootPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.FootPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.InchPerHour, q => q.ToUnit(SpeedUnit.InchPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.InchPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.InchPerMinute, q => q.ToUnit(SpeedUnit.InchPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.InchPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.InchPerSecond, q => q.ToUnit(SpeedUnit.InchPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.InchPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.KilometerPerHour, q => q.ToUnit(SpeedUnit.KilometerPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.KilometerPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.KilometerPerMinute, q => q.ToUnit(SpeedUnit.KilometerPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.KilometerPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.KilometerPerSecond, q => q.ToUnit(SpeedUnit.KilometerPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.KilometerPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.Knot, q => q.ToUnit(SpeedUnit.Knot));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.Knot, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MeterPerHour, q => q.ToUnit(SpeedUnit.MeterPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MeterPerMinute, q => q.ToUnit(SpeedUnit.MeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, Speed.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MicrometerPerMinute, q => q.ToUnit(SpeedUnit.MicrometerPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MicrometerPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MicrometerPerSecond, q => q.ToUnit(SpeedUnit.MicrometerPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MicrometerPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MilePerHour, q => q.ToUnit(SpeedUnit.MilePerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MilePerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MillimeterPerHour, q => q.ToUnit(SpeedUnit.MillimeterPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MillimeterPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MillimeterPerMinute, q => q.ToUnit(SpeedUnit.MillimeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MillimeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.MillimeterPerSecond, q => q.ToUnit(SpeedUnit.MillimeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MillimeterPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.NanometerPerMinute, q => q.ToUnit(SpeedUnit.NanometerPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.NanometerPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.NanometerPerSecond, q => q.ToUnit(SpeedUnit.NanometerPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.NanometerPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerHour, q => q.ToUnit(SpeedUnit.UsSurveyFootPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.UsSurveyFootPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerMinute, q => q.ToUnit(SpeedUnit.UsSurveyFootPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.UsSurveyFootPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerSecond, q => q.ToUnit(SpeedUnit.UsSurveyFootPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.UsSurveyFootPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.YardPerHour, q => q.ToUnit(SpeedUnit.YardPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.YardPerHour, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.YardPerMinute, q => q.ToUnit(SpeedUnit.YardPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.YardPerMinute, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Speed>(Speed.BaseUnit, SpeedUnit.YardPerSecond, q => q.ToUnit(SpeedUnit.YardPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.YardPerSecond, Speed.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.DegreeCelsius, q => q.ToUnit(TemperatureUnit.DegreeCelsius));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeCelsius, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.DegreeDelisle, q => q.ToUnit(TemperatureUnit.DegreeDelisle));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeDelisle, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.DegreeFahrenheit, q => q.ToUnit(TemperatureUnit.DegreeFahrenheit));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeFahrenheit, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.DegreeNewton, q => q.ToUnit(TemperatureUnit.DegreeNewton));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeNewton, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.DegreeRankine, q => q.ToUnit(TemperatureUnit.DegreeRankine));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeRankine, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.DegreeReaumur, q => q.ToUnit(TemperatureUnit.DegreeReaumur));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeReaumur, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.DegreeRoemer, q => q.ToUnit(TemperatureUnit.DegreeRoemer));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeRoemer, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, Temperature.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.MillidegreeCelsius, q => q.ToUnit(TemperatureUnit.MillidegreeCelsius));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.MillidegreeCelsius, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Temperature>(Temperature.BaseUnit, TemperatureUnit.SolarTemperature, q => q.ToUnit(TemperatureUnit.SolarTemperature));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.SolarTemperature, Temperature.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DegreeCelsiusPerMinute, q => q.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerMinute));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRate.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeCelsius, q => q.ToUnit(TemperatureDeltaUnit.DegreeCelsius));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeCelsius, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeDelisle, q => q.ToUnit(TemperatureDeltaUnit.DegreeDelisle));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeDelisle, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeFahrenheit, q => q.ToUnit(TemperatureDeltaUnit.DegreeFahrenheit));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeNewton, q => q.ToUnit(TemperatureDeltaUnit.DegreeNewton));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeNewton, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRankine, q => q.ToUnit(TemperatureDeltaUnit.DegreeRankine));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeRankine, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeReaumur, q => q.ToUnit(TemperatureDeltaUnit.DegreeReaumur));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeReaumur, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRoemer, q => q.ToUnit(TemperatureDeltaUnit.DegreeRoemer));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeRoemer, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDelta.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.MillidegreeCelsius, q => q.ToUnit(TemperatureDeltaUnit.MillidegreeCelsius));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.MillidegreeCelsius, TemperatureDelta.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ThermalConductivity>(ThermalConductivity.BaseUnit, ThermalConductivityUnit.BtuPerHourFootFahrenheit, q => q.ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit));
-            unitConverter.SetConversionFunction<ThermalConductivity>(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivity.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ThermalConductivity>(ThermalConductivity.BaseUnit, ThermalConductivity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistance.BaseUnit, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, q => q.ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu));
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, q => q.ToUnit(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie));
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, q => q.ToUnit(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt));
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, ThermalResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, q => q.ToUnit(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt));
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalResistance.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistance.BaseUnit, ThermalResistance.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilogramForceCentimeter, q => q.ToUnit(TorqueUnit.KilogramForceCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilogramForceCentimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilogramForceMeter, q => q.ToUnit(TorqueUnit.KilogramForceMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilogramForceMeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilogramForceMillimeter, q => q.ToUnit(TorqueUnit.KilogramForceMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilogramForceMillimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilonewtonCentimeter, q => q.ToUnit(TorqueUnit.KilonewtonCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilonewtonCentimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilonewtonMeter, q => q.ToUnit(TorqueUnit.KilonewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilonewtonMeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilonewtonMillimeter, q => q.ToUnit(TorqueUnit.KilonewtonMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilonewtonMillimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilopoundForceFoot, q => q.ToUnit(TorqueUnit.KilopoundForceFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilopoundForceFoot, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.KilopoundForceInch, q => q.ToUnit(TorqueUnit.KilopoundForceInch));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilopoundForceInch, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.MeganewtonCentimeter, q => q.ToUnit(TorqueUnit.MeganewtonCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MeganewtonCentimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.MeganewtonMeter, q => q.ToUnit(TorqueUnit.MeganewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MeganewtonMeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.MeganewtonMillimeter, q => q.ToUnit(TorqueUnit.MeganewtonMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MeganewtonMillimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.MegapoundForceFoot, q => q.ToUnit(TorqueUnit.MegapoundForceFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MegapoundForceFoot, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.MegapoundForceInch, q => q.ToUnit(TorqueUnit.MegapoundForceInch));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MegapoundForceInch, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.NewtonCentimeter, q => q.ToUnit(TorqueUnit.NewtonCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonCentimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, Torque.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.NewtonMillimeter, q => q.ToUnit(TorqueUnit.NewtonMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMillimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.PoundalFoot, q => q.ToUnit(TorqueUnit.PoundalFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.PoundalFoot, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.PoundForceFoot, q => q.ToUnit(TorqueUnit.PoundForceFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.PoundForceFoot, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.PoundForceInch, q => q.ToUnit(TorqueUnit.PoundForceInch));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.PoundForceInch, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.TonneForceCentimeter, q => q.ToUnit(TorqueUnit.TonneForceCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.TonneForceCentimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.TonneForceMeter, q => q.ToUnit(TorqueUnit.TonneForceMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.TonneForceMeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Torque>(Torque.BaseUnit, TorqueUnit.TonneForceMillimeter, q => q.ToUnit(TorqueUnit.TonneForceMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.TonneForceMillimeter, Torque.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilogramForceCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilogramForceCentimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilogramForceCentimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilogramForceMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilogramForceMeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilogramForceMeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilogramForceMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilogramForceMillimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilogramForceMillimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilonewtonCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilonewtonCentimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilonewtonCentimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilonewtonMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilonewtonMeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilonewtonMeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilonewtonMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilonewtonMillimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilonewtonMillimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilopoundForceFootPerFoot, q => q.ToUnit(TorquePerLengthUnit.KilopoundForceFootPerFoot));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilopoundForceFootPerFoot, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.KilopoundForceInchPerFoot, q => q.ToUnit(TorquePerLengthUnit.KilopoundForceInchPerFoot));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.KilopoundForceInchPerFoot, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.MeganewtonCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.MeganewtonCentimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.MeganewtonCentimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.MeganewtonMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.MeganewtonMeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.MeganewtonMeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.MeganewtonMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.MeganewtonMillimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.MeganewtonMillimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.MegapoundForceFootPerFoot, q => q.ToUnit(TorquePerLengthUnit.MegapoundForceFootPerFoot));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.MegapoundForceFootPerFoot, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.MegapoundForceInchPerFoot, q => q.ToUnit(TorquePerLengthUnit.MegapoundForceInchPerFoot));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.MegapoundForceInchPerFoot, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.NewtonCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.NewtonCentimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.NewtonCentimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLength.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.NewtonMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.NewtonMillimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.NewtonMillimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.PoundForceFootPerFoot, q => q.ToUnit(TorquePerLengthUnit.PoundForceFootPerFoot));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.PoundForceFootPerFoot, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.PoundForceInchPerFoot, q => q.ToUnit(TorquePerLengthUnit.PoundForceInchPerFoot));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.PoundForceInchPerFoot, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.TonneForceCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.TonneForceCentimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.TonneForceCentimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.TonneForceMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.TonneForceMeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.TonneForceMeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLength.BaseUnit, TorquePerLengthUnit.TonneForceMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.TonneForceMillimeterPerMeter));
-            unitConverter.SetConversionFunction<TorquePerLength>(TorquePerLengthUnit.TonneForceMillimeterPerMeter, TorquePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Turbidity>(Turbidity.BaseUnit, Turbidity.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<VitaminA>(VitaminA.BaseUnit, VitaminA.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.AcreFoot, q => q.ToUnit(VolumeUnit.AcreFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.AcreFoot, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.AuTablespoon, q => q.ToUnit(VolumeUnit.AuTablespoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.AuTablespoon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.BoardFoot, q => q.ToUnit(VolumeUnit.BoardFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.BoardFoot, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Centiliter, q => q.ToUnit(VolumeUnit.Centiliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Centiliter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicCentimeter, q => q.ToUnit(VolumeUnit.CubicCentimeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicCentimeter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicDecimeter, q => q.ToUnit(VolumeUnit.CubicDecimeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicDecimeter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicFoot, q => q.ToUnit(VolumeUnit.CubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicFoot, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicHectometer, q => q.ToUnit(VolumeUnit.CubicHectometer));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicHectometer, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicInch, q => q.ToUnit(VolumeUnit.CubicInch));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicInch, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicKilometer, q => q.ToUnit(VolumeUnit.CubicKilometer));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicKilometer, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, Volume.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicMicrometer, q => q.ToUnit(VolumeUnit.CubicMicrometer));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMicrometer, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicMile, q => q.ToUnit(VolumeUnit.CubicMile));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMile, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicMillimeter, q => q.ToUnit(VolumeUnit.CubicMillimeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMillimeter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.CubicYard, q => q.ToUnit(VolumeUnit.CubicYard));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicYard, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.DecausGallon, q => q.ToUnit(VolumeUnit.DecausGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.DecausGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Deciliter, q => q.ToUnit(VolumeUnit.Deciliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Deciliter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.DeciusGallon, q => q.ToUnit(VolumeUnit.DeciusGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.DeciusGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.HectocubicFoot, q => q.ToUnit(VolumeUnit.HectocubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.HectocubicFoot, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.HectocubicMeter, q => q.ToUnit(VolumeUnit.HectocubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.HectocubicMeter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Hectoliter, q => q.ToUnit(VolumeUnit.Hectoliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Hectoliter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.HectousGallon, q => q.ToUnit(VolumeUnit.HectousGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.HectousGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.ImperialBeerBarrel, q => q.ToUnit(VolumeUnit.ImperialBeerBarrel));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialBeerBarrel, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.ImperialGallon, q => q.ToUnit(VolumeUnit.ImperialGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.ImperialOunce, q => q.ToUnit(VolumeUnit.ImperialOunce));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialOunce, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.ImperialPint, q => q.ToUnit(VolumeUnit.ImperialPint));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialPint, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.KilocubicFoot, q => q.ToUnit(VolumeUnit.KilocubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KilocubicFoot, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.KilocubicMeter, q => q.ToUnit(VolumeUnit.KilocubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KilocubicMeter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.KiloimperialGallon, q => q.ToUnit(VolumeUnit.KiloimperialGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KiloimperialGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Kiloliter, q => q.ToUnit(VolumeUnit.Kiloliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Kiloliter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.KilousGallon, q => q.ToUnit(VolumeUnit.KilousGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KilousGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Liter, q => q.ToUnit(VolumeUnit.Liter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Liter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.MegacubicFoot, q => q.ToUnit(VolumeUnit.MegacubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MegacubicFoot, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.MegaimperialGallon, q => q.ToUnit(VolumeUnit.MegaimperialGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MegaimperialGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Megaliter, q => q.ToUnit(VolumeUnit.Megaliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Megaliter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.MegausGallon, q => q.ToUnit(VolumeUnit.MegausGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MegausGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.MetricCup, q => q.ToUnit(VolumeUnit.MetricCup));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MetricCup, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.MetricTeaspoon, q => q.ToUnit(VolumeUnit.MetricTeaspoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MetricTeaspoon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Microliter, q => q.ToUnit(VolumeUnit.Microliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Microliter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.Milliliter, q => q.ToUnit(VolumeUnit.Milliliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Milliliter, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.OilBarrel, q => q.ToUnit(VolumeUnit.OilBarrel));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.OilBarrel, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UkTablespoon, q => q.ToUnit(VolumeUnit.UkTablespoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UkTablespoon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsBeerBarrel, q => q.ToUnit(VolumeUnit.UsBeerBarrel));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsBeerBarrel, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsCustomaryCup, q => q.ToUnit(VolumeUnit.UsCustomaryCup));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsCustomaryCup, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsGallon, q => q.ToUnit(VolumeUnit.UsGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsGallon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsLegalCup, q => q.ToUnit(VolumeUnit.UsLegalCup));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsLegalCup, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsOunce, q => q.ToUnit(VolumeUnit.UsOunce));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsOunce, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsPint, q => q.ToUnit(VolumeUnit.UsPint));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsPint, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsQuart, q => q.ToUnit(VolumeUnit.UsQuart));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsQuart, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsTablespoon, q => q.ToUnit(VolumeUnit.UsTablespoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsTablespoon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<Volume>(Volume.BaseUnit, VolumeUnit.UsTeaspoon, q => q.ToUnit(VolumeUnit.UsTeaspoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsTeaspoon, Volume.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.CentilitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.CentilitersPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.CentilitersPerLiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.CentilitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.CentilitersPerMililiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.CentilitersPerMililiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.DecilitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.DecilitersPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecilitersPerLiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.DecilitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.DecilitersPerMililiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecilitersPerMililiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentration.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.LitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.LitersPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.LitersPerLiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.LitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.LitersPerMililiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.LitersPerMililiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.MicrolitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.MicrolitersPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MicrolitersPerLiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.MicrolitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.MicrolitersPerMililiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MicrolitersPerMililiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.MillilitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.MillilitersPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MillilitersPerLiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.MillilitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.MillilitersPerMililiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MillilitersPerMililiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.NanolitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.NanolitersPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.NanolitersPerLiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.NanolitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.NanolitersPerMililiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.NanolitersPerMililiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.PartPerBillion, q => q.ToUnit(VolumeConcentrationUnit.PartPerBillion));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerBillion, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.PartPerMillion, q => q.ToUnit(VolumeConcentrationUnit.PartPerMillion));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerMillion, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.PartPerThousand, q => q.ToUnit(VolumeConcentrationUnit.PartPerThousand));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerThousand, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.PartPerTrillion, q => q.ToUnit(VolumeConcentrationUnit.PartPerTrillion));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerTrillion, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.Percent, q => q.ToUnit(VolumeConcentrationUnit.Percent));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.Percent, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.PicolitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.PicolitersPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PicolitersPerLiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentration.BaseUnit, VolumeConcentrationUnit.PicolitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.PicolitersPerMililiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PicolitersPerMililiter, VolumeConcentration.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerDay, q => q.ToUnit(VolumeFlowUnit.AcreFootPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerHour, q => q.ToUnit(VolumeFlowUnit.AcreFootPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerMinute, q => q.ToUnit(VolumeFlowUnit.AcreFootPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerSecond, q => q.ToUnit(VolumeFlowUnit.AcreFootPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerDay, q => q.ToUnit(VolumeFlowUnit.CentiliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CentiliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerMinute, q => q.ToUnit(VolumeFlowUnit.CentiliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CentiliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerSecond, q => q.ToUnit(VolumeFlowUnit.CentiliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CentiliterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicCentimeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicCentimeterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicCentimeterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicDecimeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicDecimeterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerHour, q => q.ToUnit(VolumeFlowUnit.CubicFootPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicFootPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicFootPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicFootPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicFootPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicFootPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerDay, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerHour, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlow.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMillimeterPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicMillimeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerDay, q => q.ToUnit(VolumeFlowUnit.CubicYardPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerHour, q => q.ToUnit(VolumeFlowUnit.CubicYardPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicYardPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicYardPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerDay, q => q.ToUnit(VolumeFlowUnit.DeciliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DeciliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerMinute, q => q.ToUnit(VolumeFlowUnit.DeciliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DeciliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerSecond, q => q.ToUnit(VolumeFlowUnit.DeciliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DeciliterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerDay, q => q.ToUnit(VolumeFlowUnit.KiloliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KiloliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerMinute, q => q.ToUnit(VolumeFlowUnit.KiloliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KiloliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerSecond, q => q.ToUnit(VolumeFlowUnit.KiloliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KiloliterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.KilousGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.KilousGallonPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerDay, q => q.ToUnit(VolumeFlowUnit.LiterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerHour, q => q.ToUnit(VolumeFlowUnit.LiterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerMinute, q => q.ToUnit(VolumeFlowUnit.LiterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerSecond, q => q.ToUnit(VolumeFlowUnit.LiterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaliterPerDay, q => q.ToUnit(VolumeFlowUnit.MegaliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaukGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.MegaukGallonPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerDay, q => q.ToUnit(VolumeFlowUnit.MicroliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MicroliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerMinute, q => q.ToUnit(VolumeFlowUnit.MicroliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MicroliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerSecond, q => q.ToUnit(VolumeFlowUnit.MicroliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MicroliterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerDay, q => q.ToUnit(VolumeFlowUnit.MilliliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MilliliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerMinute, q => q.ToUnit(VolumeFlowUnit.MilliliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MilliliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerSecond, q => q.ToUnit(VolumeFlowUnit.MilliliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MilliliterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.MillionUsGallonsPerDay, q => q.ToUnit(VolumeFlowUnit.MillionUsGallonsPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MillionUsGallonsPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerDay, q => q.ToUnit(VolumeFlowUnit.NanoliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.NanoliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerMinute, q => q.ToUnit(VolumeFlowUnit.NanoliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.NanoliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerSecond, q => q.ToUnit(VolumeFlowUnit.NanoliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.NanoliterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerDay, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerHour, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerMinute, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerSecond, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerDay, q => q.ToUnit(VolumeFlowUnit.UkGallonPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerHour, q => q.ToUnit(VolumeFlowUnit.UkGallonPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.UkGallonPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.UkGallonPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerDay, q => q.ToUnit(VolumeFlowUnit.UsGallonPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerHour, q => q.ToUnit(VolumeFlowUnit.UsGallonPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.UsGallonPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.UsGallonPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLength.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.CubicYardPerFoot, q => q.ToUnit(VolumePerLengthUnit.CubicYardPerFoot));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicYardPerFoot, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.CubicYardPerUsSurveyFoot, q => q.ToUnit(VolumePerLengthUnit.CubicYardPerUsSurveyFoot));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicYardPerUsSurveyFoot, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.LiterPerKilometer, q => q.ToUnit(VolumePerLengthUnit.LiterPerKilometer));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.LiterPerKilometer, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.LiterPerMeter, q => q.ToUnit(VolumePerLengthUnit.LiterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.LiterPerMeter, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.LiterPerMillimeter, q => q.ToUnit(VolumePerLengthUnit.LiterPerMillimeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.LiterPerMillimeter, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.OilBarrelPerFoot, q => q.ToUnit(VolumePerLengthUnit.OilBarrelPerFoot));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.OilBarrelPerFoot, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertia.BaseUnit, WarpingMomentOfInertiaUnit.CentimeterToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.CentimeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.CentimeterToTheSixth, WarpingMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertia.BaseUnit, WarpingMomentOfInertiaUnit.DecimeterToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.DecimeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.DecimeterToTheSixth, WarpingMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertia.BaseUnit, WarpingMomentOfInertiaUnit.FootToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.FootToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.FootToTheSixth, WarpingMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertia.BaseUnit, WarpingMomentOfInertiaUnit.InchToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.InchToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.InchToTheSixth, WarpingMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertia.BaseUnit, WarpingMomentOfInertia.BaseUnit, q => q);
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertia.BaseUnit, WarpingMomentOfInertiaUnit.MillimeterToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.MillimeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MillimeterToTheSixth, WarpingMomentOfInertia.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.CentimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.CentimeterPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.CentimeterPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.DecimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.DecimeterPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.DecimeterPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.FootPerSecondSquared, q => q.ToUnit(AccelerationUnit.FootPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.FootPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.InchPerSecondSquared, q => q.ToUnit(AccelerationUnit.InchPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.InchPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.KilometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.KilometerPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.KilometerPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.KnotPerHour, q => q.ToUnit(AccelerationUnit.KnotPerHour));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.KnotPerHour, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.KnotPerMinute, q => q.ToUnit(AccelerationUnit.KnotPerMinute));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.KnotPerMinute, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.KnotPerSecond, q => q.ToUnit(AccelerationUnit.KnotPerSecond));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.KnotPerSecond, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, Acceleration<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.MicrometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.MicrometerPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.MicrometerPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.MillimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.MillimeterPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.MillimeterPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.MillistandardGravity, q => q.ToUnit(AccelerationUnit.MillistandardGravity));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.MillistandardGravity, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.NanometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.NanometerPerSecondSquared));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.NanometerPerSecondSquared, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Acceleration<T>>(Acceleration<T>.BaseUnit, AccelerationUnit.StandardGravity, q => q.ToUnit(AccelerationUnit.StandardGravity));
+            unitConverter.SetConversionFunction<Acceleration<T>>(AccelerationUnit.StandardGravity, Acceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.Centimole, q => q.ToUnit(AmountOfSubstanceUnit.Centimole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.Centimole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.CentipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.CentipoundMole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.Decimole, q => q.ToUnit(AmountOfSubstanceUnit.Decimole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.Decimole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.DecipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.DecipoundMole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.Kilomole, q => q.ToUnit(AmountOfSubstanceUnit.Kilomole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.Kilomole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.KilopoundMole, q => q.ToUnit(AmountOfSubstanceUnit.KilopoundMole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.Megamole, q => q.ToUnit(AmountOfSubstanceUnit.Megamole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.Megamole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.Micromole, q => q.ToUnit(AmountOfSubstanceUnit.Micromole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.Micromole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.MicropoundMole, q => q.ToUnit(AmountOfSubstanceUnit.MicropoundMole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.Millimole, q => q.ToUnit(AmountOfSubstanceUnit.Millimole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.Millimole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.MillipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.MillipoundMole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.Nanomole, q => q.ToUnit(AmountOfSubstanceUnit.Nanomole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.Nanomole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.NanopoundMole, q => q.ToUnit(AmountOfSubstanceUnit.NanopoundMole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstance<T>.BaseUnit, AmountOfSubstanceUnit.PoundMole, q => q.ToUnit(AmountOfSubstanceUnit.PoundMole));
+            unitConverter.SetConversionFunction<AmountOfSubstance<T>>(AmountOfSubstanceUnit.PoundMole, AmountOfSubstance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmplitudeRatio<T>>(AmplitudeRatio<T>.BaseUnit, AmplitudeRatioUnit.DecibelMicrovolt, q => q.ToUnit(AmplitudeRatioUnit.DecibelMicrovolt));
+            unitConverter.SetConversionFunction<AmplitudeRatio<T>>(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmplitudeRatio<T>>(AmplitudeRatio<T>.BaseUnit, AmplitudeRatioUnit.DecibelMillivolt, q => q.ToUnit(AmplitudeRatioUnit.DecibelMillivolt));
+            unitConverter.SetConversionFunction<AmplitudeRatio<T>>(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmplitudeRatio<T>>(AmplitudeRatio<T>.BaseUnit, AmplitudeRatioUnit.DecibelUnloaded, q => q.ToUnit(AmplitudeRatioUnit.DecibelUnloaded));
+            unitConverter.SetConversionFunction<AmplitudeRatio<T>>(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AmplitudeRatio<T>>(AmplitudeRatio<T>.BaseUnit, AmplitudeRatio<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Arcminute, q => q.ToUnit(AngleUnit.Arcminute));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Arcminute, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Arcsecond, q => q.ToUnit(AngleUnit.Arcsecond));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Arcsecond, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Centiradian, q => q.ToUnit(AngleUnit.Centiradian));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Centiradian, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Deciradian, q => q.ToUnit(AngleUnit.Deciradian));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Deciradian, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, Angle<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Gradian, q => q.ToUnit(AngleUnit.Gradian));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Gradian, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Microdegree, q => q.ToUnit(AngleUnit.Microdegree));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Microdegree, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Microradian, q => q.ToUnit(AngleUnit.Microradian));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Microradian, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Millidegree, q => q.ToUnit(AngleUnit.Millidegree));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Millidegree, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Milliradian, q => q.ToUnit(AngleUnit.Milliradian));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Milliradian, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Nanodegree, q => q.ToUnit(AngleUnit.Nanodegree));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Nanodegree, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Nanoradian, q => q.ToUnit(AngleUnit.Nanoradian));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Nanoradian, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Radian, q => q.ToUnit(AngleUnit.Radian));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Radian, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Angle<T>>(Angle<T>.BaseUnit, AngleUnit.Revolution, q => q.ToUnit(AngleUnit.Revolution));
+            unitConverter.SetConversionFunction<Angle<T>>(AngleUnit.Revolution, Angle<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ApparentEnergy<T>>(ApparentEnergy<T>.BaseUnit, ApparentEnergyUnit.KilovoltampereHour, q => q.ToUnit(ApparentEnergyUnit.KilovoltampereHour));
+            unitConverter.SetConversionFunction<ApparentEnergy<T>>(ApparentEnergyUnit.KilovoltampereHour, ApparentEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ApparentEnergy<T>>(ApparentEnergy<T>.BaseUnit, ApparentEnergyUnit.MegavoltampereHour, q => q.ToUnit(ApparentEnergyUnit.MegavoltampereHour));
+            unitConverter.SetConversionFunction<ApparentEnergy<T>>(ApparentEnergyUnit.MegavoltampereHour, ApparentEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ApparentEnergy<T>>(ApparentEnergy<T>.BaseUnit, ApparentEnergy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ApparentPower<T>>(ApparentPower<T>.BaseUnit, ApparentPowerUnit.Gigavoltampere, q => q.ToUnit(ApparentPowerUnit.Gigavoltampere));
+            unitConverter.SetConversionFunction<ApparentPower<T>>(ApparentPowerUnit.Gigavoltampere, ApparentPower<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ApparentPower<T>>(ApparentPower<T>.BaseUnit, ApparentPowerUnit.Kilovoltampere, q => q.ToUnit(ApparentPowerUnit.Kilovoltampere));
+            unitConverter.SetConversionFunction<ApparentPower<T>>(ApparentPowerUnit.Kilovoltampere, ApparentPower<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ApparentPower<T>>(ApparentPower<T>.BaseUnit, ApparentPowerUnit.Megavoltampere, q => q.ToUnit(ApparentPowerUnit.Megavoltampere));
+            unitConverter.SetConversionFunction<ApparentPower<T>>(ApparentPowerUnit.Megavoltampere, ApparentPower<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ApparentPower<T>>(ApparentPower<T>.BaseUnit, ApparentPower<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.Acre, q => q.ToUnit(AreaUnit.Acre));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.Acre, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.Hectare, q => q.ToUnit(AreaUnit.Hectare));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.Hectare, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareCentimeter, q => q.ToUnit(AreaUnit.SquareCentimeter));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareCentimeter, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareDecimeter, q => q.ToUnit(AreaUnit.SquareDecimeter));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareDecimeter, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareFoot, q => q.ToUnit(AreaUnit.SquareFoot));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareFoot, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareInch, q => q.ToUnit(AreaUnit.SquareInch));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareInch, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareKilometer, q => q.ToUnit(AreaUnit.SquareKilometer));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareKilometer, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, Area<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareMicrometer, q => q.ToUnit(AreaUnit.SquareMicrometer));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareMicrometer, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareMile, q => q.ToUnit(AreaUnit.SquareMile));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareMile, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareMillimeter, q => q.ToUnit(AreaUnit.SquareMillimeter));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareMillimeter, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareNauticalMile, q => q.ToUnit(AreaUnit.SquareNauticalMile));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareNauticalMile, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.SquareYard, q => q.ToUnit(AreaUnit.SquareYard));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.SquareYard, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Area<T>>(Area<T>.BaseUnit, AreaUnit.UsSurveySquareFoot, q => q.ToUnit(AreaUnit.UsSurveySquareFoot));
+            unitConverter.SetConversionFunction<Area<T>>(AreaUnit.UsSurveySquareFoot, Area<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AreaDensity<T>>(AreaDensity<T>.BaseUnit, AreaDensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertia<T>.BaseUnit, AreaMomentOfInertiaUnit.CentimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth));
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertia<T>.BaseUnit, AreaMomentOfInertiaUnit.DecimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth));
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertia<T>.BaseUnit, AreaMomentOfInertiaUnit.FootToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth));
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertia<T>.BaseUnit, AreaMomentOfInertiaUnit.InchToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth));
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertia<T>.BaseUnit, AreaMomentOfInertia<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertia<T>.BaseUnit, AreaMomentOfInertiaUnit.MillimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth));
+            unitConverter.SetConversionFunction<AreaMomentOfInertia<T>>(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRate<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.BytePerSecond, q => q.ToUnit(BitRateUnit.BytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.BytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.ExabitPerSecond, q => q.ToUnit(BitRateUnit.ExabitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.ExabitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.ExabytePerSecond, q => q.ToUnit(BitRateUnit.ExabytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.ExabytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.ExbibitPerSecond, q => q.ToUnit(BitRateUnit.ExbibitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.ExbibitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.ExbibytePerSecond, q => q.ToUnit(BitRateUnit.ExbibytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.ExbibytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.GibibitPerSecond, q => q.ToUnit(BitRateUnit.GibibitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.GibibitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.GibibytePerSecond, q => q.ToUnit(BitRateUnit.GibibytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.GibibytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.GigabitPerSecond, q => q.ToUnit(BitRateUnit.GigabitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.GigabitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.GigabytePerSecond, q => q.ToUnit(BitRateUnit.GigabytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.GigabytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.KibibitPerSecond, q => q.ToUnit(BitRateUnit.KibibitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.KibibitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.KibibytePerSecond, q => q.ToUnit(BitRateUnit.KibibytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.KibibytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.KilobitPerSecond, q => q.ToUnit(BitRateUnit.KilobitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.KilobitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.KilobytePerSecond, q => q.ToUnit(BitRateUnit.KilobytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.KilobytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.MebibitPerSecond, q => q.ToUnit(BitRateUnit.MebibitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.MebibitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.MebibytePerSecond, q => q.ToUnit(BitRateUnit.MebibytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.MebibytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.MegabitPerSecond, q => q.ToUnit(BitRateUnit.MegabitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.MegabitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.MegabytePerSecond, q => q.ToUnit(BitRateUnit.MegabytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.MegabytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.PebibitPerSecond, q => q.ToUnit(BitRateUnit.PebibitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.PebibitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.PebibytePerSecond, q => q.ToUnit(BitRateUnit.PebibytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.PebibytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.PetabitPerSecond, q => q.ToUnit(BitRateUnit.PetabitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.PetabitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.PetabytePerSecond, q => q.ToUnit(BitRateUnit.PetabytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.PetabytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.TebibitPerSecond, q => q.ToUnit(BitRateUnit.TebibitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.TebibitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.TebibytePerSecond, q => q.ToUnit(BitRateUnit.TebibytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.TebibytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.TerabitPerSecond, q => q.ToUnit(BitRateUnit.TerabitPerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.TerabitPerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRate<T>.BaseUnit, BitRateUnit.TerabytePerSecond, q => q.ToUnit(BitRateUnit.TerabytePerSecond));
+            unitConverter.SetConversionFunction<BitRate<T>>(BitRateUnit.TerabytePerSecond, BitRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption<T>>(BrakeSpecificFuelConsumption<T>.BaseUnit, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, q => q.ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour));
+            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption<T>>(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumption<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption<T>>(BrakeSpecificFuelConsumption<T>.BaseUnit, BrakeSpecificFuelConsumption<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption<T>>(BrakeSpecificFuelConsumption<T>.BaseUnit, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, q => q.ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour));
+            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption<T>>(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumption<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Capacitance<T>>(Capacitance<T>.BaseUnit, Capacitance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Capacitance<T>>(Capacitance<T>.BaseUnit, CapacitanceUnit.Kilofarad, q => q.ToUnit(CapacitanceUnit.Kilofarad));
+            unitConverter.SetConversionFunction<Capacitance<T>>(CapacitanceUnit.Kilofarad, Capacitance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Capacitance<T>>(Capacitance<T>.BaseUnit, CapacitanceUnit.Megafarad, q => q.ToUnit(CapacitanceUnit.Megafarad));
+            unitConverter.SetConversionFunction<Capacitance<T>>(CapacitanceUnit.Megafarad, Capacitance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Capacitance<T>>(Capacitance<T>.BaseUnit, CapacitanceUnit.Microfarad, q => q.ToUnit(CapacitanceUnit.Microfarad));
+            unitConverter.SetConversionFunction<Capacitance<T>>(CapacitanceUnit.Microfarad, Capacitance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Capacitance<T>>(Capacitance<T>.BaseUnit, CapacitanceUnit.Millifarad, q => q.ToUnit(CapacitanceUnit.Millifarad));
+            unitConverter.SetConversionFunction<Capacitance<T>>(CapacitanceUnit.Millifarad, Capacitance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Capacitance<T>>(Capacitance<T>.BaseUnit, CapacitanceUnit.Nanofarad, q => q.ToUnit(CapacitanceUnit.Nanofarad));
+            unitConverter.SetConversionFunction<Capacitance<T>>(CapacitanceUnit.Nanofarad, Capacitance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Capacitance<T>>(Capacitance<T>.BaseUnit, CapacitanceUnit.Picofarad, q => q.ToUnit(CapacitanceUnit.Picofarad));
+            unitConverter.SetConversionFunction<Capacitance<T>>(CapacitanceUnit.Picofarad, Capacitance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion<T>>(CoefficientOfThermalExpansion<T>.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, q => q.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius));
+            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion<T>>(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, CoefficientOfThermalExpansion<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion<T>>(CoefficientOfThermalExpansion<T>.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, q => q.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit));
+            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion<T>>(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, CoefficientOfThermalExpansion<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion<T>>(CoefficientOfThermalExpansion<T>.BaseUnit, CoefficientOfThermalExpansion<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.CentigramPerDeciliter, q => q.ToUnit(DensityUnit.CentigramPerDeciliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.CentigramPerDeciliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.CentigramPerLiter, q => q.ToUnit(DensityUnit.CentigramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.CentigramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.CentigramPerMilliliter, q => q.ToUnit(DensityUnit.CentigramPerMilliliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.CentigramPerMilliliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.DecigramPerDeciliter, q => q.ToUnit(DensityUnit.DecigramPerDeciliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.DecigramPerDeciliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.DecigramPerLiter, q => q.ToUnit(DensityUnit.DecigramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.DecigramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.DecigramPerMilliliter, q => q.ToUnit(DensityUnit.DecigramPerMilliliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.DecigramPerMilliliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.GramPerCubicCentimeter, q => q.ToUnit(DensityUnit.GramPerCubicCentimeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.GramPerCubicCentimeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.GramPerCubicMeter, q => q.ToUnit(DensityUnit.GramPerCubicMeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.GramPerCubicMeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.GramPerCubicMillimeter, q => q.ToUnit(DensityUnit.GramPerCubicMillimeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.GramPerCubicMillimeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.GramPerDeciliter, q => q.ToUnit(DensityUnit.GramPerDeciliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.GramPerDeciliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.GramPerLiter, q => q.ToUnit(DensityUnit.GramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.GramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.GramPerMilliliter, q => q.ToUnit(DensityUnit.GramPerMilliliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.GramPerMilliliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.KilogramPerCubicCentimeter, q => q.ToUnit(DensityUnit.KilogramPerCubicCentimeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.KilogramPerCubicCentimeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, Density<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.KilogramPerCubicMillimeter, q => q.ToUnit(DensityUnit.KilogramPerCubicMillimeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.KilogramPerCubicMillimeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.KilogramPerLiter, q => q.ToUnit(DensityUnit.KilogramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.KilogramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.KilopoundPerCubicFoot, q => q.ToUnit(DensityUnit.KilopoundPerCubicFoot));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.KilopoundPerCubicFoot, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.KilopoundPerCubicInch, q => q.ToUnit(DensityUnit.KilopoundPerCubicInch));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.KilopoundPerCubicInch, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MicrogramPerCubicMeter, q => q.ToUnit(DensityUnit.MicrogramPerCubicMeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MicrogramPerCubicMeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MicrogramPerDeciliter, q => q.ToUnit(DensityUnit.MicrogramPerDeciliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MicrogramPerDeciliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MicrogramPerLiter, q => q.ToUnit(DensityUnit.MicrogramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MicrogramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MicrogramPerMilliliter, q => q.ToUnit(DensityUnit.MicrogramPerMilliliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MicrogramPerMilliliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MilligramPerCubicMeter, q => q.ToUnit(DensityUnit.MilligramPerCubicMeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MilligramPerCubicMeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MilligramPerDeciliter, q => q.ToUnit(DensityUnit.MilligramPerDeciliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MilligramPerDeciliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MilligramPerLiter, q => q.ToUnit(DensityUnit.MilligramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MilligramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.MilligramPerMilliliter, q => q.ToUnit(DensityUnit.MilligramPerMilliliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.MilligramPerMilliliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.NanogramPerDeciliter, q => q.ToUnit(DensityUnit.NanogramPerDeciliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.NanogramPerDeciliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.NanogramPerLiter, q => q.ToUnit(DensityUnit.NanogramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.NanogramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.NanogramPerMilliliter, q => q.ToUnit(DensityUnit.NanogramPerMilliliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.NanogramPerMilliliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.PicogramPerDeciliter, q => q.ToUnit(DensityUnit.PicogramPerDeciliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.PicogramPerDeciliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.PicogramPerLiter, q => q.ToUnit(DensityUnit.PicogramPerLiter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.PicogramPerLiter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.PicogramPerMilliliter, q => q.ToUnit(DensityUnit.PicogramPerMilliliter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.PicogramPerMilliliter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.PoundPerCubicFoot, q => q.ToUnit(DensityUnit.PoundPerCubicFoot));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.PoundPerCubicFoot, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.PoundPerCubicInch, q => q.ToUnit(DensityUnit.PoundPerCubicInch));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.PoundPerCubicInch, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.PoundPerImperialGallon, q => q.ToUnit(DensityUnit.PoundPerImperialGallon));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.PoundPerImperialGallon, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.PoundPerUSGallon, q => q.ToUnit(DensityUnit.PoundPerUSGallon));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.PoundPerUSGallon, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.SlugPerCubicFoot, q => q.ToUnit(DensityUnit.SlugPerCubicFoot));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.SlugPerCubicFoot, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.TonnePerCubicCentimeter, q => q.ToUnit(DensityUnit.TonnePerCubicCentimeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.TonnePerCubicCentimeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.TonnePerCubicMeter, q => q.ToUnit(DensityUnit.TonnePerCubicMeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.TonnePerCubicMeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Density<T>>(Density<T>.BaseUnit, DensityUnit.TonnePerCubicMillimeter, q => q.ToUnit(DensityUnit.TonnePerCubicMillimeter));
+            unitConverter.SetConversionFunction<Density<T>>(DensityUnit.TonnePerCubicMillimeter, Density<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Day, q => q.ToUnit(DurationUnit.Day));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Day, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Hour, q => q.ToUnit(DurationUnit.Hour));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Hour, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Microsecond, q => q.ToUnit(DurationUnit.Microsecond));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Microsecond, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Millisecond, q => q.ToUnit(DurationUnit.Millisecond));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Millisecond, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Minute, q => q.ToUnit(DurationUnit.Minute));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Minute, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Month30, q => q.ToUnit(DurationUnit.Month30));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Month30, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Nanosecond, q => q.ToUnit(DurationUnit.Nanosecond));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Nanosecond, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, Duration<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Week, q => q.ToUnit(DurationUnit.Week));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Week, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Duration<T>>(Duration<T>.BaseUnit, DurationUnit.Year365, q => q.ToUnit(DurationUnit.Year365));
+            unitConverter.SetConversionFunction<Duration<T>>(DurationUnit.Year365, Duration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.Centipoise, q => q.ToUnit(DynamicViscosityUnit.Centipoise));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.Centipoise, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.MicropascalSecond, q => q.ToUnit(DynamicViscosityUnit.MicropascalSecond));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.MicropascalSecond, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.MillipascalSecond, q => q.ToUnit(DynamicViscosityUnit.MillipascalSecond));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.MillipascalSecond, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.PascalSecond, q => q.ToUnit(DynamicViscosityUnit.PascalSecond));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.PascalSecond, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.Poise, q => q.ToUnit(DynamicViscosityUnit.Poise));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.Poise, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.PoundForceSecondPerSquareFoot, q => q.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareFoot));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.PoundForceSecondPerSquareFoot, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.PoundForceSecondPerSquareInch, q => q.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareInch));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.PoundForceSecondPerSquareInch, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.PoundPerFootSecond, q => q.ToUnit(DynamicViscosityUnit.PoundPerFootSecond));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.PoundPerFootSecond, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosity<T>.BaseUnit, DynamicViscosityUnit.Reyn, q => q.ToUnit(DynamicViscosityUnit.Reyn));
+            unitConverter.SetConversionFunction<DynamicViscosity<T>>(DynamicViscosityUnit.Reyn, DynamicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricAdmittance<T>>(ElectricAdmittance<T>.BaseUnit, ElectricAdmittanceUnit.Microsiemens, q => q.ToUnit(ElectricAdmittanceUnit.Microsiemens));
+            unitConverter.SetConversionFunction<ElectricAdmittance<T>>(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricAdmittance<T>>(ElectricAdmittance<T>.BaseUnit, ElectricAdmittanceUnit.Millisiemens, q => q.ToUnit(ElectricAdmittanceUnit.Millisiemens));
+            unitConverter.SetConversionFunction<ElectricAdmittance<T>>(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricAdmittance<T>>(ElectricAdmittance<T>.BaseUnit, ElectricAdmittanceUnit.Nanosiemens, q => q.ToUnit(ElectricAdmittanceUnit.Nanosiemens));
+            unitConverter.SetConversionFunction<ElectricAdmittance<T>>(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricAdmittance<T>>(ElectricAdmittance<T>.BaseUnit, ElectricAdmittance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricCharge<T>.BaseUnit, ElectricChargeUnit.AmpereHour, q => q.ToUnit(ElectricChargeUnit.AmpereHour));
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricChargeUnit.AmpereHour, ElectricCharge<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricCharge<T>.BaseUnit, ElectricCharge<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricCharge<T>.BaseUnit, ElectricChargeUnit.KiloampereHour, q => q.ToUnit(ElectricChargeUnit.KiloampereHour));
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricChargeUnit.KiloampereHour, ElectricCharge<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricCharge<T>.BaseUnit, ElectricChargeUnit.MegaampereHour, q => q.ToUnit(ElectricChargeUnit.MegaampereHour));
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricChargeUnit.MegaampereHour, ElectricCharge<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricCharge<T>.BaseUnit, ElectricChargeUnit.MilliampereHour, q => q.ToUnit(ElectricChargeUnit.MilliampereHour));
+            unitConverter.SetConversionFunction<ElectricCharge<T>>(ElectricChargeUnit.MilliampereHour, ElectricCharge<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricChargeDensity<T>>(ElectricChargeDensity<T>.BaseUnit, ElectricChargeDensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricConductance<T>>(ElectricConductance<T>.BaseUnit, ElectricConductanceUnit.Microsiemens, q => q.ToUnit(ElectricConductanceUnit.Microsiemens));
+            unitConverter.SetConversionFunction<ElectricConductance<T>>(ElectricConductanceUnit.Microsiemens, ElectricConductance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricConductance<T>>(ElectricConductance<T>.BaseUnit, ElectricConductanceUnit.Millisiemens, q => q.ToUnit(ElectricConductanceUnit.Millisiemens));
+            unitConverter.SetConversionFunction<ElectricConductance<T>>(ElectricConductanceUnit.Millisiemens, ElectricConductance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricConductance<T>>(ElectricConductance<T>.BaseUnit, ElectricConductance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricConductivity<T>>(ElectricConductivity<T>.BaseUnit, ElectricConductivityUnit.SiemensPerFoot, q => q.ToUnit(ElectricConductivityUnit.SiemensPerFoot));
+            unitConverter.SetConversionFunction<ElectricConductivity<T>>(ElectricConductivityUnit.SiemensPerFoot, ElectricConductivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricConductivity<T>>(ElectricConductivity<T>.BaseUnit, ElectricConductivityUnit.SiemensPerInch, q => q.ToUnit(ElectricConductivityUnit.SiemensPerInch));
+            unitConverter.SetConversionFunction<ElectricConductivity<T>>(ElectricConductivityUnit.SiemensPerInch, ElectricConductivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricConductivity<T>>(ElectricConductivity<T>.BaseUnit, ElectricConductivity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrent<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrentUnit.Centiampere, q => q.ToUnit(ElectricCurrentUnit.Centiampere));
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrentUnit.Centiampere, ElectricCurrent<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrentUnit.Kiloampere, q => q.ToUnit(ElectricCurrentUnit.Kiloampere));
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrentUnit.Kiloampere, ElectricCurrent<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrentUnit.Megaampere, q => q.ToUnit(ElectricCurrentUnit.Megaampere));
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrentUnit.Megaampere, ElectricCurrent<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrentUnit.Microampere, q => q.ToUnit(ElectricCurrentUnit.Microampere));
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrentUnit.Microampere, ElectricCurrent<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrentUnit.Milliampere, q => q.ToUnit(ElectricCurrentUnit.Milliampere));
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrentUnit.Milliampere, ElectricCurrent<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrentUnit.Nanoampere, q => q.ToUnit(ElectricCurrentUnit.Nanoampere));
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrentUnit.Nanoampere, ElectricCurrent<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrent<T>.BaseUnit, ElectricCurrentUnit.Picoampere, q => q.ToUnit(ElectricCurrentUnit.Picoampere));
+            unitConverter.SetConversionFunction<ElectricCurrent<T>>(ElectricCurrentUnit.Picoampere, ElectricCurrent<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrentDensity<T>>(ElectricCurrentDensity<T>.BaseUnit, ElectricCurrentDensityUnit.AmperePerSquareFoot, q => q.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareFoot));
+            unitConverter.SetConversionFunction<ElectricCurrentDensity<T>>(ElectricCurrentDensityUnit.AmperePerSquareFoot, ElectricCurrentDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrentDensity<T>>(ElectricCurrentDensity<T>.BaseUnit, ElectricCurrentDensityUnit.AmperePerSquareInch, q => q.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareInch));
+            unitConverter.SetConversionFunction<ElectricCurrentDensity<T>>(ElectricCurrentDensityUnit.AmperePerSquareInch, ElectricCurrentDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrentDensity<T>>(ElectricCurrentDensity<T>.BaseUnit, ElectricCurrentDensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricCurrentGradient<T>>(ElectricCurrentGradient<T>.BaseUnit, ElectricCurrentGradientUnit.AmperePerMicrosecond, q => q.ToUnit(ElectricCurrentGradientUnit.AmperePerMicrosecond));
+            unitConverter.SetConversionFunction<ElectricCurrentGradient<T>>(ElectricCurrentGradientUnit.AmperePerMicrosecond, ElectricCurrentGradient<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrentGradient<T>>(ElectricCurrentGradient<T>.BaseUnit, ElectricCurrentGradientUnit.AmperePerMillisecond, q => q.ToUnit(ElectricCurrentGradientUnit.AmperePerMillisecond));
+            unitConverter.SetConversionFunction<ElectricCurrentGradient<T>>(ElectricCurrentGradientUnit.AmperePerMillisecond, ElectricCurrentGradient<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrentGradient<T>>(ElectricCurrentGradient<T>.BaseUnit, ElectricCurrentGradientUnit.AmperePerNanosecond, q => q.ToUnit(ElectricCurrentGradientUnit.AmperePerNanosecond));
+            unitConverter.SetConversionFunction<ElectricCurrentGradient<T>>(ElectricCurrentGradientUnit.AmperePerNanosecond, ElectricCurrentGradient<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricCurrentGradient<T>>(ElectricCurrentGradient<T>.BaseUnit, ElectricCurrentGradient<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricField<T>>(ElectricField<T>.BaseUnit, ElectricField<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricInductance<T>>(ElectricInductance<T>.BaseUnit, ElectricInductance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricInductance<T>>(ElectricInductance<T>.BaseUnit, ElectricInductanceUnit.Microhenry, q => q.ToUnit(ElectricInductanceUnit.Microhenry));
+            unitConverter.SetConversionFunction<ElectricInductance<T>>(ElectricInductanceUnit.Microhenry, ElectricInductance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricInductance<T>>(ElectricInductance<T>.BaseUnit, ElectricInductanceUnit.Millihenry, q => q.ToUnit(ElectricInductanceUnit.Millihenry));
+            unitConverter.SetConversionFunction<ElectricInductance<T>>(ElectricInductanceUnit.Millihenry, ElectricInductance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricInductance<T>>(ElectricInductance<T>.BaseUnit, ElectricInductanceUnit.Nanohenry, q => q.ToUnit(ElectricInductanceUnit.Nanohenry));
+            unitConverter.SetConversionFunction<ElectricInductance<T>>(ElectricInductanceUnit.Nanohenry, ElectricInductance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotential<T>.BaseUnit, ElectricPotentialUnit.Kilovolt, q => q.ToUnit(ElectricPotentialUnit.Kilovolt));
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotentialUnit.Kilovolt, ElectricPotential<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotential<T>.BaseUnit, ElectricPotentialUnit.Megavolt, q => q.ToUnit(ElectricPotentialUnit.Megavolt));
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotentialUnit.Megavolt, ElectricPotential<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotential<T>.BaseUnit, ElectricPotentialUnit.Microvolt, q => q.ToUnit(ElectricPotentialUnit.Microvolt));
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotentialUnit.Microvolt, ElectricPotential<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotential<T>.BaseUnit, ElectricPotentialUnit.Millivolt, q => q.ToUnit(ElectricPotentialUnit.Millivolt));
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotentialUnit.Millivolt, ElectricPotential<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotential<T>>(ElectricPotential<T>.BaseUnit, ElectricPotential<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAc<T>.BaseUnit, ElectricPotentialAcUnit.KilovoltAc, q => q.ToUnit(ElectricPotentialAcUnit.KilovoltAc));
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAcUnit.KilovoltAc, ElectricPotentialAc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAc<T>.BaseUnit, ElectricPotentialAcUnit.MegavoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MegavoltAc));
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAcUnit.MegavoltAc, ElectricPotentialAc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAc<T>.BaseUnit, ElectricPotentialAcUnit.MicrovoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MicrovoltAc));
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAcUnit.MicrovoltAc, ElectricPotentialAc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAc<T>.BaseUnit, ElectricPotentialAcUnit.MillivoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MillivoltAc));
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAcUnit.MillivoltAc, ElectricPotentialAc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialAc<T>>(ElectricPotentialAc<T>.BaseUnit, ElectricPotentialAc<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerHour));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.KilovoltPerHour, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerMinute));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.KilovoltPerMinute, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.KilovoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerSecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.KilovoltPerSecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerHour));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MegavoltPerHour, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerMinute));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MegavoltPerMinute, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MegavoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerSecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MegavoltPerSecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerHour));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MicrovoltPerHour, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerMinute));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MicrovoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerSecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerHour));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MillivoltPerHour, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerMinute));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MillivoltPerMinute, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.MillivoltPerSecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerSecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.MillivoltPerSecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.VoltPerHour, q => q.ToUnit(ElectricPotentialChangeRateUnit.VoltPerHour));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.VoltPerHour, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.VoltPerMicrosecond, q => q.ToUnit(ElectricPotentialChangeRateUnit.VoltPerMicrosecond));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRateUnit.VoltPerMinute, q => q.ToUnit(ElectricPotentialChangeRateUnit.VoltPerMinute));
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRateUnit.VoltPerMinute, ElectricPotentialChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialChangeRate<T>>(ElectricPotentialChangeRate<T>.BaseUnit, ElectricPotentialChangeRate<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDc<T>.BaseUnit, ElectricPotentialDcUnit.KilovoltDc, q => q.ToUnit(ElectricPotentialDcUnit.KilovoltDc));
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDcUnit.KilovoltDc, ElectricPotentialDc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDc<T>.BaseUnit, ElectricPotentialDcUnit.MegavoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MegavoltDc));
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDcUnit.MegavoltDc, ElectricPotentialDc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDc<T>.BaseUnit, ElectricPotentialDcUnit.MicrovoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MicrovoltDc));
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDcUnit.MicrovoltDc, ElectricPotentialDc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDc<T>.BaseUnit, ElectricPotentialDcUnit.MillivoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MillivoltDc));
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDcUnit.MillivoltDc, ElectricPotentialDc<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricPotentialDc<T>>(ElectricPotentialDc<T>.BaseUnit, ElectricPotentialDc<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistance<T>.BaseUnit, ElectricResistanceUnit.Gigaohm, q => q.ToUnit(ElectricResistanceUnit.Gigaohm));
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistanceUnit.Gigaohm, ElectricResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistance<T>.BaseUnit, ElectricResistanceUnit.Kiloohm, q => q.ToUnit(ElectricResistanceUnit.Kiloohm));
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistanceUnit.Kiloohm, ElectricResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistance<T>.BaseUnit, ElectricResistanceUnit.Megaohm, q => q.ToUnit(ElectricResistanceUnit.Megaohm));
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistanceUnit.Megaohm, ElectricResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistance<T>.BaseUnit, ElectricResistanceUnit.Microohm, q => q.ToUnit(ElectricResistanceUnit.Microohm));
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistanceUnit.Microohm, ElectricResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistance<T>.BaseUnit, ElectricResistanceUnit.Milliohm, q => q.ToUnit(ElectricResistanceUnit.Milliohm));
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistanceUnit.Milliohm, ElectricResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistance<T>>(ElectricResistance<T>.BaseUnit, ElectricResistance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.KiloohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.KiloohmCentimeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.KiloohmMeter, q => q.ToUnit(ElectricResistivityUnit.KiloohmMeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.KiloohmMeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.MegaohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MegaohmCentimeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.MegaohmMeter, q => q.ToUnit(ElectricResistivityUnit.MegaohmMeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.MegaohmMeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.MicroohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MicroohmCentimeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.MicroohmMeter, q => q.ToUnit(ElectricResistivityUnit.MicroohmMeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.MicroohmMeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.MilliohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MilliohmCentimeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.MilliohmMeter, q => q.ToUnit(ElectricResistivityUnit.MilliohmMeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.MilliohmMeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.NanoohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.NanoohmCentimeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.NanoohmMeter, q => q.ToUnit(ElectricResistivityUnit.NanoohmMeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.NanoohmMeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.OhmCentimeter, q => q.ToUnit(ElectricResistivityUnit.OhmCentimeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.OhmCentimeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.PicoohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.PicoohmCentimeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivity<T>.BaseUnit, ElectricResistivityUnit.PicoohmMeter, q => q.ToUnit(ElectricResistivityUnit.PicoohmMeter));
+            unitConverter.SetConversionFunction<ElectricResistivity<T>>(ElectricResistivityUnit.PicoohmMeter, ElectricResistivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity<T>>(ElectricSurfaceChargeDensity<T>.BaseUnit, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, q => q.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter));
+            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity<T>>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, ElectricSurfaceChargeDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity<T>>(ElectricSurfaceChargeDensity<T>.BaseUnit, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, q => q.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch));
+            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity<T>>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, ElectricSurfaceChargeDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity<T>>(ElectricSurfaceChargeDensity<T>.BaseUnit, ElectricSurfaceChargeDensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.BritishThermalUnit, q => q.ToUnit(EnergyUnit.BritishThermalUnit));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.BritishThermalUnit, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Calorie, q => q.ToUnit(EnergyUnit.Calorie));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Calorie, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.DecathermEc, q => q.ToUnit(EnergyUnit.DecathermEc));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.DecathermEc, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.DecathermImperial, q => q.ToUnit(EnergyUnit.DecathermImperial));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.DecathermImperial, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.DecathermUs, q => q.ToUnit(EnergyUnit.DecathermUs));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.DecathermUs, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.ElectronVolt, q => q.ToUnit(EnergyUnit.ElectronVolt));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.ElectronVolt, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Erg, q => q.ToUnit(EnergyUnit.Erg));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Erg, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.FootPound, q => q.ToUnit(EnergyUnit.FootPound));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.FootPound, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.GigabritishThermalUnit, q => q.ToUnit(EnergyUnit.GigabritishThermalUnit));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.GigabritishThermalUnit, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.GigaelectronVolt, q => q.ToUnit(EnergyUnit.GigaelectronVolt));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.GigaelectronVolt, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Gigajoule, q => q.ToUnit(EnergyUnit.Gigajoule));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Gigajoule, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.GigawattDay, q => q.ToUnit(EnergyUnit.GigawattDay));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.GigawattDay, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.GigawattHour, q => q.ToUnit(EnergyUnit.GigawattHour));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.GigawattHour, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.HorsepowerHour, q => q.ToUnit(EnergyUnit.HorsepowerHour));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.HorsepowerHour, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, Energy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.KilobritishThermalUnit, q => q.ToUnit(EnergyUnit.KilobritishThermalUnit));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.KilobritishThermalUnit, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Kilocalorie, q => q.ToUnit(EnergyUnit.Kilocalorie));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Kilocalorie, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.KiloelectronVolt, q => q.ToUnit(EnergyUnit.KiloelectronVolt));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.KiloelectronVolt, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Kilojoule, q => q.ToUnit(EnergyUnit.Kilojoule));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Kilojoule, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.KilowattDay, q => q.ToUnit(EnergyUnit.KilowattDay));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.KilowattDay, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.KilowattHour, q => q.ToUnit(EnergyUnit.KilowattHour));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.KilowattHour, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.MegabritishThermalUnit, q => q.ToUnit(EnergyUnit.MegabritishThermalUnit));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.MegabritishThermalUnit, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Megacalorie, q => q.ToUnit(EnergyUnit.Megacalorie));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Megacalorie, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.MegaelectronVolt, q => q.ToUnit(EnergyUnit.MegaelectronVolt));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.MegaelectronVolt, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Megajoule, q => q.ToUnit(EnergyUnit.Megajoule));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Megajoule, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.MegawattDay, q => q.ToUnit(EnergyUnit.MegawattDay));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.MegawattDay, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.MegawattHour, q => q.ToUnit(EnergyUnit.MegawattHour));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.MegawattHour, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.Millijoule, q => q.ToUnit(EnergyUnit.Millijoule));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.Millijoule, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.TeraelectronVolt, q => q.ToUnit(EnergyUnit.TeraelectronVolt));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.TeraelectronVolt, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.TerawattDay, q => q.ToUnit(EnergyUnit.TerawattDay));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.TerawattDay, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.TerawattHour, q => q.ToUnit(EnergyUnit.TerawattHour));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.TerawattHour, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.ThermEc, q => q.ToUnit(EnergyUnit.ThermEc));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.ThermEc, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.ThermImperial, q => q.ToUnit(EnergyUnit.ThermImperial));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.ThermImperial, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.ThermUs, q => q.ToUnit(EnergyUnit.ThermUs));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.ThermUs, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.WattDay, q => q.ToUnit(EnergyUnit.WattDay));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.WattDay, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Energy<T>>(Energy<T>.BaseUnit, EnergyUnit.WattHour, q => q.ToUnit(EnergyUnit.WattHour));
+            unitConverter.SetConversionFunction<Energy<T>>(EnergyUnit.WattHour, Energy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Entropy<T>>(Entropy<T>.BaseUnit, EntropyUnit.CaloriePerKelvin, q => q.ToUnit(EntropyUnit.CaloriePerKelvin));
+            unitConverter.SetConversionFunction<Entropy<T>>(EntropyUnit.CaloriePerKelvin, Entropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Entropy<T>>(Entropy<T>.BaseUnit, EntropyUnit.JoulePerDegreeCelsius, q => q.ToUnit(EntropyUnit.JoulePerDegreeCelsius));
+            unitConverter.SetConversionFunction<Entropy<T>>(EntropyUnit.JoulePerDegreeCelsius, Entropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Entropy<T>>(Entropy<T>.BaseUnit, Entropy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Entropy<T>>(Entropy<T>.BaseUnit, EntropyUnit.KilocaloriePerKelvin, q => q.ToUnit(EntropyUnit.KilocaloriePerKelvin));
+            unitConverter.SetConversionFunction<Entropy<T>>(EntropyUnit.KilocaloriePerKelvin, Entropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Entropy<T>>(Entropy<T>.BaseUnit, EntropyUnit.KilojoulePerDegreeCelsius, q => q.ToUnit(EntropyUnit.KilojoulePerDegreeCelsius));
+            unitConverter.SetConversionFunction<Entropy<T>>(EntropyUnit.KilojoulePerDegreeCelsius, Entropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Entropy<T>>(Entropy<T>.BaseUnit, EntropyUnit.KilojoulePerKelvin, q => q.ToUnit(EntropyUnit.KilojoulePerKelvin));
+            unitConverter.SetConversionFunction<Entropy<T>>(EntropyUnit.KilojoulePerKelvin, Entropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Entropy<T>>(Entropy<T>.BaseUnit, EntropyUnit.MegajoulePerKelvin, q => q.ToUnit(EntropyUnit.MegajoulePerKelvin));
+            unitConverter.SetConversionFunction<Entropy<T>>(EntropyUnit.MegajoulePerKelvin, Entropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.Decanewton, q => q.ToUnit(ForceUnit.Decanewton));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.Decanewton, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.Dyn, q => q.ToUnit(ForceUnit.Dyn));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.Dyn, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.KilogramForce, q => q.ToUnit(ForceUnit.KilogramForce));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.KilogramForce, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.Kilonewton, q => q.ToUnit(ForceUnit.Kilonewton));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.Kilonewton, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.KiloPond, q => q.ToUnit(ForceUnit.KiloPond));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.KiloPond, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.KilopoundForce, q => q.ToUnit(ForceUnit.KilopoundForce));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.KilopoundForce, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.Meganewton, q => q.ToUnit(ForceUnit.Meganewton));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.Meganewton, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.Micronewton, q => q.ToUnit(ForceUnit.Micronewton));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.Micronewton, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.Millinewton, q => q.ToUnit(ForceUnit.Millinewton));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.Millinewton, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, Force<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.OunceForce, q => q.ToUnit(ForceUnit.OunceForce));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.OunceForce, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.Poundal, q => q.ToUnit(ForceUnit.Poundal));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.Poundal, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.PoundForce, q => q.ToUnit(ForceUnit.PoundForce));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.PoundForce, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.ShortTonForce, q => q.ToUnit(ForceUnit.ShortTonForce));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.ShortTonForce, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force<T>>(Force<T>.BaseUnit, ForceUnit.TonneForce, q => q.ToUnit(ForceUnit.TonneForce));
+            unitConverter.SetConversionFunction<Force<T>>(ForceUnit.TonneForce, Force<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.CentinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.CentinewtonPerSecond));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.DecanewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.DecanewtonPerMinute));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.DecanewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.DecanewtonPerSecond));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.DecinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.DecinewtonPerSecond));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.KilonewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.KilonewtonPerMinute));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.KilonewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.KilonewtonPerSecond));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.MicronewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MicronewtonPerSecond));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.MillinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MillinewtonPerSecond));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.NanonewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.NanonewtonPerSecond));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRateUnit.NewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.NewtonPerMinute));
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForceChangeRate<T>>(ForceChangeRate<T>.BaseUnit, ForceChangeRate<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.CentinewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.CentinewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.CentinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.CentinewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.CentinewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.DecanewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.DecanewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.DecanewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.DecanewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.DecanewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.DecanewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.DecanewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.DecanewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.DecanewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.DecinewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.DecinewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.DecinewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.DecinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.DecinewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.DecinewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.DecinewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.DecinewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilogramForcePerCentimeter, q => q.ToUnit(ForcePerLengthUnit.KilogramForcePerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilogramForcePerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilogramForcePerMeter, q => q.ToUnit(ForcePerLengthUnit.KilogramForcePerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilogramForcePerMillimeter, q => q.ToUnit(ForcePerLengthUnit.KilogramForcePerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilogramForcePerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilonewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.KilonewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilonewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilonewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.KilonewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilonewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.KilonewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilonewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilopoundForcePerFoot, q => q.ToUnit(ForcePerLengthUnit.KilopoundForcePerFoot));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilopoundForcePerFoot, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.KilopoundForcePerInch, q => q.ToUnit(ForcePerLengthUnit.KilopoundForcePerInch));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.KilopoundForcePerInch, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MeganewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.MeganewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MeganewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MeganewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MeganewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MeganewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.MeganewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MeganewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MicronewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.MicronewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MicronewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MicronewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MicronewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MicronewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.MicronewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MicronewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MillinewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.MillinewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MillinewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MillinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MillinewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.MillinewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.MillinewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.MillinewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.NanonewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.NanonewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.NanonewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.NanonewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.NanonewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.NewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.NewtonPerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.NewtonPerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLength<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.NewtonPerMillimeter, q => q.ToUnit(ForcePerLengthUnit.NewtonPerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.NewtonPerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.PoundForcePerFoot, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerFoot));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.PoundForcePerFoot, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.PoundForcePerInch, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerInch));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.PoundForcePerInch, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.PoundForcePerYard, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerYard));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.PoundForcePerYard, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.TonneForcePerCentimeter, q => q.ToUnit(ForcePerLengthUnit.TonneForcePerCentimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.TonneForcePerCentimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.TonneForcePerMeter, q => q.ToUnit(ForcePerLengthUnit.TonneForcePerMeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.TonneForcePerMeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLength<T>.BaseUnit, ForcePerLengthUnit.TonneForcePerMillimeter, q => q.ToUnit(ForcePerLengthUnit.TonneForcePerMillimeter));
+            unitConverter.SetConversionFunction<ForcePerLength<T>>(ForcePerLengthUnit.TonneForcePerMillimeter, ForcePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.BeatPerMinute, q => q.ToUnit(FrequencyUnit.BeatPerMinute));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.BeatPerMinute, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.CyclePerHour, q => q.ToUnit(FrequencyUnit.CyclePerHour));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.CyclePerHour, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.CyclePerMinute, q => q.ToUnit(FrequencyUnit.CyclePerMinute));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.CyclePerMinute, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.Gigahertz, q => q.ToUnit(FrequencyUnit.Gigahertz));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.Gigahertz, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, Frequency<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.Kilohertz, q => q.ToUnit(FrequencyUnit.Kilohertz));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.Kilohertz, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.Megahertz, q => q.ToUnit(FrequencyUnit.Megahertz));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.Megahertz, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.PerSecond, q => q.ToUnit(FrequencyUnit.PerSecond));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.PerSecond, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.RadianPerSecond, q => q.ToUnit(FrequencyUnit.RadianPerSecond));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.RadianPerSecond, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Frequency<T>>(Frequency<T>.BaseUnit, FrequencyUnit.Terahertz, q => q.ToUnit(FrequencyUnit.Terahertz));
+            unitConverter.SetConversionFunction<Frequency<T>>(FrequencyUnit.Terahertz, Frequency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<FuelEfficiency<T>>(FuelEfficiency<T>.BaseUnit, FuelEfficiencyUnit.KilometerPerLiter, q => q.ToUnit(FuelEfficiencyUnit.KilometerPerLiter));
+            unitConverter.SetConversionFunction<FuelEfficiency<T>>(FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<FuelEfficiency<T>>(FuelEfficiency<T>.BaseUnit, FuelEfficiency<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<FuelEfficiency<T>>(FuelEfficiency<T>.BaseUnit, FuelEfficiencyUnit.MilePerUkGallon, q => q.ToUnit(FuelEfficiencyUnit.MilePerUkGallon));
+            unitConverter.SetConversionFunction<FuelEfficiency<T>>(FuelEfficiencyUnit.MilePerUkGallon, FuelEfficiency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<FuelEfficiency<T>>(FuelEfficiency<T>.BaseUnit, FuelEfficiencyUnit.MilePerUsGallon, q => q.ToUnit(FuelEfficiencyUnit.MilePerUsGallon));
+            unitConverter.SetConversionFunction<FuelEfficiency<T>>(FuelEfficiencyUnit.MilePerUsGallon, FuelEfficiency<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.BtuPerHourSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerHourSquareFoot));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.BtuPerHourSquareFoot, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.BtuPerMinuteSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerMinuteSquareFoot));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.BtuPerSecondSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerSecondSquareFoot));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.BtuPerSecondSquareInch, q => q.ToUnit(HeatFluxUnit.BtuPerSecondSquareInch));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.BtuPerSecondSquareInch, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.CaloriePerSecondSquareCentimeter, q => q.ToUnit(HeatFluxUnit.CaloriePerSecondSquareCentimeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.CentiwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.CentiwattPerSquareMeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.CentiwattPerSquareMeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.DeciwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.DeciwattPerSquareMeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.DeciwattPerSquareMeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.KilocaloriePerHourSquareMeter, q => q.ToUnit(HeatFluxUnit.KilocaloriePerHourSquareMeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, q => q.ToUnit(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.KilowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.KilowattPerSquareMeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.KilowattPerSquareMeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.MicrowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.MicrowattPerSquareMeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.MicrowattPerSquareMeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.MilliwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.MilliwattPerSquareMeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.MilliwattPerSquareMeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.NanowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.NanowattPerSquareMeter));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.NanowattPerSquareMeter, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.PoundForcePerFootSecond, q => q.ToUnit(HeatFluxUnit.PoundForcePerFootSecond));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.PoundForcePerFootSecond, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.PoundPerSecondCubed, q => q.ToUnit(HeatFluxUnit.PoundPerSecondCubed));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.PoundPerSecondCubed, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.WattPerSquareFoot, q => q.ToUnit(HeatFluxUnit.WattPerSquareFoot));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.WattPerSquareFoot, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFluxUnit.WattPerSquareInch, q => q.ToUnit(HeatFluxUnit.WattPerSquareInch));
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFluxUnit.WattPerSquareInch, HeatFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatFlux<T>>(HeatFlux<T>.BaseUnit, HeatFlux<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<HeatTransferCoefficient<T>>(HeatTransferCoefficient<T>.BaseUnit, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, q => q.ToUnit(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit));
+            unitConverter.SetConversionFunction<HeatTransferCoefficient<T>>(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, HeatTransferCoefficient<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatTransferCoefficient<T>>(HeatTransferCoefficient<T>.BaseUnit, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, q => q.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius));
+            unitConverter.SetConversionFunction<HeatTransferCoefficient<T>>(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<HeatTransferCoefficient<T>>(HeatTransferCoefficient<T>.BaseUnit, HeatTransferCoefficient<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Illuminance<T>>(Illuminance<T>.BaseUnit, IlluminanceUnit.Kilolux, q => q.ToUnit(IlluminanceUnit.Kilolux));
+            unitConverter.SetConversionFunction<Illuminance<T>>(IlluminanceUnit.Kilolux, Illuminance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Illuminance<T>>(Illuminance<T>.BaseUnit, Illuminance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Illuminance<T>>(Illuminance<T>.BaseUnit, IlluminanceUnit.Megalux, q => q.ToUnit(IlluminanceUnit.Megalux));
+            unitConverter.SetConversionFunction<Illuminance<T>>(IlluminanceUnit.Megalux, Illuminance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Illuminance<T>>(Illuminance<T>.BaseUnit, IlluminanceUnit.Millilux, q => q.ToUnit(IlluminanceUnit.Millilux));
+            unitConverter.SetConversionFunction<Illuminance<T>>(IlluminanceUnit.Millilux, Illuminance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, Information<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Byte, q => q.ToUnit(InformationUnit.Byte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Byte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Exabit, q => q.ToUnit(InformationUnit.Exabit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Exabit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Exabyte, q => q.ToUnit(InformationUnit.Exabyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Exabyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Exbibit, q => q.ToUnit(InformationUnit.Exbibit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Exbibit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Exbibyte, q => q.ToUnit(InformationUnit.Exbibyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Exbibyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Gibibit, q => q.ToUnit(InformationUnit.Gibibit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Gibibit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Gibibyte, q => q.ToUnit(InformationUnit.Gibibyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Gibibyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Gigabit, q => q.ToUnit(InformationUnit.Gigabit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Gigabit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Gigabyte, q => q.ToUnit(InformationUnit.Gigabyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Gigabyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Kibibit, q => q.ToUnit(InformationUnit.Kibibit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Kibibit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Kibibyte, q => q.ToUnit(InformationUnit.Kibibyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Kibibyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Kilobit, q => q.ToUnit(InformationUnit.Kilobit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Kilobit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Kilobyte, q => q.ToUnit(InformationUnit.Kilobyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Kilobyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Mebibit, q => q.ToUnit(InformationUnit.Mebibit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Mebibit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Mebibyte, q => q.ToUnit(InformationUnit.Mebibyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Mebibyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Megabit, q => q.ToUnit(InformationUnit.Megabit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Megabit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Megabyte, q => q.ToUnit(InformationUnit.Megabyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Megabyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Pebibit, q => q.ToUnit(InformationUnit.Pebibit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Pebibit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Pebibyte, q => q.ToUnit(InformationUnit.Pebibyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Pebibyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Petabit, q => q.ToUnit(InformationUnit.Petabit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Petabit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Petabyte, q => q.ToUnit(InformationUnit.Petabyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Petabyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Tebibit, q => q.ToUnit(InformationUnit.Tebibit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Tebibit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Tebibyte, q => q.ToUnit(InformationUnit.Tebibyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Tebibyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Terabit, q => q.ToUnit(InformationUnit.Terabit));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Terabit, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Information<T>>(Information<T>.BaseUnit, InformationUnit.Terabyte, q => q.ToUnit(InformationUnit.Terabyte));
+            unitConverter.SetConversionFunction<Information<T>>(InformationUnit.Terabyte, Information<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.KilowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.KilowattPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.KilowattPerSquareCentimeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.KilowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.KilowattPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.KilowattPerSquareMeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.MegawattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MegawattPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.MegawattPerSquareCentimeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.MegawattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MegawattPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.MegawattPerSquareMeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.MicrowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MicrowattPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.MicrowattPerSquareCentimeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.MicrowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MicrowattPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.MicrowattPerSquareMeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.MilliwattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MilliwattPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.MilliwattPerSquareCentimeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.MilliwattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MilliwattPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.MilliwattPerSquareMeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.NanowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.NanowattPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.NanowattPerSquareCentimeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.NanowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.NanowattPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.NanowattPerSquareMeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.PicowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.PicowattPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.PicowattPerSquareCentimeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.PicowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.PicowattPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.PicowattPerSquareMeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, IrradianceUnit.WattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.WattPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiance<T>>(IrradianceUnit.WattPerSquareCentimeter, Irradiance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiance<T>>(Irradiance<T>.BaseUnit, Irradiance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Irradiation<T>>(Irradiation<T>.BaseUnit, IrradiationUnit.JoulePerSquareCentimeter, q => q.ToUnit(IrradiationUnit.JoulePerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiation<T>>(IrradiationUnit.JoulePerSquareCentimeter, Irradiation<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiation<T>>(Irradiation<T>.BaseUnit, Irradiation<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Irradiation<T>>(Irradiation<T>.BaseUnit, IrradiationUnit.JoulePerSquareMillimeter, q => q.ToUnit(IrradiationUnit.JoulePerSquareMillimeter));
+            unitConverter.SetConversionFunction<Irradiation<T>>(IrradiationUnit.JoulePerSquareMillimeter, Irradiation<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiation<T>>(Irradiation<T>.BaseUnit, IrradiationUnit.KilojoulePerSquareMeter, q => q.ToUnit(IrradiationUnit.KilojoulePerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiation<T>>(IrradiationUnit.KilojoulePerSquareMeter, Irradiation<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiation<T>>(Irradiation<T>.BaseUnit, IrradiationUnit.KilowattHourPerSquareMeter, q => q.ToUnit(IrradiationUnit.KilowattHourPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiation<T>>(IrradiationUnit.KilowattHourPerSquareMeter, Irradiation<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiation<T>>(Irradiation<T>.BaseUnit, IrradiationUnit.MillijoulePerSquareCentimeter, q => q.ToUnit(IrradiationUnit.MillijoulePerSquareCentimeter));
+            unitConverter.SetConversionFunction<Irradiation<T>>(IrradiationUnit.MillijoulePerSquareCentimeter, Irradiation<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Irradiation<T>>(Irradiation<T>.BaseUnit, IrradiationUnit.WattHourPerSquareMeter, q => q.ToUnit(IrradiationUnit.WattHourPerSquareMeter));
+            unitConverter.SetConversionFunction<Irradiation<T>>(IrradiationUnit.WattHourPerSquareMeter, Irradiation<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosityUnit.Centistokes, q => q.ToUnit(KinematicViscosityUnit.Centistokes));
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosityUnit.Centistokes, KinematicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosityUnit.Decistokes, q => q.ToUnit(KinematicViscosityUnit.Decistokes));
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosityUnit.Decistokes, KinematicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosityUnit.Kilostokes, q => q.ToUnit(KinematicViscosityUnit.Kilostokes));
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosityUnit.Kilostokes, KinematicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosityUnit.Microstokes, q => q.ToUnit(KinematicViscosityUnit.Microstokes));
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosityUnit.Microstokes, KinematicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosityUnit.Millistokes, q => q.ToUnit(KinematicViscosityUnit.Millistokes));
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosityUnit.Millistokes, KinematicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosityUnit.Nanostokes, q => q.ToUnit(KinematicViscosityUnit.Nanostokes));
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosityUnit.Nanostokes, KinematicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosity<T>.BaseUnit, KinematicViscosityUnit.Stokes, q => q.ToUnit(KinematicViscosityUnit.Stokes));
+            unitConverter.SetConversionFunction<KinematicViscosity<T>>(KinematicViscosityUnit.Stokes, KinematicViscosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LapseRate<T>>(LapseRate<T>.BaseUnit, LapseRate<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.AstronomicalUnit, q => q.ToUnit(LengthUnit.AstronomicalUnit));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.AstronomicalUnit, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Centimeter, q => q.ToUnit(LengthUnit.Centimeter));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Centimeter, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Chain, q => q.ToUnit(LengthUnit.Chain));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Chain, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Decimeter, q => q.ToUnit(LengthUnit.Decimeter));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Decimeter, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.DtpPica, q => q.ToUnit(LengthUnit.DtpPica));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.DtpPica, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.DtpPoint, q => q.ToUnit(LengthUnit.DtpPoint));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.DtpPoint, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Fathom, q => q.ToUnit(LengthUnit.Fathom));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Fathom, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Foot, q => q.ToUnit(LengthUnit.Foot));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Foot, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Hand, q => q.ToUnit(LengthUnit.Hand));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Hand, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Hectometer, q => q.ToUnit(LengthUnit.Hectometer));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Hectometer, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Inch, q => q.ToUnit(LengthUnit.Inch));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Inch, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.KilolightYear, q => q.ToUnit(LengthUnit.KilolightYear));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.KilolightYear, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Kilometer, q => q.ToUnit(LengthUnit.Kilometer));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Kilometer, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Kiloparsec, q => q.ToUnit(LengthUnit.Kiloparsec));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Kiloparsec, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.LightYear, q => q.ToUnit(LengthUnit.LightYear));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.LightYear, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.MegalightYear, q => q.ToUnit(LengthUnit.MegalightYear));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.MegalightYear, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Megaparsec, q => q.ToUnit(LengthUnit.Megaparsec));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Megaparsec, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, Length<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Microinch, q => q.ToUnit(LengthUnit.Microinch));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Microinch, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Micrometer, q => q.ToUnit(LengthUnit.Micrometer));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Micrometer, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Mil, q => q.ToUnit(LengthUnit.Mil));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Mil, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Mile, q => q.ToUnit(LengthUnit.Mile));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Mile, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Millimeter, q => q.ToUnit(LengthUnit.Millimeter));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Millimeter, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Nanometer, q => q.ToUnit(LengthUnit.Nanometer));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Nanometer, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.NauticalMile, q => q.ToUnit(LengthUnit.NauticalMile));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.NauticalMile, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Parsec, q => q.ToUnit(LengthUnit.Parsec));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Parsec, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.PrinterPica, q => q.ToUnit(LengthUnit.PrinterPica));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.PrinterPica, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.PrinterPoint, q => q.ToUnit(LengthUnit.PrinterPoint));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.PrinterPoint, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Shackle, q => q.ToUnit(LengthUnit.Shackle));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Shackle, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.SolarRadius, q => q.ToUnit(LengthUnit.SolarRadius));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.SolarRadius, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Twip, q => q.ToUnit(LengthUnit.Twip));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Twip, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.UsSurveyFoot, q => q.ToUnit(LengthUnit.UsSurveyFoot));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.UsSurveyFoot, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Length<T>>(Length<T>.BaseUnit, LengthUnit.Yard, q => q.ToUnit(LengthUnit.Yard));
+            unitConverter.SetConversionFunction<Length<T>>(LengthUnit.Yard, Length<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Level<T>>(Level<T>.BaseUnit, Level<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Level<T>>(Level<T>.BaseUnit, LevelUnit.Neper, q => q.ToUnit(LevelUnit.Neper));
+            unitConverter.SetConversionFunction<Level<T>>(LevelUnit.Neper, Level<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.GramPerCentimeter, q => q.ToUnit(LinearDensityUnit.GramPerCentimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.GramPerCentimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.GramPerMeter, q => q.ToUnit(LinearDensityUnit.GramPerMeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.GramPerMeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.GramPerMillimeter, q => q.ToUnit(LinearDensityUnit.GramPerMillimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.GramPerMillimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.KilogramPerCentimeter, q => q.ToUnit(LinearDensityUnit.KilogramPerCentimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.KilogramPerCentimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.KilogramPerMillimeter, q => q.ToUnit(LinearDensityUnit.KilogramPerMillimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.KilogramPerMillimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.MicrogramPerCentimeter, q => q.ToUnit(LinearDensityUnit.MicrogramPerCentimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.MicrogramPerCentimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.MicrogramPerMeter, q => q.ToUnit(LinearDensityUnit.MicrogramPerMeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.MicrogramPerMeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.MicrogramPerMillimeter, q => q.ToUnit(LinearDensityUnit.MicrogramPerMillimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.MicrogramPerMillimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.MilligramPerCentimeter, q => q.ToUnit(LinearDensityUnit.MilligramPerCentimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.MilligramPerCentimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.MilligramPerMeter, q => q.ToUnit(LinearDensityUnit.MilligramPerMeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.MilligramPerMeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.MilligramPerMillimeter, q => q.ToUnit(LinearDensityUnit.MilligramPerMillimeter));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.MilligramPerMillimeter, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.PoundPerFoot, q => q.ToUnit(LinearDensityUnit.PoundPerFoot));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.PoundPerFoot, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensity<T>.BaseUnit, LinearDensityUnit.PoundPerInch, q => q.ToUnit(LinearDensityUnit.PoundPerInch));
+            unitConverter.SetConversionFunction<LinearDensity<T>>(LinearDensityUnit.PoundPerInch, LinearDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.GigawattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerCentimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.GigawattPerCentimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.GigawattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerFoot));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.GigawattPerFoot, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.GigawattPerInch, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerInch));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.GigawattPerInch, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.GigawattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerMeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.GigawattPerMeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.GigawattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerMillimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.GigawattPerMillimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.KilowattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerCentimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.KilowattPerCentimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.KilowattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerFoot));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.KilowattPerFoot, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.KilowattPerInch, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerInch));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.KilowattPerInch, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.KilowattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerMeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.KilowattPerMeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.KilowattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerMillimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.KilowattPerMillimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MegawattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerCentimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MegawattPerCentimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MegawattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerFoot));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MegawattPerFoot, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MegawattPerInch, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerInch));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MegawattPerInch, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MegawattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerMeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MegawattPerMeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MegawattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerMillimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MegawattPerMillimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MilliwattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerCentimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MilliwattPerCentimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MilliwattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerFoot));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MilliwattPerFoot, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MilliwattPerInch, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerInch));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MilliwattPerInch, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MilliwattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerMeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MilliwattPerMeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.MilliwattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerMillimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.MilliwattPerMillimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.WattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.WattPerCentimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.WattPerCentimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.WattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.WattPerFoot));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.WattPerFoot, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.WattPerInch, q => q.ToUnit(LinearPowerDensityUnit.WattPerInch));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.WattPerInch, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensity<T>.BaseUnit, LinearPowerDensityUnit.WattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.WattPerMillimeter));
+            unitConverter.SetConversionFunction<LinearPowerDensity<T>>(LinearPowerDensityUnit.WattPerMillimeter, LinearPowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Decawatt, q => q.ToUnit(LuminosityUnit.Decawatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Decawatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Deciwatt, q => q.ToUnit(LuminosityUnit.Deciwatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Deciwatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Femtowatt, q => q.ToUnit(LuminosityUnit.Femtowatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Femtowatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Gigawatt, q => q.ToUnit(LuminosityUnit.Gigawatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Gigawatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Kilowatt, q => q.ToUnit(LuminosityUnit.Kilowatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Kilowatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Megawatt, q => q.ToUnit(LuminosityUnit.Megawatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Megawatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Microwatt, q => q.ToUnit(LuminosityUnit.Microwatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Microwatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Milliwatt, q => q.ToUnit(LuminosityUnit.Milliwatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Milliwatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Nanowatt, q => q.ToUnit(LuminosityUnit.Nanowatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Nanowatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Petawatt, q => q.ToUnit(LuminosityUnit.Petawatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Petawatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Picowatt, q => q.ToUnit(LuminosityUnit.Picowatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Picowatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.SolarLuminosity, q => q.ToUnit(LuminosityUnit.SolarLuminosity));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.SolarLuminosity, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, LuminosityUnit.Terawatt, q => q.ToUnit(LuminosityUnit.Terawatt));
+            unitConverter.SetConversionFunction<Luminosity<T>>(LuminosityUnit.Terawatt, Luminosity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Luminosity<T>>(Luminosity<T>.BaseUnit, Luminosity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<LuminousFlux<T>>(LuminousFlux<T>.BaseUnit, LuminousFlux<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<LuminousIntensity<T>>(LuminousIntensity<T>.BaseUnit, LuminousIntensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticField<T>.BaseUnit, MagneticFieldUnit.Gauss, q => q.ToUnit(MagneticFieldUnit.Gauss));
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticFieldUnit.Gauss, MagneticField<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticField<T>.BaseUnit, MagneticFieldUnit.Microtesla, q => q.ToUnit(MagneticFieldUnit.Microtesla));
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticFieldUnit.Microtesla, MagneticField<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticField<T>.BaseUnit, MagneticFieldUnit.Millitesla, q => q.ToUnit(MagneticFieldUnit.Millitesla));
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticFieldUnit.Millitesla, MagneticField<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticField<T>.BaseUnit, MagneticFieldUnit.Nanotesla, q => q.ToUnit(MagneticFieldUnit.Nanotesla));
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticFieldUnit.Nanotesla, MagneticField<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MagneticField<T>>(MagneticField<T>.BaseUnit, MagneticField<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MagneticFlux<T>>(MagneticFlux<T>.BaseUnit, MagneticFlux<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Magnetization<T>>(Magnetization<T>.BaseUnit, Magnetization<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Centigram, q => q.ToUnit(MassUnit.Centigram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Centigram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Decagram, q => q.ToUnit(MassUnit.Decagram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Decagram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Decigram, q => q.ToUnit(MassUnit.Decigram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Decigram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.EarthMass, q => q.ToUnit(MassUnit.EarthMass));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.EarthMass, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Grain, q => q.ToUnit(MassUnit.Grain));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Grain, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Gram, q => q.ToUnit(MassUnit.Gram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Gram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Hectogram, q => q.ToUnit(MassUnit.Hectogram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Hectogram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, Mass<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Kilopound, q => q.ToUnit(MassUnit.Kilopound));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Kilopound, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Kilotonne, q => q.ToUnit(MassUnit.Kilotonne));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Kilotonne, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.LongHundredweight, q => q.ToUnit(MassUnit.LongHundredweight));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.LongHundredweight, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.LongTon, q => q.ToUnit(MassUnit.LongTon));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.LongTon, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Megapound, q => q.ToUnit(MassUnit.Megapound));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Megapound, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Megatonne, q => q.ToUnit(MassUnit.Megatonne));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Megatonne, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Microgram, q => q.ToUnit(MassUnit.Microgram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Microgram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Milligram, q => q.ToUnit(MassUnit.Milligram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Milligram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Nanogram, q => q.ToUnit(MassUnit.Nanogram));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Nanogram, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Ounce, q => q.ToUnit(MassUnit.Ounce));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Ounce, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Pound, q => q.ToUnit(MassUnit.Pound));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Pound, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.ShortHundredweight, q => q.ToUnit(MassUnit.ShortHundredweight));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.ShortHundredweight, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.ShortTon, q => q.ToUnit(MassUnit.ShortTon));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.ShortTon, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Slug, q => q.ToUnit(MassUnit.Slug));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Slug, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.SolarMass, q => q.ToUnit(MassUnit.SolarMass));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.SolarMass, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Stone, q => q.ToUnit(MassUnit.Stone));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Stone, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Mass<T>>(Mass<T>.BaseUnit, MassUnit.Tonne, q => q.ToUnit(MassUnit.Tonne));
+            unitConverter.SetConversionFunction<Mass<T>>(MassUnit.Tonne, Mass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.CentigramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.CentigramPerDeciliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.CentigramPerDeciliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.CentigramPerLiter, q => q.ToUnit(MassConcentrationUnit.CentigramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.CentigramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.CentigramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.CentigramPerMicroliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.CentigramPerMicroliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.CentigramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.CentigramPerMilliliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.CentigramPerMilliliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.DecigramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.DecigramPerDeciliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.DecigramPerDeciliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.DecigramPerLiter, q => q.ToUnit(MassConcentrationUnit.DecigramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.DecigramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.DecigramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.DecigramPerMicroliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.DecigramPerMicroliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.DecigramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.DecigramPerMilliliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.DecigramPerMilliliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.GramPerCubicCentimeter, q => q.ToUnit(MassConcentrationUnit.GramPerCubicCentimeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.GramPerCubicCentimeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.GramPerCubicMeter, q => q.ToUnit(MassConcentrationUnit.GramPerCubicMeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.GramPerCubicMeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.GramPerCubicMillimeter, q => q.ToUnit(MassConcentrationUnit.GramPerCubicMillimeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.GramPerCubicMillimeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.GramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.GramPerDeciliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.GramPerDeciliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.GramPerLiter, q => q.ToUnit(MassConcentrationUnit.GramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.GramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.GramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.GramPerMicroliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.GramPerMicroliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.GramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.GramPerMilliliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.GramPerMilliliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.KilogramPerCubicCentimeter, q => q.ToUnit(MassConcentrationUnit.KilogramPerCubicCentimeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.KilogramPerCubicCentimeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentration<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.KilogramPerCubicMillimeter, q => q.ToUnit(MassConcentrationUnit.KilogramPerCubicMillimeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.KilogramPerCubicMillimeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.KilogramPerLiter, q => q.ToUnit(MassConcentrationUnit.KilogramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.KilogramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.KilopoundPerCubicFoot, q => q.ToUnit(MassConcentrationUnit.KilopoundPerCubicFoot));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.KilopoundPerCubicFoot, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.KilopoundPerCubicInch, q => q.ToUnit(MassConcentrationUnit.KilopoundPerCubicInch));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.KilopoundPerCubicInch, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MicrogramPerCubicMeter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerCubicMeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MicrogramPerCubicMeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MicrogramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerDeciliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MicrogramPerDeciliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MicrogramPerLiter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MicrogramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MicrogramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerMicroliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MicrogramPerMicroliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MicrogramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.MicrogramPerMilliliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MicrogramPerMilliliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MilligramPerCubicMeter, q => q.ToUnit(MassConcentrationUnit.MilligramPerCubicMeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MilligramPerCubicMeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MilligramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.MilligramPerDeciliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MilligramPerDeciliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MilligramPerLiter, q => q.ToUnit(MassConcentrationUnit.MilligramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MilligramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MilligramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.MilligramPerMicroliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MilligramPerMicroliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.MilligramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.MilligramPerMilliliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.MilligramPerMilliliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.NanogramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.NanogramPerDeciliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.NanogramPerDeciliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.NanogramPerLiter, q => q.ToUnit(MassConcentrationUnit.NanogramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.NanogramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.NanogramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.NanogramPerMicroliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.NanogramPerMicroliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.NanogramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.NanogramPerMilliliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.NanogramPerMilliliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PicogramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.PicogramPerDeciliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PicogramPerDeciliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PicogramPerLiter, q => q.ToUnit(MassConcentrationUnit.PicogramPerLiter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PicogramPerLiter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PicogramPerMicroliter, q => q.ToUnit(MassConcentrationUnit.PicogramPerMicroliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PicogramPerMicroliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PicogramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.PicogramPerMilliliter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PicogramPerMilliliter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PoundPerCubicFoot, q => q.ToUnit(MassConcentrationUnit.PoundPerCubicFoot));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PoundPerCubicFoot, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PoundPerCubicInch, q => q.ToUnit(MassConcentrationUnit.PoundPerCubicInch));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PoundPerCubicInch, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PoundPerImperialGallon, q => q.ToUnit(MassConcentrationUnit.PoundPerImperialGallon));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PoundPerImperialGallon, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.PoundPerUSGallon, q => q.ToUnit(MassConcentrationUnit.PoundPerUSGallon));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.PoundPerUSGallon, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.SlugPerCubicFoot, q => q.ToUnit(MassConcentrationUnit.SlugPerCubicFoot));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.SlugPerCubicFoot, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.TonnePerCubicCentimeter, q => q.ToUnit(MassConcentrationUnit.TonnePerCubicCentimeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.TonnePerCubicCentimeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.TonnePerCubicMeter, q => q.ToUnit(MassConcentrationUnit.TonnePerCubicMeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.TonnePerCubicMeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentration<T>.BaseUnit, MassConcentrationUnit.TonnePerCubicMillimeter, q => q.ToUnit(MassConcentrationUnit.TonnePerCubicMillimeter));
+            unitConverter.SetConversionFunction<MassConcentration<T>>(MassConcentrationUnit.TonnePerCubicMillimeter, MassConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.CentigramPerDay, q => q.ToUnit(MassFlowUnit.CentigramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.CentigramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.CentigramPerSecond, q => q.ToUnit(MassFlowUnit.CentigramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.CentigramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.DecagramPerDay, q => q.ToUnit(MassFlowUnit.DecagramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.DecagramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.DecagramPerSecond, q => q.ToUnit(MassFlowUnit.DecagramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.DecagramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.DecigramPerDay, q => q.ToUnit(MassFlowUnit.DecigramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.DecigramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.DecigramPerSecond, q => q.ToUnit(MassFlowUnit.DecigramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.DecigramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.GramPerDay, q => q.ToUnit(MassFlowUnit.GramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.GramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.GramPerHour, q => q.ToUnit(MassFlowUnit.GramPerHour));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.GramPerHour, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlow<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.HectogramPerDay, q => q.ToUnit(MassFlowUnit.HectogramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.HectogramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.HectogramPerSecond, q => q.ToUnit(MassFlowUnit.HectogramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.HectogramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.KilogramPerDay, q => q.ToUnit(MassFlowUnit.KilogramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.KilogramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.KilogramPerHour, q => q.ToUnit(MassFlowUnit.KilogramPerHour));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.KilogramPerHour, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.KilogramPerMinute, q => q.ToUnit(MassFlowUnit.KilogramPerMinute));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.KilogramPerMinute, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.KilogramPerSecond, q => q.ToUnit(MassFlowUnit.KilogramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.KilogramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MegagramPerDay, q => q.ToUnit(MassFlowUnit.MegagramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MegagramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MegapoundPerDay, q => q.ToUnit(MassFlowUnit.MegapoundPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MegapoundPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MegapoundPerHour, q => q.ToUnit(MassFlowUnit.MegapoundPerHour));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MegapoundPerHour, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MegapoundPerMinute, q => q.ToUnit(MassFlowUnit.MegapoundPerMinute));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MegapoundPerMinute, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MegapoundPerSecond, q => q.ToUnit(MassFlowUnit.MegapoundPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MegapoundPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MicrogramPerDay, q => q.ToUnit(MassFlowUnit.MicrogramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MicrogramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MicrogramPerSecond, q => q.ToUnit(MassFlowUnit.MicrogramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MicrogramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MilligramPerDay, q => q.ToUnit(MassFlowUnit.MilligramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MilligramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.MilligramPerSecond, q => q.ToUnit(MassFlowUnit.MilligramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.MilligramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.NanogramPerDay, q => q.ToUnit(MassFlowUnit.NanogramPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.NanogramPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.NanogramPerSecond, q => q.ToUnit(MassFlowUnit.NanogramPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.NanogramPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.PoundPerDay, q => q.ToUnit(MassFlowUnit.PoundPerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.PoundPerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.PoundPerHour, q => q.ToUnit(MassFlowUnit.PoundPerHour));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.PoundPerHour, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.PoundPerMinute, q => q.ToUnit(MassFlowUnit.PoundPerMinute));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.PoundPerMinute, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.PoundPerSecond, q => q.ToUnit(MassFlowUnit.PoundPerSecond));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.PoundPerSecond, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.ShortTonPerHour, q => q.ToUnit(MassFlowUnit.ShortTonPerHour));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.ShortTonPerHour, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.TonnePerDay, q => q.ToUnit(MassFlowUnit.TonnePerDay));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.TonnePerDay, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlow<T>.BaseUnit, MassFlowUnit.TonnePerHour, q => q.ToUnit(MassFlowUnit.TonnePerHour));
+            unitConverter.SetConversionFunction<MassFlow<T>>(MassFlowUnit.TonnePerHour, MassFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.GramPerHourPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.GramPerHourPerSquareCentimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.GramPerHourPerSquareCentimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.GramPerHourPerSquareMeter, q => q.ToUnit(MassFluxUnit.GramPerHourPerSquareMeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.GramPerHourPerSquareMeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.GramPerHourPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.GramPerHourPerSquareMillimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.GramPerHourPerSquareMillimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.GramPerSecondPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.GramPerSecondPerSquareCentimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.GramPerSecondPerSquareCentimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMeter, q => q.ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.GramPerSecondPerSquareMeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.GramPerSecondPerSquareMillimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.GramPerSecondPerSquareMillimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.KilogramPerHourPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.KilogramPerHourPerSquareCentimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.KilogramPerHourPerSquareCentimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.KilogramPerHourPerSquareMeter, q => q.ToUnit(MassFluxUnit.KilogramPerHourPerSquareMeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.KilogramPerHourPerSquareMeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.KilogramPerHourPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.KilogramPerHourPerSquareMillimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.KilogramPerHourPerSquareMillimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.KilogramPerSecondPerSquareCentimeter, q => q.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareCentimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.KilogramPerSecondPerSquareCentimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFlux<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFlux<T>.BaseUnit, MassFluxUnit.KilogramPerSecondPerSquareMillimeter, q => q.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMillimeter));
+            unitConverter.SetConversionFunction<MassFlux<T>>(MassFluxUnit.KilogramPerSecondPerSquareMillimeter, MassFlux<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.CentigramPerGram, q => q.ToUnit(MassFractionUnit.CentigramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.CentigramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.CentigramPerKilogram, q => q.ToUnit(MassFractionUnit.CentigramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.CentigramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.DecagramPerGram, q => q.ToUnit(MassFractionUnit.DecagramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.DecagramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.DecagramPerKilogram, q => q.ToUnit(MassFractionUnit.DecagramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.DecagramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.DecigramPerGram, q => q.ToUnit(MassFractionUnit.DecigramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.DecigramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.DecigramPerKilogram, q => q.ToUnit(MassFractionUnit.DecigramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.DecigramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFraction<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.GramPerGram, q => q.ToUnit(MassFractionUnit.GramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.GramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.GramPerKilogram, q => q.ToUnit(MassFractionUnit.GramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.GramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.HectogramPerGram, q => q.ToUnit(MassFractionUnit.HectogramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.HectogramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.HectogramPerKilogram, q => q.ToUnit(MassFractionUnit.HectogramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.HectogramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.KilogramPerGram, q => q.ToUnit(MassFractionUnit.KilogramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.KilogramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.KilogramPerKilogram, q => q.ToUnit(MassFractionUnit.KilogramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.KilogramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.MicrogramPerGram, q => q.ToUnit(MassFractionUnit.MicrogramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.MicrogramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.MicrogramPerKilogram, q => q.ToUnit(MassFractionUnit.MicrogramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.MicrogramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.MilligramPerGram, q => q.ToUnit(MassFractionUnit.MilligramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.MilligramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.MilligramPerKilogram, q => q.ToUnit(MassFractionUnit.MilligramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.MilligramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.NanogramPerGram, q => q.ToUnit(MassFractionUnit.NanogramPerGram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.NanogramPerGram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.NanogramPerKilogram, q => q.ToUnit(MassFractionUnit.NanogramPerKilogram));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.NanogramPerKilogram, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.PartPerBillion, q => q.ToUnit(MassFractionUnit.PartPerBillion));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.PartPerBillion, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.PartPerMillion, q => q.ToUnit(MassFractionUnit.PartPerMillion));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.PartPerMillion, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.PartPerThousand, q => q.ToUnit(MassFractionUnit.PartPerThousand));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.PartPerThousand, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.PartPerTrillion, q => q.ToUnit(MassFractionUnit.PartPerTrillion));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.PartPerTrillion, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFraction<T>.BaseUnit, MassFractionUnit.Percent, q => q.ToUnit(MassFractionUnit.Percent));
+            unitConverter.SetConversionFunction<MassFraction<T>>(MassFractionUnit.Percent, MassFraction<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.GramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.GramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.GramSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareMeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.GramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertia<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMilimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMilimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.PoundSquareFoot, q => q.ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.PoundSquareInch, q => q.ToUnit(MassMomentOfInertiaUnit.PoundSquareInch));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.SlugSquareFoot, q => q.ToUnit(MassMomentOfInertiaUnit.SlugSquareFoot));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.SlugSquareInch, q => q.ToUnit(MassMomentOfInertiaUnit.SlugSquareInch));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.TonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.TonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertia<T>.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareMilimeter));
+            unitConverter.SetConversionFunction<MassMomentOfInertia<T>>(MassMomentOfInertiaUnit.TonneSquareMilimeter, MassMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarEnergy<T>>(MolarEnergy<T>.BaseUnit, MolarEnergy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MolarEnergy<T>>(MolarEnergy<T>.BaseUnit, MolarEnergyUnit.KilojoulePerMole, q => q.ToUnit(MolarEnergyUnit.KilojoulePerMole));
+            unitConverter.SetConversionFunction<MolarEnergy<T>>(MolarEnergyUnit.KilojoulePerMole, MolarEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarEnergy<T>>(MolarEnergy<T>.BaseUnit, MolarEnergyUnit.MegajoulePerMole, q => q.ToUnit(MolarEnergyUnit.MegajoulePerMole));
+            unitConverter.SetConversionFunction<MolarEnergy<T>>(MolarEnergyUnit.MegajoulePerMole, MolarEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarEntropy<T>>(MolarEntropy<T>.BaseUnit, MolarEntropy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MolarEntropy<T>>(MolarEntropy<T>.BaseUnit, MolarEntropyUnit.KilojoulePerMoleKelvin, q => q.ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin));
+            unitConverter.SetConversionFunction<MolarEntropy<T>>(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarEntropy<T>>(MolarEntropy<T>.BaseUnit, MolarEntropyUnit.MegajoulePerMoleKelvin, q => q.ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin));
+            unitConverter.SetConversionFunction<MolarEntropy<T>>(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, MolarityUnit.CentimolesPerLiter, q => q.ToUnit(MolarityUnit.CentimolesPerLiter));
+            unitConverter.SetConversionFunction<Molarity<T>>(MolarityUnit.CentimolesPerLiter, Molarity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, MolarityUnit.DecimolesPerLiter, q => q.ToUnit(MolarityUnit.DecimolesPerLiter));
+            unitConverter.SetConversionFunction<Molarity<T>>(MolarityUnit.DecimolesPerLiter, Molarity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, MolarityUnit.MicromolesPerLiter, q => q.ToUnit(MolarityUnit.MicromolesPerLiter));
+            unitConverter.SetConversionFunction<Molarity<T>>(MolarityUnit.MicromolesPerLiter, Molarity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, MolarityUnit.MillimolesPerLiter, q => q.ToUnit(MolarityUnit.MillimolesPerLiter));
+            unitConverter.SetConversionFunction<Molarity<T>>(MolarityUnit.MillimolesPerLiter, Molarity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, Molarity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, MolarityUnit.MolesPerLiter, q => q.ToUnit(MolarityUnit.MolesPerLiter));
+            unitConverter.SetConversionFunction<Molarity<T>>(MolarityUnit.MolesPerLiter, Molarity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, MolarityUnit.NanomolesPerLiter, q => q.ToUnit(MolarityUnit.NanomolesPerLiter));
+            unitConverter.SetConversionFunction<Molarity<T>>(MolarityUnit.NanomolesPerLiter, Molarity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Molarity<T>>(Molarity<T>.BaseUnit, MolarityUnit.PicomolesPerLiter, q => q.ToUnit(MolarityUnit.PicomolesPerLiter));
+            unitConverter.SetConversionFunction<Molarity<T>>(MolarityUnit.PicomolesPerLiter, Molarity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.CentigramPerMole, q => q.ToUnit(MolarMassUnit.CentigramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.CentigramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.DecagramPerMole, q => q.ToUnit(MolarMassUnit.DecagramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.DecagramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.DecigramPerMole, q => q.ToUnit(MolarMassUnit.DecigramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.DecigramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.GramPerMole, q => q.ToUnit(MolarMassUnit.GramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.GramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.HectogramPerMole, q => q.ToUnit(MolarMassUnit.HectogramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.HectogramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMass<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.KilopoundPerMole, q => q.ToUnit(MolarMassUnit.KilopoundPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.KilopoundPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.MegapoundPerMole, q => q.ToUnit(MolarMassUnit.MegapoundPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.MegapoundPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.MicrogramPerMole, q => q.ToUnit(MolarMassUnit.MicrogramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.MicrogramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.MilligramPerMole, q => q.ToUnit(MolarMassUnit.MilligramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.MilligramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.NanogramPerMole, q => q.ToUnit(MolarMassUnit.NanogramPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.NanogramPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMass<T>.BaseUnit, MolarMassUnit.PoundPerMole, q => q.ToUnit(MolarMassUnit.PoundPerMole));
+            unitConverter.SetConversionFunction<MolarMass<T>>(MolarMassUnit.PoundPerMole, MolarMass<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Permeability<T>>(Permeability<T>.BaseUnit, Permeability<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Permittivity<T>>(Permittivity<T>.BaseUnit, Permittivity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.BoilerHorsepower, q => q.ToUnit(PowerUnit.BoilerHorsepower));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.BoilerHorsepower, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.BritishThermalUnitPerHour, q => q.ToUnit(PowerUnit.BritishThermalUnitPerHour));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.BritishThermalUnitPerHour, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Decawatt, q => q.ToUnit(PowerUnit.Decawatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Decawatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Deciwatt, q => q.ToUnit(PowerUnit.Deciwatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Deciwatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.ElectricalHorsepower, q => q.ToUnit(PowerUnit.ElectricalHorsepower));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.ElectricalHorsepower, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Femtowatt, q => q.ToUnit(PowerUnit.Femtowatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Femtowatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.GigajoulePerHour, q => q.ToUnit(PowerUnit.GigajoulePerHour));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.GigajoulePerHour, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Gigawatt, q => q.ToUnit(PowerUnit.Gigawatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Gigawatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.HydraulicHorsepower, q => q.ToUnit(PowerUnit.HydraulicHorsepower));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.HydraulicHorsepower, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.JoulePerHour, q => q.ToUnit(PowerUnit.JoulePerHour));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.JoulePerHour, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.KilobritishThermalUnitPerHour, q => q.ToUnit(PowerUnit.KilobritishThermalUnitPerHour));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.KilobritishThermalUnitPerHour, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.KilojoulePerHour, q => q.ToUnit(PowerUnit.KilojoulePerHour));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.KilojoulePerHour, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Kilowatt, q => q.ToUnit(PowerUnit.Kilowatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Kilowatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.MechanicalHorsepower, q => q.ToUnit(PowerUnit.MechanicalHorsepower));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.MechanicalHorsepower, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.MegajoulePerHour, q => q.ToUnit(PowerUnit.MegajoulePerHour));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.MegajoulePerHour, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Megawatt, q => q.ToUnit(PowerUnit.Megawatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Megawatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.MetricHorsepower, q => q.ToUnit(PowerUnit.MetricHorsepower));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.MetricHorsepower, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Microwatt, q => q.ToUnit(PowerUnit.Microwatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Microwatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.MillijoulePerHour, q => q.ToUnit(PowerUnit.MillijoulePerHour));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.MillijoulePerHour, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Milliwatt, q => q.ToUnit(PowerUnit.Milliwatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Milliwatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Nanowatt, q => q.ToUnit(PowerUnit.Nanowatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Nanowatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Petawatt, q => q.ToUnit(PowerUnit.Petawatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Petawatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Picowatt, q => q.ToUnit(PowerUnit.Picowatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Picowatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, PowerUnit.Terawatt, q => q.ToUnit(PowerUnit.Terawatt));
+            unitConverter.SetConversionFunction<Power<T>>(PowerUnit.Terawatt, Power<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Power<T>>(Power<T>.BaseUnit, Power<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DecawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DecawattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DecawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DecawattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DecawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DecawattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DecawattPerLiter, q => q.ToUnit(PowerDensityUnit.DecawattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DecawattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DeciwattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DeciwattPerCubicInch, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DeciwattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DeciwattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.DeciwattPerLiter, q => q.ToUnit(PowerDensityUnit.DeciwattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.DeciwattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.GigawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.GigawattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.GigawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.GigawattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.GigawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.GigawattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.GigawattPerLiter, q => q.ToUnit(PowerDensityUnit.GigawattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.GigawattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.KilowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.KilowattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.KilowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.KilowattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.KilowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.KilowattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.KilowattPerLiter, q => q.ToUnit(PowerDensityUnit.KilowattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.KilowattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MegawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MegawattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MegawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MegawattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MegawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MegawattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MegawattPerLiter, q => q.ToUnit(PowerDensityUnit.MegawattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MegawattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MicrowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MicrowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MicrowattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MicrowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MicrowattPerLiter, q => q.ToUnit(PowerDensityUnit.MicrowattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MicrowattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MilliwattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MilliwattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MilliwattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MilliwattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.MilliwattPerLiter, q => q.ToUnit(PowerDensityUnit.MilliwattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.MilliwattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.NanowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.NanowattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.NanowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.NanowattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.NanowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.NanowattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.NanowattPerLiter, q => q.ToUnit(PowerDensityUnit.NanowattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.NanowattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.PicowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.PicowattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.PicowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.PicowattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.PicowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.PicowattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.PicowattPerLiter, q => q.ToUnit(PowerDensityUnit.PicowattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.PicowattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.TerawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.TerawattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.TerawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.TerawattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.TerawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicMeter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.TerawattPerCubicMeter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.TerawattPerLiter, q => q.ToUnit(PowerDensityUnit.TerawattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.TerawattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.WattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.WattPerCubicFoot));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.WattPerCubicFoot, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.WattPerCubicInch, q => q.ToUnit(PowerDensityUnit.WattPerCubicInch));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.WattPerCubicInch, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensity<T>.BaseUnit, PowerDensityUnit.WattPerLiter, q => q.ToUnit(PowerDensityUnit.WattPerLiter));
+            unitConverter.SetConversionFunction<PowerDensity<T>>(PowerDensityUnit.WattPerLiter, PowerDensity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerRatio<T>>(PowerRatio<T>.BaseUnit, PowerRatioUnit.DecibelMilliwatt, q => q.ToUnit(PowerRatioUnit.DecibelMilliwatt));
+            unitConverter.SetConversionFunction<PowerRatio<T>>(PowerRatioUnit.DecibelMilliwatt, PowerRatio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PowerRatio<T>>(PowerRatio<T>.BaseUnit, PowerRatio<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Atmosphere, q => q.ToUnit(PressureUnit.Atmosphere));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Atmosphere, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Bar, q => q.ToUnit(PressureUnit.Bar));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Bar, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Centibar, q => q.ToUnit(PressureUnit.Centibar));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Centibar, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Decapascal, q => q.ToUnit(PressureUnit.Decapascal));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Decapascal, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Decibar, q => q.ToUnit(PressureUnit.Decibar));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Decibar, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.DynePerSquareCentimeter, q => q.ToUnit(PressureUnit.DynePerSquareCentimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.DynePerSquareCentimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.FootOfHead, q => q.ToUnit(PressureUnit.FootOfHead));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.FootOfHead, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Gigapascal, q => q.ToUnit(PressureUnit.Gigapascal));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Gigapascal, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Hectopascal, q => q.ToUnit(PressureUnit.Hectopascal));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Hectopascal, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.InchOfMercury, q => q.ToUnit(PressureUnit.InchOfMercury));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.InchOfMercury, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.InchOfWaterColumn, q => q.ToUnit(PressureUnit.InchOfWaterColumn));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.InchOfWaterColumn, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Kilobar, q => q.ToUnit(PressureUnit.Kilobar));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Kilobar, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilogramForcePerSquareCentimeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareCentimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilogramForcePerSquareCentimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilogramForcePerSquareMeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareMeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilogramForcePerSquareMeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilogramForcePerSquareMillimeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareMillimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilogramForcePerSquareMillimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilonewtonPerSquareCentimeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilonewtonPerSquareCentimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilonewtonPerSquareMeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareMeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilonewtonPerSquareMeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilonewtonPerSquareMillimeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareMillimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilonewtonPerSquareMillimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Kilopascal, q => q.ToUnit(PressureUnit.Kilopascal));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Kilopascal, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilopoundForcePerSquareFoot, q => q.ToUnit(PressureUnit.KilopoundForcePerSquareFoot));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilopoundForcePerSquareFoot, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.KilopoundForcePerSquareInch, q => q.ToUnit(PressureUnit.KilopoundForcePerSquareInch));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.KilopoundForcePerSquareInch, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Megabar, q => q.ToUnit(PressureUnit.Megabar));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Megabar, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.MeganewtonPerSquareMeter, q => q.ToUnit(PressureUnit.MeganewtonPerSquareMeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.MeganewtonPerSquareMeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Megapascal, q => q.ToUnit(PressureUnit.Megapascal));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Megapascal, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.MeterOfHead, q => q.ToUnit(PressureUnit.MeterOfHead));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.MeterOfHead, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Microbar, q => q.ToUnit(PressureUnit.Microbar));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Microbar, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Micropascal, q => q.ToUnit(PressureUnit.Micropascal));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Micropascal, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Millibar, q => q.ToUnit(PressureUnit.Millibar));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Millibar, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.MillimeterOfMercury, q => q.ToUnit(PressureUnit.MillimeterOfMercury));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.MillimeterOfMercury, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Millipascal, q => q.ToUnit(PressureUnit.Millipascal));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Millipascal, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.NewtonPerSquareCentimeter, q => q.ToUnit(PressureUnit.NewtonPerSquareCentimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.NewtonPerSquareCentimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.NewtonPerSquareMeter, q => q.ToUnit(PressureUnit.NewtonPerSquareMeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.NewtonPerSquareMeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.NewtonPerSquareMillimeter, q => q.ToUnit(PressureUnit.NewtonPerSquareMillimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.NewtonPerSquareMillimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, Pressure<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.PoundForcePerSquareFoot, q => q.ToUnit(PressureUnit.PoundForcePerSquareFoot));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.PoundForcePerSquareFoot, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.PoundForcePerSquareInch, q => q.ToUnit(PressureUnit.PoundForcePerSquareInch));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.PoundForcePerSquareInch, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.PoundPerInchSecondSquared, q => q.ToUnit(PressureUnit.PoundPerInchSecondSquared));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.PoundPerInchSecondSquared, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.TechnicalAtmosphere, q => q.ToUnit(PressureUnit.TechnicalAtmosphere));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.TechnicalAtmosphere, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.TonneForcePerSquareCentimeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareCentimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.TonneForcePerSquareCentimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.TonneForcePerSquareMeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareMeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.TonneForcePerSquareMeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.TonneForcePerSquareMillimeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareMillimeter));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.TonneForcePerSquareMillimeter, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Pressure<T>>(Pressure<T>.BaseUnit, PressureUnit.Torr, q => q.ToUnit(PressureUnit.Torr));
+            unitConverter.SetConversionFunction<Pressure<T>>(PressureUnit.Torr, Pressure<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRate<T>.BaseUnit, PressureChangeRateUnit.AtmospherePerSecond, q => q.ToUnit(PressureChangeRateUnit.AtmospherePerSecond));
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRate<T>.BaseUnit, PressureChangeRateUnit.KilopascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.KilopascalPerMinute));
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRate<T>.BaseUnit, PressureChangeRateUnit.KilopascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.KilopascalPerSecond));
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRate<T>.BaseUnit, PressureChangeRateUnit.MegapascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerMinute));
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRate<T>.BaseUnit, PressureChangeRateUnit.MegapascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerSecond));
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRate<T>.BaseUnit, PressureChangeRateUnit.PascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.PascalPerMinute));
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<PressureChangeRate<T>>(PressureChangeRate<T>.BaseUnit, PressureChangeRate<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Ratio<T>>(Ratio<T>.BaseUnit, Ratio<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Ratio<T>>(Ratio<T>.BaseUnit, RatioUnit.PartPerBillion, q => q.ToUnit(RatioUnit.PartPerBillion));
+            unitConverter.SetConversionFunction<Ratio<T>>(RatioUnit.PartPerBillion, Ratio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Ratio<T>>(Ratio<T>.BaseUnit, RatioUnit.PartPerMillion, q => q.ToUnit(RatioUnit.PartPerMillion));
+            unitConverter.SetConversionFunction<Ratio<T>>(RatioUnit.PartPerMillion, Ratio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Ratio<T>>(Ratio<T>.BaseUnit, RatioUnit.PartPerThousand, q => q.ToUnit(RatioUnit.PartPerThousand));
+            unitConverter.SetConversionFunction<Ratio<T>>(RatioUnit.PartPerThousand, Ratio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Ratio<T>>(Ratio<T>.BaseUnit, RatioUnit.PartPerTrillion, q => q.ToUnit(RatioUnit.PartPerTrillion));
+            unitConverter.SetConversionFunction<Ratio<T>>(RatioUnit.PartPerTrillion, Ratio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Ratio<T>>(Ratio<T>.BaseUnit, RatioUnit.Percent, q => q.ToUnit(RatioUnit.Percent));
+            unitConverter.SetConversionFunction<Ratio<T>>(RatioUnit.Percent, Ratio<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RatioChangeRate<T>>(RatioChangeRate<T>.BaseUnit, RatioChangeRate<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RatioChangeRate<T>>(RatioChangeRate<T>.BaseUnit, RatioChangeRateUnit.PercentPerSecond, q => q.ToUnit(RatioChangeRateUnit.PercentPerSecond));
+            unitConverter.SetConversionFunction<RatioChangeRate<T>>(RatioChangeRateUnit.PercentPerSecond, RatioChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ReactiveEnergy<T>>(ReactiveEnergy<T>.BaseUnit, ReactiveEnergyUnit.KilovoltampereReactiveHour, q => q.ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour));
+            unitConverter.SetConversionFunction<ReactiveEnergy<T>>(ReactiveEnergyUnit.KilovoltampereReactiveHour, ReactiveEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ReactiveEnergy<T>>(ReactiveEnergy<T>.BaseUnit, ReactiveEnergyUnit.MegavoltampereReactiveHour, q => q.ToUnit(ReactiveEnergyUnit.MegavoltampereReactiveHour));
+            unitConverter.SetConversionFunction<ReactiveEnergy<T>>(ReactiveEnergyUnit.MegavoltampereReactiveHour, ReactiveEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ReactiveEnergy<T>>(ReactiveEnergy<T>.BaseUnit, ReactiveEnergy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ReactivePower<T>>(ReactivePower<T>.BaseUnit, ReactivePowerUnit.GigavoltampereReactive, q => q.ToUnit(ReactivePowerUnit.GigavoltampereReactive));
+            unitConverter.SetConversionFunction<ReactivePower<T>>(ReactivePowerUnit.GigavoltampereReactive, ReactivePower<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ReactivePower<T>>(ReactivePower<T>.BaseUnit, ReactivePowerUnit.KilovoltampereReactive, q => q.ToUnit(ReactivePowerUnit.KilovoltampereReactive));
+            unitConverter.SetConversionFunction<ReactivePower<T>>(ReactivePowerUnit.KilovoltampereReactive, ReactivePower<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ReactivePower<T>>(ReactivePower<T>.BaseUnit, ReactivePowerUnit.MegavoltampereReactive, q => q.ToUnit(ReactivePowerUnit.MegavoltampereReactive));
+            unitConverter.SetConversionFunction<ReactivePower<T>>(ReactivePowerUnit.MegavoltampereReactive, ReactivePower<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ReactivePower<T>>(ReactivePower<T>.BaseUnit, ReactivePower<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RelativeHumidity<T>>(RelativeHumidity<T>.BaseUnit, RelativeHumidity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RotationalAcceleration<T>>(RotationalAcceleration<T>.BaseUnit, RotationalAccelerationUnit.DegreePerSecondSquared, q => q.ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared));
+            unitConverter.SetConversionFunction<RotationalAcceleration<T>>(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAcceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalAcceleration<T>>(RotationalAcceleration<T>.BaseUnit, RotationalAcceleration<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RotationalAcceleration<T>>(RotationalAcceleration<T>.BaseUnit, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, q => q.ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond));
+            unitConverter.SetConversionFunction<RotationalAcceleration<T>>(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalAcceleration<T>>(RotationalAcceleration<T>.BaseUnit, RotationalAccelerationUnit.RevolutionPerSecondSquared, q => q.ToUnit(RotationalAccelerationUnit.RevolutionPerSecondSquared));
+            unitConverter.SetConversionFunction<RotationalAcceleration<T>>(RotationalAccelerationUnit.RevolutionPerSecondSquared, RotationalAcceleration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.CentiradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.CentiradianPerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.DeciradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.DeciradianPerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.DegreePerMinute, q => q.ToUnit(RotationalSpeedUnit.DegreePerMinute));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.DegreePerMinute, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.DegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.DegreePerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.DegreePerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.MicrodegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.MicrodegreePerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.MicroradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.MicroradianPerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.MillidegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.MillidegreePerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.MilliradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.MilliradianPerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.NanodegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.NanodegreePerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.NanoradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.NanoradianPerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeed<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.RevolutionPerMinute, q => q.ToUnit(RotationalSpeedUnit.RevolutionPerMinute));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeed<T>.BaseUnit, RotationalSpeedUnit.RevolutionPerSecond, q => q.ToUnit(RotationalSpeedUnit.RevolutionPerSecond));
+            unitConverter.SetConversionFunction<RotationalSpeed<T>>(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.CentinewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.CentinewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.CentinewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.DecanewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecanewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.DecanewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.DecinewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecinewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.DecinewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.KilonewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.KilopoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerDegrees));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MeganewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MicronewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MicronewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MicronewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MillinewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MillinewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MillinewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.NanonewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NanonewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.NanonewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.NewtonMeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NewtonMeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.NewtonMeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffness<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.NewtonMillimeterPerDegree, q => q.ToUnit(RotationalStiffnessUnit.NewtonMillimeterPerDegree));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.NewtonMillimeterPerDegree, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.NewtonMillimeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.NewtonMillimeterPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.NewtonMillimeterPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.PoundForceFeetPerRadian, q => q.ToUnit(RotationalStiffnessUnit.PoundForceFeetPerRadian));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.PoundForceFeetPerRadian, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffness<T>.BaseUnit, RotationalStiffnessUnit.PoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.PoundForceFootPerDegrees));
+            unitConverter.SetConversionFunction<RotationalStiffness<T>>(RotationalStiffnessUnit.PoundForceFootPerDegrees, RotationalStiffness<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLength<T>.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter));
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLength<T>.BaseUnit, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, q => q.ToUnit(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot));
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLength<T>.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter));
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLength<T>.BaseUnit, RotationalStiffnessPerLength<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLength<T>.BaseUnit, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, q => q.ToUnit(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot));
+            unitConverter.SetConversionFunction<RotationalStiffnessPerLength<T>>(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SolidAngle<T>>(SolidAngle<T>.BaseUnit, SolidAngle<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.BtuPerPound, q => q.ToUnit(SpecificEnergyUnit.BtuPerPound));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.BtuPerPound, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.CaloriePerGram, q => q.ToUnit(SpecificEnergyUnit.CaloriePerGram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.CaloriePerGram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.GigawattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.GigawattDayPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.GigawattDayPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.GigawattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.GigawattDayPerShortTon));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.GigawattDayPerShortTon, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.GigawattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.GigawattDayPerTonne));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.GigawattDayPerTonne, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.GigawattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.GigawattHourPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.GigawattHourPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.KilocaloriePerGram, q => q.ToUnit(SpecificEnergyUnit.KilocaloriePerGram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.KilojoulePerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilojoulePerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.KilowattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilowattDayPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.KilowattDayPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.KilowattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.KilowattDayPerShortTon));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.KilowattDayPerShortTon, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.KilowattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.KilowattDayPerTonne));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.KilowattDayPerTonne, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.KilowattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.MegajoulePerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegajoulePerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.MegawattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegawattDayPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.MegawattDayPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.MegawattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.MegawattDayPerShortTon));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.MegawattDayPerShortTon, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.MegawattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.MegawattDayPerTonne));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.MegawattDayPerTonne, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.MegawattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.TerawattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.TerawattDayPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.TerawattDayPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.TerawattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.TerawattDayPerShortTon));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.TerawattDayPerShortTon, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.TerawattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.TerawattDayPerTonne));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.TerawattDayPerTonne, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.WattDayPerKilogram, q => q.ToUnit(SpecificEnergyUnit.WattDayPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.WattDayPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.WattDayPerShortTon, q => q.ToUnit(SpecificEnergyUnit.WattDayPerShortTon));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.WattDayPerShortTon, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.WattDayPerTonne, q => q.ToUnit(SpecificEnergyUnit.WattDayPerTonne));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.WattDayPerTonne, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergy<T>.BaseUnit, SpecificEnergyUnit.WattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.WattHourPerKilogram));
+            unitConverter.SetConversionFunction<SpecificEnergy<T>>(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.BtuPerPoundFahrenheit, q => q.ToUnit(SpecificEntropyUnit.BtuPerPoundFahrenheit));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.BtuPerPoundFahrenheit, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.CaloriePerGramKelvin, q => q.ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropy<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.KilocaloriePerGramKelvin, q => q.ToUnit(SpecificEntropyUnit.KilocaloriePerGramKelvin));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramKelvin, q => q.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramKelvin));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropy<T>.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramKelvin, q => q.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramKelvin));
+            unitConverter.SetConversionFunction<SpecificEntropy<T>>(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropy<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificVolume<T>>(SpecificVolume<T>.BaseUnit, SpecificVolumeUnit.CubicFootPerPound, q => q.ToUnit(SpecificVolumeUnit.CubicFootPerPound));
+            unitConverter.SetConversionFunction<SpecificVolume<T>>(SpecificVolumeUnit.CubicFootPerPound, SpecificVolume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificVolume<T>>(SpecificVolume<T>.BaseUnit, SpecificVolume<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<SpecificVolume<T>>(SpecificVolume<T>.BaseUnit, SpecificVolumeUnit.MillicubicMeterPerKilogram, q => q.ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram));
+            unitConverter.SetConversionFunction<SpecificVolume<T>>(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMillimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicCentimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMillimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicFoot, q => q.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicFoot));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicInch, q => q.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicInch));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.MeganewtonPerCubicMeter, q => q.ToUnit(SpecificWeightUnit.MeganewtonPerCubicMeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.NewtonPerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.NewtonPerCubicCentimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeight<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.NewtonPerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.NewtonPerCubicMillimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.PoundForcePerCubicFoot, q => q.ToUnit(SpecificWeightUnit.PoundForcePerCubicFoot));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.PoundForcePerCubicInch, q => q.ToUnit(SpecificWeightUnit.PoundForcePerCubicInch));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.TonneForcePerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicCentimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicMeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeight<T>.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicMillimeter));
+            unitConverter.SetConversionFunction<SpecificWeight<T>>(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeight<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.CentimeterPerHour, q => q.ToUnit(SpeedUnit.CentimeterPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.CentimeterPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.CentimeterPerMinute, q => q.ToUnit(SpeedUnit.CentimeterPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.CentimeterPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.CentimeterPerSecond, q => q.ToUnit(SpeedUnit.CentimeterPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.CentimeterPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.DecimeterPerMinute, q => q.ToUnit(SpeedUnit.DecimeterPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.DecimeterPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.DecimeterPerSecond, q => q.ToUnit(SpeedUnit.DecimeterPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.DecimeterPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.FootPerHour, q => q.ToUnit(SpeedUnit.FootPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.FootPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.FootPerMinute, q => q.ToUnit(SpeedUnit.FootPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.FootPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.FootPerSecond, q => q.ToUnit(SpeedUnit.FootPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.FootPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.InchPerHour, q => q.ToUnit(SpeedUnit.InchPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.InchPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.InchPerMinute, q => q.ToUnit(SpeedUnit.InchPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.InchPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.InchPerSecond, q => q.ToUnit(SpeedUnit.InchPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.InchPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.KilometerPerHour, q => q.ToUnit(SpeedUnit.KilometerPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.KilometerPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.KilometerPerMinute, q => q.ToUnit(SpeedUnit.KilometerPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.KilometerPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.KilometerPerSecond, q => q.ToUnit(SpeedUnit.KilometerPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.KilometerPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.Knot, q => q.ToUnit(SpeedUnit.Knot));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.Knot, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MeterPerHour, q => q.ToUnit(SpeedUnit.MeterPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MeterPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MeterPerMinute, q => q.ToUnit(SpeedUnit.MeterPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MeterPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, Speed<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MicrometerPerMinute, q => q.ToUnit(SpeedUnit.MicrometerPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MicrometerPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MicrometerPerSecond, q => q.ToUnit(SpeedUnit.MicrometerPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MicrometerPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MilePerHour, q => q.ToUnit(SpeedUnit.MilePerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MilePerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MillimeterPerHour, q => q.ToUnit(SpeedUnit.MillimeterPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MillimeterPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MillimeterPerMinute, q => q.ToUnit(SpeedUnit.MillimeterPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MillimeterPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.MillimeterPerSecond, q => q.ToUnit(SpeedUnit.MillimeterPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.MillimeterPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.NanometerPerMinute, q => q.ToUnit(SpeedUnit.NanometerPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.NanometerPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.NanometerPerSecond, q => q.ToUnit(SpeedUnit.NanometerPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.NanometerPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.UsSurveyFootPerHour, q => q.ToUnit(SpeedUnit.UsSurveyFootPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.UsSurveyFootPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.UsSurveyFootPerMinute, q => q.ToUnit(SpeedUnit.UsSurveyFootPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.UsSurveyFootPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.UsSurveyFootPerSecond, q => q.ToUnit(SpeedUnit.UsSurveyFootPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.UsSurveyFootPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.YardPerHour, q => q.ToUnit(SpeedUnit.YardPerHour));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.YardPerHour, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.YardPerMinute, q => q.ToUnit(SpeedUnit.YardPerMinute));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.YardPerMinute, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Speed<T>>(Speed<T>.BaseUnit, SpeedUnit.YardPerSecond, q => q.ToUnit(SpeedUnit.YardPerSecond));
+            unitConverter.SetConversionFunction<Speed<T>>(SpeedUnit.YardPerSecond, Speed<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.DegreeCelsius, q => q.ToUnit(TemperatureUnit.DegreeCelsius));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.DegreeCelsius, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.DegreeDelisle, q => q.ToUnit(TemperatureUnit.DegreeDelisle));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.DegreeDelisle, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.DegreeFahrenheit, q => q.ToUnit(TemperatureUnit.DegreeFahrenheit));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.DegreeFahrenheit, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.DegreeNewton, q => q.ToUnit(TemperatureUnit.DegreeNewton));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.DegreeNewton, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.DegreeRankine, q => q.ToUnit(TemperatureUnit.DegreeRankine));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.DegreeRankine, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.DegreeReaumur, q => q.ToUnit(TemperatureUnit.DegreeReaumur));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.DegreeReaumur, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.DegreeRoemer, q => q.ToUnit(TemperatureUnit.DegreeRoemer));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.DegreeRoemer, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, Temperature<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.MillidegreeCelsius, q => q.ToUnit(TemperatureUnit.MillidegreeCelsius));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.MillidegreeCelsius, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Temperature<T>>(Temperature<T>.BaseUnit, TemperatureUnit.SolarTemperature, q => q.ToUnit(TemperatureUnit.SolarTemperature));
+            unitConverter.SetConversionFunction<Temperature<T>>(TemperatureUnit.SolarTemperature, Temperature<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.DegreeCelsiusPerMinute, q => q.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerMinute));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRate<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRate<T>.BaseUnit, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond));
+            unitConverter.SetConversionFunction<TemperatureChangeRate<T>>(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRate<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.DegreeCelsius, q => q.ToUnit(TemperatureDeltaUnit.DegreeCelsius));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.DegreeCelsius, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.DegreeDelisle, q => q.ToUnit(TemperatureDeltaUnit.DegreeDelisle));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.DegreeDelisle, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.DegreeFahrenheit, q => q.ToUnit(TemperatureDeltaUnit.DegreeFahrenheit));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.DegreeNewton, q => q.ToUnit(TemperatureDeltaUnit.DegreeNewton));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.DegreeNewton, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.DegreeRankine, q => q.ToUnit(TemperatureDeltaUnit.DegreeRankine));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.DegreeRankine, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.DegreeReaumur, q => q.ToUnit(TemperatureDeltaUnit.DegreeReaumur));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.DegreeReaumur, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.DegreeRoemer, q => q.ToUnit(TemperatureDeltaUnit.DegreeRoemer));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.DegreeRoemer, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDelta<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDelta<T>.BaseUnit, TemperatureDeltaUnit.MillidegreeCelsius, q => q.ToUnit(TemperatureDeltaUnit.MillidegreeCelsius));
+            unitConverter.SetConversionFunction<TemperatureDelta<T>>(TemperatureDeltaUnit.MillidegreeCelsius, TemperatureDelta<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ThermalConductivity<T>>(ThermalConductivity<T>.BaseUnit, ThermalConductivityUnit.BtuPerHourFootFahrenheit, q => q.ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit));
+            unitConverter.SetConversionFunction<ThermalConductivity<T>>(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivity<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ThermalConductivity<T>>(ThermalConductivity<T>.BaseUnit, ThermalConductivity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistance<T>.BaseUnit, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, q => q.ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu));
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistance<T>.BaseUnit, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, q => q.ToUnit(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie));
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistance<T>.BaseUnit, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, q => q.ToUnit(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt));
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, ThermalResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistance<T>.BaseUnit, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, q => q.ToUnit(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt));
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalResistance<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<ThermalResistance<T>>(ThermalResistance<T>.BaseUnit, ThermalResistance<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilogramForceCentimeter, q => q.ToUnit(TorqueUnit.KilogramForceCentimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilogramForceCentimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilogramForceMeter, q => q.ToUnit(TorqueUnit.KilogramForceMeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilogramForceMeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilogramForceMillimeter, q => q.ToUnit(TorqueUnit.KilogramForceMillimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilogramForceMillimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilonewtonCentimeter, q => q.ToUnit(TorqueUnit.KilonewtonCentimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilonewtonCentimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilonewtonMeter, q => q.ToUnit(TorqueUnit.KilonewtonMeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilonewtonMeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilonewtonMillimeter, q => q.ToUnit(TorqueUnit.KilonewtonMillimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilonewtonMillimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilopoundForceFoot, q => q.ToUnit(TorqueUnit.KilopoundForceFoot));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilopoundForceFoot, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.KilopoundForceInch, q => q.ToUnit(TorqueUnit.KilopoundForceInch));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.KilopoundForceInch, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.MeganewtonCentimeter, q => q.ToUnit(TorqueUnit.MeganewtonCentimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.MeganewtonCentimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.MeganewtonMeter, q => q.ToUnit(TorqueUnit.MeganewtonMeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.MeganewtonMeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.MeganewtonMillimeter, q => q.ToUnit(TorqueUnit.MeganewtonMillimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.MeganewtonMillimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.MegapoundForceFoot, q => q.ToUnit(TorqueUnit.MegapoundForceFoot));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.MegapoundForceFoot, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.MegapoundForceInch, q => q.ToUnit(TorqueUnit.MegapoundForceInch));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.MegapoundForceInch, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.NewtonCentimeter, q => q.ToUnit(TorqueUnit.NewtonCentimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.NewtonCentimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, Torque<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.NewtonMillimeter, q => q.ToUnit(TorqueUnit.NewtonMillimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.NewtonMillimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.PoundalFoot, q => q.ToUnit(TorqueUnit.PoundalFoot));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.PoundalFoot, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.PoundForceFoot, q => q.ToUnit(TorqueUnit.PoundForceFoot));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.PoundForceFoot, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.PoundForceInch, q => q.ToUnit(TorqueUnit.PoundForceInch));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.PoundForceInch, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.TonneForceCentimeter, q => q.ToUnit(TorqueUnit.TonneForceCentimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.TonneForceCentimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.TonneForceMeter, q => q.ToUnit(TorqueUnit.TonneForceMeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.TonneForceMeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Torque<T>>(Torque<T>.BaseUnit, TorqueUnit.TonneForceMillimeter, q => q.ToUnit(TorqueUnit.TonneForceMillimeter));
+            unitConverter.SetConversionFunction<Torque<T>>(TorqueUnit.TonneForceMillimeter, Torque<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilogramForceCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilogramForceCentimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilogramForceCentimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilogramForceMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilogramForceMeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilogramForceMeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilogramForceMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilogramForceMillimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilogramForceMillimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilonewtonCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilonewtonCentimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilonewtonCentimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilonewtonMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilonewtonMeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilonewtonMeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilonewtonMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.KilonewtonMillimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilonewtonMillimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilopoundForceFootPerFoot, q => q.ToUnit(TorquePerLengthUnit.KilopoundForceFootPerFoot));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilopoundForceFootPerFoot, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.KilopoundForceInchPerFoot, q => q.ToUnit(TorquePerLengthUnit.KilopoundForceInchPerFoot));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.KilopoundForceInchPerFoot, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.MeganewtonCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.MeganewtonCentimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.MeganewtonCentimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.MeganewtonMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.MeganewtonMeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.MeganewtonMeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.MeganewtonMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.MeganewtonMillimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.MeganewtonMillimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.MegapoundForceFootPerFoot, q => q.ToUnit(TorquePerLengthUnit.MegapoundForceFootPerFoot));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.MegapoundForceFootPerFoot, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.MegapoundForceInchPerFoot, q => q.ToUnit(TorquePerLengthUnit.MegapoundForceInchPerFoot));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.MegapoundForceInchPerFoot, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.NewtonCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.NewtonCentimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.NewtonCentimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLength<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.NewtonMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.NewtonMillimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.NewtonMillimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.PoundForceFootPerFoot, q => q.ToUnit(TorquePerLengthUnit.PoundForceFootPerFoot));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.PoundForceFootPerFoot, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.PoundForceInchPerFoot, q => q.ToUnit(TorquePerLengthUnit.PoundForceInchPerFoot));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.PoundForceInchPerFoot, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.TonneForceCentimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.TonneForceCentimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.TonneForceCentimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.TonneForceMeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.TonneForceMeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.TonneForceMeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLength<T>.BaseUnit, TorquePerLengthUnit.TonneForceMillimeterPerMeter, q => q.ToUnit(TorquePerLengthUnit.TonneForceMillimeterPerMeter));
+            unitConverter.SetConversionFunction<TorquePerLength<T>>(TorquePerLengthUnit.TonneForceMillimeterPerMeter, TorquePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Turbidity<T>>(Turbidity<T>.BaseUnit, Turbidity<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<VitaminA<T>>(VitaminA<T>.BaseUnit, VitaminA<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.AcreFoot, q => q.ToUnit(VolumeUnit.AcreFoot));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.AcreFoot, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.AuTablespoon, q => q.ToUnit(VolumeUnit.AuTablespoon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.AuTablespoon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.BoardFoot, q => q.ToUnit(VolumeUnit.BoardFoot));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.BoardFoot, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Centiliter, q => q.ToUnit(VolumeUnit.Centiliter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Centiliter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicCentimeter, q => q.ToUnit(VolumeUnit.CubicCentimeter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicCentimeter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicDecimeter, q => q.ToUnit(VolumeUnit.CubicDecimeter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicDecimeter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicFoot, q => q.ToUnit(VolumeUnit.CubicFoot));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicFoot, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicHectometer, q => q.ToUnit(VolumeUnit.CubicHectometer));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicHectometer, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicInch, q => q.ToUnit(VolumeUnit.CubicInch));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicInch, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicKilometer, q => q.ToUnit(VolumeUnit.CubicKilometer));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicKilometer, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, Volume<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicMicrometer, q => q.ToUnit(VolumeUnit.CubicMicrometer));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicMicrometer, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicMile, q => q.ToUnit(VolumeUnit.CubicMile));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicMile, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicMillimeter, q => q.ToUnit(VolumeUnit.CubicMillimeter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicMillimeter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.CubicYard, q => q.ToUnit(VolumeUnit.CubicYard));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.CubicYard, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.DecausGallon, q => q.ToUnit(VolumeUnit.DecausGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.DecausGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Deciliter, q => q.ToUnit(VolumeUnit.Deciliter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Deciliter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.DeciusGallon, q => q.ToUnit(VolumeUnit.DeciusGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.DeciusGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.HectocubicFoot, q => q.ToUnit(VolumeUnit.HectocubicFoot));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.HectocubicFoot, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.HectocubicMeter, q => q.ToUnit(VolumeUnit.HectocubicMeter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.HectocubicMeter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Hectoliter, q => q.ToUnit(VolumeUnit.Hectoliter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Hectoliter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.HectousGallon, q => q.ToUnit(VolumeUnit.HectousGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.HectousGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.ImperialBeerBarrel, q => q.ToUnit(VolumeUnit.ImperialBeerBarrel));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.ImperialBeerBarrel, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.ImperialGallon, q => q.ToUnit(VolumeUnit.ImperialGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.ImperialGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.ImperialOunce, q => q.ToUnit(VolumeUnit.ImperialOunce));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.ImperialOunce, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.ImperialPint, q => q.ToUnit(VolumeUnit.ImperialPint));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.ImperialPint, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.KilocubicFoot, q => q.ToUnit(VolumeUnit.KilocubicFoot));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.KilocubicFoot, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.KilocubicMeter, q => q.ToUnit(VolumeUnit.KilocubicMeter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.KilocubicMeter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.KiloimperialGallon, q => q.ToUnit(VolumeUnit.KiloimperialGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.KiloimperialGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Kiloliter, q => q.ToUnit(VolumeUnit.Kiloliter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Kiloliter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.KilousGallon, q => q.ToUnit(VolumeUnit.KilousGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.KilousGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Liter, q => q.ToUnit(VolumeUnit.Liter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Liter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.MegacubicFoot, q => q.ToUnit(VolumeUnit.MegacubicFoot));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.MegacubicFoot, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.MegaimperialGallon, q => q.ToUnit(VolumeUnit.MegaimperialGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.MegaimperialGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Megaliter, q => q.ToUnit(VolumeUnit.Megaliter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Megaliter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.MegausGallon, q => q.ToUnit(VolumeUnit.MegausGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.MegausGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.MetricCup, q => q.ToUnit(VolumeUnit.MetricCup));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.MetricCup, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.MetricTeaspoon, q => q.ToUnit(VolumeUnit.MetricTeaspoon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.MetricTeaspoon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Microliter, q => q.ToUnit(VolumeUnit.Microliter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Microliter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.Milliliter, q => q.ToUnit(VolumeUnit.Milliliter));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.Milliliter, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.OilBarrel, q => q.ToUnit(VolumeUnit.OilBarrel));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.OilBarrel, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UkTablespoon, q => q.ToUnit(VolumeUnit.UkTablespoon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UkTablespoon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsBeerBarrel, q => q.ToUnit(VolumeUnit.UsBeerBarrel));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsBeerBarrel, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsCustomaryCup, q => q.ToUnit(VolumeUnit.UsCustomaryCup));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsCustomaryCup, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsGallon, q => q.ToUnit(VolumeUnit.UsGallon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsGallon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsLegalCup, q => q.ToUnit(VolumeUnit.UsLegalCup));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsLegalCup, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsOunce, q => q.ToUnit(VolumeUnit.UsOunce));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsOunce, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsPint, q => q.ToUnit(VolumeUnit.UsPint));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsPint, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsQuart, q => q.ToUnit(VolumeUnit.UsQuart));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsQuart, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsTablespoon, q => q.ToUnit(VolumeUnit.UsTablespoon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsTablespoon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Volume<T>>(Volume<T>.BaseUnit, VolumeUnit.UsTeaspoon, q => q.ToUnit(VolumeUnit.UsTeaspoon));
+            unitConverter.SetConversionFunction<Volume<T>>(VolumeUnit.UsTeaspoon, Volume<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.CentilitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.CentilitersPerLiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.CentilitersPerLiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.CentilitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.CentilitersPerMililiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.CentilitersPerMililiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.DecilitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.DecilitersPerLiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.DecilitersPerLiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.DecilitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.DecilitersPerMililiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.DecilitersPerMililiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentration<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.LitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.LitersPerLiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.LitersPerLiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.LitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.LitersPerMililiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.LitersPerMililiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.MicrolitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.MicrolitersPerLiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.MicrolitersPerLiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.MicrolitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.MicrolitersPerMililiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.MicrolitersPerMililiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.MillilitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.MillilitersPerLiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.MillilitersPerLiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.MillilitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.MillilitersPerMililiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.MillilitersPerMililiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.NanolitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.NanolitersPerLiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.NanolitersPerLiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.NanolitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.NanolitersPerMililiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.NanolitersPerMililiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.PartPerBillion, q => q.ToUnit(VolumeConcentrationUnit.PartPerBillion));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.PartPerBillion, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.PartPerMillion, q => q.ToUnit(VolumeConcentrationUnit.PartPerMillion));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.PartPerMillion, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.PartPerThousand, q => q.ToUnit(VolumeConcentrationUnit.PartPerThousand));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.PartPerThousand, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.PartPerTrillion, q => q.ToUnit(VolumeConcentrationUnit.PartPerTrillion));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.PartPerTrillion, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.Percent, q => q.ToUnit(VolumeConcentrationUnit.Percent));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.Percent, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.PicolitersPerLiter, q => q.ToUnit(VolumeConcentrationUnit.PicolitersPerLiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.PicolitersPerLiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentration<T>.BaseUnit, VolumeConcentrationUnit.PicolitersPerMililiter, q => q.ToUnit(VolumeConcentrationUnit.PicolitersPerMililiter));
+            unitConverter.SetConversionFunction<VolumeConcentration<T>>(VolumeConcentrationUnit.PicolitersPerMililiter, VolumeConcentration<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.AcreFootPerDay, q => q.ToUnit(VolumeFlowUnit.AcreFootPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.AcreFootPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.AcreFootPerHour, q => q.ToUnit(VolumeFlowUnit.AcreFootPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.AcreFootPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.AcreFootPerMinute, q => q.ToUnit(VolumeFlowUnit.AcreFootPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.AcreFootPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.AcreFootPerSecond, q => q.ToUnit(VolumeFlowUnit.AcreFootPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.AcreFootPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CentiliterPerDay, q => q.ToUnit(VolumeFlowUnit.CentiliterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CentiliterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CentiliterPerMinute, q => q.ToUnit(VolumeFlowUnit.CentiliterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CentiliterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CentiliterPerSecond, q => q.ToUnit(VolumeFlowUnit.CentiliterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CentiliterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicCentimeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicCentimeterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicCentimeterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicDecimeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicDecimeterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicFootPerHour, q => q.ToUnit(VolumeFlowUnit.CubicFootPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicFootPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicFootPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicFootPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicFootPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicFootPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicFootPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicFootPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicMeterPerDay, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicMeterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicMeterPerHour, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicMeterPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicMeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlow<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicMillimeterPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicMillimeterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicYardPerDay, q => q.ToUnit(VolumeFlowUnit.CubicYardPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicYardPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicYardPerHour, q => q.ToUnit(VolumeFlowUnit.CubicYardPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicYardPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicYardPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicYardPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicYardPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.CubicYardPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicYardPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.CubicYardPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.DeciliterPerDay, q => q.ToUnit(VolumeFlowUnit.DeciliterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.DeciliterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.DeciliterPerMinute, q => q.ToUnit(VolumeFlowUnit.DeciliterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.DeciliterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.DeciliterPerSecond, q => q.ToUnit(VolumeFlowUnit.DeciliterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.DeciliterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.KiloliterPerDay, q => q.ToUnit(VolumeFlowUnit.KiloliterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.KiloliterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.KiloliterPerMinute, q => q.ToUnit(VolumeFlowUnit.KiloliterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.KiloliterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.KiloliterPerSecond, q => q.ToUnit(VolumeFlowUnit.KiloliterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.KiloliterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.KilousGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.KilousGallonPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.LiterPerDay, q => q.ToUnit(VolumeFlowUnit.LiterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.LiterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.LiterPerHour, q => q.ToUnit(VolumeFlowUnit.LiterPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.LiterPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.LiterPerMinute, q => q.ToUnit(VolumeFlowUnit.LiterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.LiterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.LiterPerSecond, q => q.ToUnit(VolumeFlowUnit.LiterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.LiterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MegaliterPerDay, q => q.ToUnit(VolumeFlowUnit.MegaliterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MegaliterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MegaukGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.MegaukGallonPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MicroliterPerDay, q => q.ToUnit(VolumeFlowUnit.MicroliterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MicroliterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MicroliterPerMinute, q => q.ToUnit(VolumeFlowUnit.MicroliterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MicroliterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MicroliterPerSecond, q => q.ToUnit(VolumeFlowUnit.MicroliterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MicroliterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MilliliterPerDay, q => q.ToUnit(VolumeFlowUnit.MilliliterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MilliliterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MilliliterPerMinute, q => q.ToUnit(VolumeFlowUnit.MilliliterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MilliliterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MilliliterPerSecond, q => q.ToUnit(VolumeFlowUnit.MilliliterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MilliliterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.MillionUsGallonsPerDay, q => q.ToUnit(VolumeFlowUnit.MillionUsGallonsPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.MillionUsGallonsPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.NanoliterPerDay, q => q.ToUnit(VolumeFlowUnit.NanoliterPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.NanoliterPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.NanoliterPerMinute, q => q.ToUnit(VolumeFlowUnit.NanoliterPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.NanoliterPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.NanoliterPerSecond, q => q.ToUnit(VolumeFlowUnit.NanoliterPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.NanoliterPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.OilBarrelPerDay, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.OilBarrelPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.OilBarrelPerHour, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.OilBarrelPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.OilBarrelPerMinute, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.OilBarrelPerSecond, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UkGallonPerDay, q => q.ToUnit(VolumeFlowUnit.UkGallonPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UkGallonPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UkGallonPerHour, q => q.ToUnit(VolumeFlowUnit.UkGallonPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UkGallonPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UkGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.UkGallonPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UkGallonPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UkGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.UkGallonPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UkGallonPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UsGallonPerDay, q => q.ToUnit(VolumeFlowUnit.UsGallonPerDay));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UsGallonPerDay, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UsGallonPerHour, q => q.ToUnit(VolumeFlowUnit.UsGallonPerHour));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UsGallonPerHour, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UsGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.UsGallonPerMinute));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UsGallonPerMinute, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlow<T>.BaseUnit, VolumeFlowUnit.UsGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.UsGallonPerSecond));
+            unitConverter.SetConversionFunction<VolumeFlow<T>>(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLength<T>.BaseUnit, VolumePerLength<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLength<T>.BaseUnit, VolumePerLengthUnit.CubicYardPerFoot, q => q.ToUnit(VolumePerLengthUnit.CubicYardPerFoot));
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLengthUnit.CubicYardPerFoot, VolumePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLength<T>.BaseUnit, VolumePerLengthUnit.CubicYardPerUsSurveyFoot, q => q.ToUnit(VolumePerLengthUnit.CubicYardPerUsSurveyFoot));
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLengthUnit.CubicYardPerUsSurveyFoot, VolumePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLength<T>.BaseUnit, VolumePerLengthUnit.LiterPerKilometer, q => q.ToUnit(VolumePerLengthUnit.LiterPerKilometer));
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLengthUnit.LiterPerKilometer, VolumePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLength<T>.BaseUnit, VolumePerLengthUnit.LiterPerMeter, q => q.ToUnit(VolumePerLengthUnit.LiterPerMeter));
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLengthUnit.LiterPerMeter, VolumePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLength<T>.BaseUnit, VolumePerLengthUnit.LiterPerMillimeter, q => q.ToUnit(VolumePerLengthUnit.LiterPerMillimeter));
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLengthUnit.LiterPerMillimeter, VolumePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLength<T>.BaseUnit, VolumePerLengthUnit.OilBarrelPerFoot, q => q.ToUnit(VolumePerLengthUnit.OilBarrelPerFoot));
+            unitConverter.SetConversionFunction<VolumePerLength<T>>(VolumePerLengthUnit.OilBarrelPerFoot, VolumePerLength<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertia<T>.BaseUnit, WarpingMomentOfInertiaUnit.CentimeterToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.CentimeterToTheSixth));
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertiaUnit.CentimeterToTheSixth, WarpingMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertia<T>.BaseUnit, WarpingMomentOfInertiaUnit.DecimeterToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.DecimeterToTheSixth));
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertiaUnit.DecimeterToTheSixth, WarpingMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertia<T>.BaseUnit, WarpingMomentOfInertiaUnit.FootToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.FootToTheSixth));
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertiaUnit.FootToTheSixth, WarpingMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertia<T>.BaseUnit, WarpingMomentOfInertiaUnit.InchToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.InchToTheSixth));
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertiaUnit.InchToTheSixth, WarpingMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertia<T>.BaseUnit, WarpingMomentOfInertia<T>.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertia<T>.BaseUnit, WarpingMomentOfInertiaUnit.MillimeterToTheSixth, q => q.ToUnit(WarpingMomentOfInertiaUnit.MillimeterToTheSixth));
+            unitConverter.SetConversionFunction<WarpingMomentOfInertia<T>>(WarpingMomentOfInertiaUnit.MillimeterToTheSixth, WarpingMomentOfInertia<T>.BaseUnit, q => q.ToBaseUnit());
         }
     }
 }
diff --git a/UnitsNet/IQuantity.cs b/UnitsNet/IQuantity.cs
index 9146fe083a..80f40ee2cc 100644
--- a/UnitsNet/IQuantity.cs
+++ b/UnitsNet/IQuantity.cs
@@ -32,7 +32,7 @@ public interface IQuantity : IFormattable
         /// <summary>
         ///     Gets the value in the given unit.
         /// </summary>
-        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length"/> you should provide a <see cref="LengthUnit"/> value.</param>
+        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length{T}"/> you should provide a <see cref="LengthUnit"/> value.</param>
         /// <returns>Value converted to the specified unit.</returns>
         /// <exception cref="InvalidCastException">Wrong unit enum type was given.</exception>
         double As(Enum unit);
@@ -58,7 +58,7 @@ public interface IQuantity : IFormattable
         /// <summary>
         ///     Converts to a quantity with the given unit representation, which affects things like <see cref="IQuantity.ToString(System.IFormatProvider)"/>.
         /// </summary>
-        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length"/> you should provide a <see cref="LengthUnit"/> value.</param>
+        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length{T}"/> you should provide a <see cref="LengthUnit"/> value.</param>
         /// <returns>A new quantity with the given unit.</returns>
         IQuantity ToUnit(Enum unit);
 
diff --git a/UnitsNet/IQuantityT.cs b/UnitsNet/IQuantityT.cs
new file mode 100644
index 0000000000..51e62cc836
--- /dev/null
+++ b/UnitsNet/IQuantityT.cs
@@ -0,0 +1,81 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+
+namespace UnitsNet
+{
+    /// <summary>
+    ///     Represents a quantity.
+    /// </summary>
+    public interface IQuantityT<T> : IQuantity
+    {
+        /// <summary>
+        ///     Gets the value in the given unit.
+        /// </summary>
+        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length{T}"/> you should provide a <see cref="LengthUnit"/> value.</param>
+        /// <returns>Value converted to the specified unit.</returns>
+        /// <exception cref="InvalidCastException">Wrong unit enum type was given.</exception>
+        new T As( Enum unit );
+
+        /// <summary>
+        ///     Gets the value in the unit determined by the given <see cref="UnitSystem"/>. If multiple units were found for the given <see cref="UnitSystem"/>,
+        ///     the first match will be used.
+        /// </summary>
+        /// <param name="unitSystem">The <see cref="UnitSystem"/> to convert the quantity value to.</param>
+        /// <returns>The converted value.</returns>
+        new T As( UnitSystem unitSystem );
+
+        /// <summary>
+        ///     The value this quantity was constructed with. See also <see cref="IQuantity.Unit"/>.
+        /// </summary>
+        new T Value { get; }
+
+        /// <summary>
+        ///     Converts to a quantity with the given unit representation, which affects things like <see cref="IQuantity.ToString(System.IFormatProvider)"/>.
+        /// </summary>
+        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length{T}"/> you should provide a <see cref="LengthUnit"/> value.</param>
+        /// <returns>A new quantity with the given unit.</returns>
+        new IQuantityT<T> ToUnit( Enum unit );
+
+        /// <summary>
+        ///     Converts to a quantity with a unit determined by the given <see cref="UnitSystem"/>, which affects things like <see cref="IQuantity.ToString(System.IFormatProvider)"/>.
+        ///     If multiple units were found for the given <see cref="UnitSystem"/>, the first match will be used.
+        /// </summary>
+        /// <param name="unitSystem">The <see cref="UnitSystem"/> to convert the quantity to.</param>
+        /// <returns>A new quantity with the determined unit.</returns>
+        new IQuantityT<T> ToUnit( UnitSystem unitSystem );
+    }
+
+    /// <summary>
+    ///     A stronger typed interface where the unit enum type is known, to avoid passing in the
+    ///     wrong unit enum type and not having to cast from <see cref="Enum"/>.
+    /// </summary>
+    /// <example>
+    ///     IQuantity{LengthUnit} length;
+    ///     double centimeters = length.As(LengthUnit.Centimeter); // Type safety on enum type
+    /// </example>
+    public interface IQuantityT<TUnitType, T> : IQuantity<TUnitType> where TUnitType : Enum
+    {
+        /// <summary>
+        ///     Convert to a unit representation <typeparamref name="TUnitType"/>.
+        /// </summary>
+        /// <returns>Value converted to the specified unit.</returns>
+        new T As( TUnitType unit );
+
+        /// <summary>
+        ///     Converts to a quantity with the given unit representation, which affects things like <see cref="IQuantity.ToString(System.IFormatProvider)"/>.
+        /// </summary>
+        /// <param name="unit">The unit enum value.</param>
+        /// <returns>A new quantity with the given unit.</returns>
+        new IQuantityT<TUnitType, T> ToUnit( TUnitType unit );
+
+        /// <summary>
+        ///     Converts to a quantity with a unit determined by the given <see cref="UnitSystem"/>, which affects things like <see cref="IQuantity.ToString(System.IFormatProvider)"/>.
+        ///     If multiple units were found for the given <see cref="UnitSystem"/>, the first match will be used.
+        /// </summary>
+        /// <param name="unitSystem">The <see cref="UnitSystem"/> to convert the quantity to.</param>
+        /// <returns>A new quantity with the determined unit.</returns>
+        new IQuantityT<TUnitType, T> ToUnit( UnitSystem unitSystem );
+    }
+}
diff --git a/UnitsNet/InternalHelpers/GenericNumberHelper.cs b/UnitsNet/InternalHelpers/GenericNumberHelper.cs
new file mode 100644
index 0000000000..ad9dce0565
--- /dev/null
+++ b/UnitsNet/InternalHelpers/GenericNumberHelper.cs
@@ -0,0 +1,43 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+
+namespace UnitsNet.InternalHelpers
+{
+    /// <summary>
+    /// Helpers for working with generic numbers.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class GenericNumberHelper<T> where T : struct
+    {
+        private static readonly Dictionary<Type, GenericNumberInfo> TypeToInfo;
+
+        static GenericNumberHelper()
+        {
+            TypeToInfo = new Dictionary<Type, GenericNumberInfo>
+            {
+                {typeof(int), new GenericNumberInfo(int.MaxValue, int.MinValue)},
+                {typeof(long), new GenericNumberInfo(long.MaxValue, long.MinValue)},
+                {typeof(double), new GenericNumberInfo(double.MaxValue, double.MinValue)},
+                {typeof(decimal), new GenericNumberInfo(decimal.MaxValue, decimal.MinValue)},
+            };
+        }
+
+        public static T MaxValue => (T) TypeToInfo[typeof(T)].MaxValue;
+        public static T MinValue => (T) TypeToInfo[typeof(T)].MinValue;
+
+        private class GenericNumberInfo
+        {
+            public GenericNumberInfo(object maxValue, object minValue)
+            {
+                MaxValue = maxValue;
+                MinValue = minValue;
+            }
+
+            public object MaxValue { get; }
+            public object MinValue { get; }
+        }
+    }
+}
diff --git a/UnitsNet/QuantityInfo.cs b/UnitsNet/QuantityInfo.cs
index a33616b687..c7a5affbed 100644
--- a/UnitsNet/QuantityInfo.cs
+++ b/UnitsNet/QuantityInfo.cs
@@ -23,7 +23,7 @@ public class QuantityInfo
     {
         private static readonly string UnitEnumNamespace = typeof(LengthUnit).Namespace;
 
-        private static readonly Type[] UnitEnumTypes = typeof(Length)
+        private static readonly Type[] UnitEnumTypes = typeof(Length<double>)
             .Wrap()
             .Assembly
             .GetExportedTypes()
@@ -121,7 +121,7 @@ public QuantityInfo([NotNull] string name, [NotNull] UnitInfo[] unitInfos, [NotN
         public Enum BaseUnit { get; }
 
         /// <summary>
-        ///     Zero value of quantity, such as <see cref="Length.Zero" />.
+        ///     Zero value of quantity, such as <see cref="Length{T}.Zero" />.
         /// </summary>
         public IQuantity Zero { get; }
 
@@ -131,7 +131,7 @@ public QuantityInfo([NotNull] string name, [NotNull] UnitInfo[] unitInfos, [NotN
         public Type UnitType { get; }
 
         /// <summary>
-        ///     Quantity value type, such as <see cref="Length"/> or <see cref="Mass"/>.
+        ///     Quantity value type, such as <see cref="Length{T}"/> or <see cref="Mass{T}"/>.
         /// </summary>
         public Type ValueType { get; }
 
@@ -186,8 +186,8 @@ public IEnumerable<UnitInfo> GetUnitInfosFor(BaseUnits baseUnits)
     /// <inheritdoc cref="QuantityInfo" />
     /// <remarks>
     ///     This is a specialization of <see cref="QuantityInfo" />, for when the unit type is known.
-    ///     Typically you obtain this by looking it up statically from <see cref="Length.Info" /> or
-    ///     <see cref="Length.QuantityInfo" />, or dynamically via <see cref="IQuantity{TUnitType}.QuantityInfo" />.
+    ///     Typically you obtain this by looking it up statically from <see cref="Length{T}.Info" /> or
+    ///     <see cref="Length{T}.QuantityInfo" />, or dynamically via <see cref="IQuantity{TUnitType}.QuantityInfo" />.
     /// </remarks>
     /// <typeparam name="TUnit">The unit enum type, such as <see cref="LengthUnit" />. </typeparam>
     public class QuantityInfo<TUnit> : QuantityInfo
diff --git a/UnitsNet/QuantityNotFoundException.cs b/UnitsNet/QuantityNotFoundException.cs
index 78ce500b9e..ec813e5103 100644
--- a/UnitsNet/QuantityNotFoundException.cs
+++ b/UnitsNet/QuantityNotFoundException.cs
@@ -7,7 +7,7 @@ namespace UnitsNet
 {
     /// <summary>
     ///     Quantity type was not found. This is typically thrown for dynamic conversions,
-    ///     such as <see cref="UnitConverter.ConvertByName" />.
+    ///     such as <see cref="UnitConverter{T}.ConvertByName" />.
     /// </summary>
     [Obsolete("")]
     public class QuantityNotFoundException : UnitsNetException
diff --git a/UnitsNet/QuantityTypeConverter.cs b/UnitsNet/QuantityTypeConverter.cs
index dbbe2865ae..1a95efd8a8 100644
--- a/UnitsNet/QuantityTypeConverter.cs
+++ b/UnitsNet/QuantityTypeConverter.cs
@@ -80,7 +80,7 @@ public DisplayAsUnitAttribute(object unitType, string format = "") : base(unitTy
     /// </para>
     ///   <para>For basic understanding of TypeConverters consult the .NET documentation.</para>
     /// </summary>
-    /// <typeparam name="TQuantity">Quantity value type, such as <see cref="Length"/> or <see cref="Mass"/>.</typeparam>
+    /// <typeparam name="TQuantity">Quantity value type, such as <see cref="Length{T}"/> or <see cref="Mass{T}"/>.</typeparam>
     /// <remarks>
     /// <para>
     ///     When a string is converted a Quantity the unit given by the string is used.
@@ -148,7 +148,7 @@ public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceT
             if (attribute?.UnitType != null)
             {
                 string converterQuantityName = default(TQuantity).QuantityInfo.Name;
-                string attributeQuantityName = Quantity.From(1, attribute.UnitType).QuantityInfo.Name;
+                string attributeQuantityName = Quantity.From<double>(1, attribute.UnitType).QuantityInfo.Name;
                 if (converterQuantityName != attributeQuantityName)
                 {
                     throw new ArgumentException($"The {attribute.GetType()}'s UnitType [{attribute.UnitType}] is not compatible with the converter's quantity [{converterQuantityName}].");
@@ -177,11 +177,11 @@ public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo c
                 {
                     var defaultUnit = GetAttribute<DefaultUnitAttribute>(context) ?? new DefaultUnitAttribute(default(TQuantity).Unit);
                     if(defaultUnit.UnitType != null)
-                        quantity = Quantity.From(dvalue, defaultUnit.UnitType);
+                        quantity = Quantity.From<double>(dvalue, defaultUnit.UnitType);
                 }
                 else
                 {
-                    quantity = Quantity.Parse(culture, typeof(TQuantity), stringValue);
+                    quantity = Quantity.Parse<double>(culture, typeof(TQuantity), stringValue);
                 }
 
                 if( quantity != null )
diff --git a/UnitsNet/QuantityValue.cs b/UnitsNet/QuantityValue.cs
index 6e6bd88430..32daafa47c 100644
--- a/UnitsNet/QuantityValue.cs
+++ b/UnitsNet/QuantityValue.cs
@@ -1,6 +1,7 @@
 // Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
+using System;
 using UnitsNet.InternalHelpers;
 
 namespace UnitsNet
@@ -89,6 +90,16 @@ public static explicit operator decimal(QuantityValue number)
 
         #endregion
 
+        /// <summary>
+        /// Converts the value to type T.
+        /// </summary>
+        /// <typeparam name="T">The type to convert to.</typeparam>
+        /// <returns>The value as T.</returns>
+        public T ConvertTo<T>()
+        {
+            return _value.HasValue ? (T)Convert.ChangeType(_value, typeof(T)) : (T)Convert.ChangeType(_valueDecimal, typeof(T));
+        }
+
         /// <summary>Returns the string representation of the numeric value.</summary>
         public override string ToString()
         {
diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs
index 09f55f3255..6e689db8b2 100644
--- a/UnitsNet/UnitConverter.cs
+++ b/UnitsNet/UnitConverter.cs
@@ -32,19 +32,19 @@ public delegate TQuantity ConversionFunction<TQuantity>(TQuantity inputValue)
     ///     Convert between units of a quantity, such as converting from meters to centimeters of a given length.
     /// </summary>
     [PublicAPI]
-    public sealed partial class UnitConverter
+    public sealed partial class UnitConverter<T>
     {
         /// <summary>
         /// The static instance used by Units.NET to convert between units. Modify this to add/remove conversion functions at runtime, such
         /// as adding your own third-party units and quantities to convert between.
         /// </summary>
-        public static UnitConverter Default { get; }
+        public static UnitConverter<T> Default { get; }
 
         private readonly Dictionary<ConversionFunctionLookupKey, ConversionFunction> _conversionFunctions = new Dictionary<ConversionFunctionLookupKey, ConversionFunction>();
 
         static UnitConverter()
         {
-            Default = new UnitConverter();
+            Default = new UnitConverter<T>();
             RegisterDefaultConversions(Default);
         }
 
@@ -237,7 +237,7 @@ public bool TryGetConversionFunction(ConversionFunctionLookupKey lookupKey, out
         public static double Convert(QuantityValue fromValue, Enum fromUnitValue, Enum toUnitValue)
         {
             return Quantity
-                .From(fromValue, fromUnitValue)
+                .From<T>( fromValue, fromUnitValue)
                 .As(toUnitValue);
         }
 
@@ -252,7 +252,7 @@ public static double Convert(QuantityValue fromValue, Enum fromUnitValue, Enum t
         public static bool TryConvert(QuantityValue fromValue, Enum fromUnitValue, Enum toUnitValue, out double convertedValue)
         {
             convertedValue = 0;
-            if (!Quantity.TryFrom(fromValue, fromUnitValue, out IQuantity? fromQuantity))
+            if (!Quantity.TryFrom<T>(fromValue, fromUnitValue, out IQuantity? fromQuantity))
                 return false;
 
             try
@@ -432,7 +432,7 @@ public static double ConvertByAbbreviation(QuantityValue fromValue, string quant
             var cultureInfo = string.IsNullOrWhiteSpace(culture) ? CultureInfo.CurrentUICulture : new CultureInfo(culture);
 
             var fromUnit = UnitParser.Default.Parse(fromUnitAbbrev, unitType!, cultureInfo); // ex: ("m", LengthUnit) => LengthUnit.Meter
-            var fromQuantity = Quantity.From(fromValue, fromUnit);
+            var fromQuantity = Quantity.From<T>( fromValue, fromUnit);
 
             var toUnit = UnitParser.Default.Parse(toUnitAbbrev, unitType!, cultureInfo); // ex:("cm", LengthUnit) => LengthUnit.Centimeter
             return fromQuantity.As(toUnit);
@@ -514,7 +514,7 @@ public static bool TryConvertByAbbreviation(QuantityValue fromValue, string quan
             if (!UnitParser.Default.TryParse(toUnitAbbrev, unitType!, cultureInfo, out Enum? toUnit)) // ex:("cm", LengthUnit) => LengthUnit.Centimeter
                 return false;
 
-            var fromQuantity = Quantity.From(fromValue, fromUnit!);
+            var fromQuantity = Quantity.From<T>(fromValue, fromUnit!);
             result = fromQuantity.As(toUnit!);
 
             return true;
diff --git a/UnitsNet/UnitMath.cs b/UnitsNet/UnitMath.cs
index d684c77e66..9eb799977a 100644
--- a/UnitsNet/UnitMath.cs
+++ b/UnitsNet/UnitMath.cs
@@ -30,10 +30,10 @@ public static TQuantity Abs<TQuantity>(this TQuantity value) where TQuantity : I
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> source, Enum unitType)
+        public static TQuantity Sum<TQuantity, T>(this IEnumerable<TQuantity> source, Enum unitType)
             where TQuantity : IQuantity
         {
-            return (TQuantity) Quantity.From(source.Sum(x => x.As(unitType)), unitType);
+            return (TQuantity) Quantity.From<T>( source.Sum(x => x.As(unitType)), unitType);
         }
 
         /// <summary>
@@ -45,6 +45,7 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> source, Enum
         /// <param name="unitType">The desired unit type for the resulting quantity</param>
         /// <typeparam name="TSource">The type of the elements of source.</typeparam>
         /// <typeparam name="TQuantity">The type of quantity that is produced by this operation</typeparam>
+        /// <typeparam name="T">The type of the quantity value (float, double, decimal, etc.)</typeparam>
         /// <returns>The sum of the projected values, represented in the specified unit type.</returns>
         /// <exception cref="T:System.ArgumentNullException">
         ///     <paramref name="source">source</paramref> or <paramref name="selector">selector</paramref> is null.
@@ -52,10 +53,10 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> source, Enum
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Sum<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
+        public static TQuantity Sum<TSource, TQuantity, T>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
             where TQuantity : IQuantity
         {
-            return source.Select(selector).Sum(unitType);
+            return source.Select(selector).Sum<TQuantity, T>(unitType);
         }
 
         /// <summary>Returns the smaller of two <typeparamref name="TQuantity" /> values.</summary>
@@ -79,10 +80,10 @@ public static TQuantity Min<TQuantity>(TQuantity val1, TQuantity val2) where TQu
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Min<TQuantity>(this IEnumerable<TQuantity> source, Enum unitType)
+        public static TQuantity Min<TQuantity, T>(this IEnumerable<TQuantity> source, Enum unitType)
             where TQuantity : IQuantity
         {
-            return (TQuantity) Quantity.From(source.Min(x => x.As(unitType)), unitType);
+            return (TQuantity) Quantity.From<T>( source.Min(x => x.As(unitType)), unitType);
         }
 
         /// <summary>
@@ -94,6 +95,7 @@ public static TQuantity Min<TQuantity>(this IEnumerable<TQuantity> source, Enum
         /// <param name="unitType">The desired unit type for the resulting quantity</param>
         /// <typeparam name="TSource">The type of the elements of source.</typeparam>
         /// <typeparam name="TQuantity">The type of quantity that is produced by this operation</typeparam>
+        /// <typeparam name="T">The type of the quantity value (float, double, decimal, etc.)</typeparam>
         /// <returns>The min of the projected values, represented in the specified unit type.</returns>
         /// <exception cref="T:System.ArgumentNullException">
         ///     <paramref name="source">source</paramref> or <paramref name="selector">selector</paramref> is null.
@@ -102,10 +104,10 @@ public static TQuantity Min<TQuantity>(this IEnumerable<TQuantity> source, Enum
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Min<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
+        public static TQuantity Min<TSource, TQuantity, T>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
             where TQuantity : IQuantity
         {
-            return source.Select(selector).Min(unitType);
+            return source.Select(selector).Min<TQuantity,T>(unitType);
         }
 
         /// <summary>Returns the larger of two <typeparamref name="TQuantity" /> values.</summary>
@@ -129,10 +131,10 @@ public static TQuantity Max<TQuantity>(TQuantity val1, TQuantity val2) where TQu
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Max<TQuantity>(this IEnumerable<TQuantity> source, Enum unitType)
+        public static TQuantity Max<TQuantity, T>(this IEnumerable<TQuantity> source, Enum unitType)
             where TQuantity : IQuantity
         {
-            return (TQuantity) Quantity.From(source.Max(x => x.As(unitType)), unitType);
+            return (TQuantity) Quantity.From<T>( source.Max(x => x.As(unitType)), unitType);
         }
 
         /// <summary>
@@ -144,6 +146,7 @@ public static TQuantity Max<TQuantity>(this IEnumerable<TQuantity> source, Enum
         /// <param name="unitType">The desired unit type for the resulting quantity</param>
         /// <typeparam name="TSource">The type of the elements of source.</typeparam>
         /// <typeparam name="TQuantity">The type of quantity that is produced by this operation</typeparam>
+        /// <typeparam name="T">The type of the quantity value (float, double, decimal, etc.)</typeparam>
         /// <returns>The max of the projected values, represented in the specified unit type.</returns>
         /// <exception cref="T:System.ArgumentNullException">
         ///     <paramref name="source">source</paramref> or <paramref name="selector">selector</paramref> is null.
@@ -152,10 +155,10 @@ public static TQuantity Max<TQuantity>(this IEnumerable<TQuantity> source, Enum
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Max<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
+        public static TQuantity Max<TSource, TQuantity, T>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
             where TQuantity : IQuantity
         {
-            return source.Select(selector).Max(unitType);
+            return source.Select(selector).Max<TQuantity,T>(unitType);
         }
 
         /// <summary>Computes the average of a sequence of <typeparamref name="TQuantity" /> values.</summary>
@@ -169,10 +172,10 @@ public static TQuantity Max<TSource, TQuantity>(this IEnumerable<TSource> source
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Average<TQuantity>(this IEnumerable<TQuantity> source, Enum unitType)
+        public static TQuantity Average<TQuantity, T>(this IEnumerable<TQuantity> source, Enum unitType)
             where TQuantity : IQuantity
         {
-            return (TQuantity) Quantity.From(source.Average(x => x.As(unitType)), unitType);
+            return (TQuantity) Quantity.From<T>( source.Average(x => x.As(unitType)), unitType);
         }
 
         /// <summary>
@@ -184,6 +187,7 @@ public static TQuantity Average<TQuantity>(this IEnumerable<TQuantity> source, E
         /// <param name="unitType">The desired unit type for the resulting quantity</param>
         /// <typeparam name="TSource">The type of the elements of source.</typeparam>
         /// <typeparam name="TQuantity">The type of quantity that is produced by this operation</typeparam>
+        /// <typeparam name="T">The type of the quantity value (float, double, decimal, etc.)</typeparam>
         /// <returns>The average of the projected values, represented in the specified unit type.</returns>
         /// <exception cref="T:System.ArgumentNullException">
         ///     <paramref name="source">source</paramref> or <paramref name="selector">selector</paramref> is null.
@@ -192,10 +196,10 @@ public static TQuantity Average<TQuantity>(this IEnumerable<TQuantity> source, E
         /// <exception cref="ArgumentException">
         ///     <paramref name="source">source</paramref> contains quantity types different from <paramref name="unitType" />.
         /// </exception>
-        public static TQuantity Average<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
+        public static TQuantity Average<TSource, TQuantity, T>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, Enum unitType)
             where TQuantity : IQuantity
         {
-            return source.Select(selector).Average(unitType);
+            return source.Select(selector).Average<TQuantity, T>( unitType);
         }
     }
 }
diff --git a/UnitsNet/UnitNotFoundException.cs b/UnitsNet/UnitNotFoundException.cs
index 0a1001e273..e15c9a062c 100644
--- a/UnitsNet/UnitNotFoundException.cs
+++ b/UnitsNet/UnitNotFoundException.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -7,7 +7,7 @@ namespace UnitsNet
 {
     /// <summary>
     ///     Unit was not found. This is typically thrown for dynamic conversions,
-    ///     such as <see cref="UnitConverter.ConvertByName" />.
+    ///     such as <see cref="UnitConverter{T}.ConvertByName" />.
     /// </summary>
     public class UnitNotFoundException : UnitsNetException
     {
diff --git a/UnitsNet/UnitsNet.csproj b/UnitsNet/UnitsNet.csproj
index c16b0cbccb..3597d9de13 100644
--- a/UnitsNet/UnitsNet.csproj
+++ b/UnitsNet/UnitsNet.csproj
@@ -60,7 +60,7 @@
 
   <!-- Files to include in nuget package -->
   <ItemGroup>
-    <None Include="../Docs/Images/logo-32.png" Pack="true" PackagePath="/"/>
+    <None Include="../Docs/Images/logo-32.png" Pack="true" PackagePath="/" />
   </ItemGroup>
 
 </Project>